GATOR — AI-Powered Orchestration System

// apps/core/src/index.ts — Hono server setup
import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { logger } from 'hono/logger';
import { authMiddleware } from './middleware/auth';
import { chatRouter } from './routes/chat';
import { wsRouter } from './routes/ws';

const app = new Hono();

// Global middleware
app.use('*', logger());
app.use('*', cors({ origin: '*', credentials: true }));

// Routes
app.get('/health', (c) => c.json({ status: 'ok', uptime: process.uptime() }));
app.route('/api/chat', chatRouter);
app.route('/api/ws', wsRouter);

// Start with tsx — no compilation needed
export default app;

// packages/database/src/schema.ts — Drizzle schema
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';

export const devices = sqliteTable('devices', {
  id: text('id').primaryKey(),
  name: text('name').notNull(),
  platform: text('platform').notNull(),
  isActive: integer('is_active').default(1),
  lastSeen: integer('last_seen'),
  createdAt: integer('created_at').notNull(),
});

export const tasks = sqliteTable('tasks', {
  id: text('id').primaryKey(),
  deviceId: text('device_id').notNull(),
  intent: text('intent').notNull(),
  status: text('status').notNull(),
  priority: text('priority').default('medium'),
  result: text('result'),
  createdAt: integer('created_at').notNull(),
  completedAt: integer('completed_at'),
});

// packages/queue/src/priority-queue.ts
type Task = {
  id: string;
  priority: 'low' | 'medium' | 'high';
  payload: unknown;
  createdAt: number;
};

class PriorityQueue {
  private queues = {
    high: [] as Task[],
    medium: [] as Task[],
    low: [] as Task[],
  };

  async enqueue(task: Task): Promise<void> {
    this.queues[task.priority].push(task);
    // Persist to SQLite for restart recovery
    await db.insert(tasks).values(task);
  }

  async dequeue(): Promise<Task | undefined> {
    for (const priority of ['high', 'medium', 'low'] as const) {
      const task = this.queues[priority].shift();
      if (task) return task;
    }
    return undefined;
  }
}

User: "Run tests on backend"
GATOR: Parses intent → "Run test:unit on apps/api"
GATOR: Executes whitelisted task → Streams output
GATOR: Reports back with results

IDLE (20000ms heartbeat)
    │
    ▼ (signals.activate())
ACTIVE (150ms serial polling)
    │
    ▼ (signals.deactivate())
IDLE

// Task whitelist from task-registry.json
const taskRegistry = {
  'test:unit': {
    command: 'pnpm --filter apps/api test',
    description: 'Run API unit tests',
    timeout: 120000,
  },
  'build:core': {
    command: 'pnpm --filter apps/core build',
    description: 'Build core application',
    timeout: 60000,
  },
  // Unknown tasks are rejected before execution
};

async function executeTask(taskName: string) {
  if (!taskRegistry[taskName]) {
    throw new Error(`Task "${taskName}" not whitelisted`);
  }
  return spawn(taskRegistry[taskName].command);
}

// Using jose library for lightweight JWT
import { SignJWT, jwtVerify } from 'jose';

const secret = new TextEncoder().encode(process.env.JWT_SECRET);

async function signToken(payload: object): Promise<string> {
  return new SignJWT(payload)
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime('7d')
    .sign(secret);
}

async function verifyToken(token: string): Promise<object> {
  const { payload } = await jwtVerify(token, secret);
  return payload;
}

# No Docker required
pnpm install
pnpm dev

# System starts in <1.5 seconds with:
# - Embedded SQLite (auto-created)
# - In-memory queue (empty)
# - LSP-Bridge ready

# On the host machine, ensure Tailscale is running
tailscale up --autoconnect=true

# GATOR binds to Tailscale IP automatically
# Access from phone via: https://100.x.x.x:3000

# Install dependencies
pnpm install

# Build for production
pnpm build

# Start the core
pnpm start:core

# Access from mobile via Tailscale
# https://<tailcale-ip>/app