@pixelbyte-software/pixcode 1.54.11 → 1.55.0

package/server/modules/tasks/runners/spawn-runner.ts

@@ -0,0 +1,122 @@
+// ============================================================
+// Spawn Runner — Generic CLI spawn runner for Gemini, Qwen, OpenCode
+// Uses child_process spawn with real-time output streaming
+// ============================================================
+
+import { spawn } from 'node:child_process';
+
+import { buildPrompt, buildContinuePrompt } from '../prompt-builder.js';
+import type { AgentRunner, RunContext, RunResult } from './types.js';
+
+// CLI command mapping
+const CLI_COMMANDS: Record<string, { bin: string; args: string[]; promptFlag: string }> = {
+  gemini: {
+    bin: 'gemini',
+    args: ['--yolo'],
+    promptFlag: '-p',
+  },
+  qwen: {
+    bin: 'qwen',
+    args: [],
+    promptFlag: '-p',
+  },
+  opencode: {
+    bin: 'opencode',
+    args: ['run'],
+    promptFlag: '',
+  },
+};
+
+function getCliCommand(agentType: string, model?: string): { bin: string; args: string[]; promptFlag: string } {
+  const config = CLI_COMMANDS[agentType];
+  if (!config) throw new Error(`Unknown CLI agent: ${agentType}`);
+  const args = [...config.args];
+  if (model && agentType === 'gemini') args.push('--model', model);
+  if (model && agentType === 'qwen') args.push('--model', model);
+  return { ...config, args };
+}
+
+export function createSpawnRunner(agentType: string): AgentRunner {
+  return {
+    async run(ctx: RunContext): Promise<RunResult> {
+      const { task, projectPath, abortController } = ctx;
+      const workdir = task.worktreePath || projectPath;
+
+      const prompt = task.continueSession && task.predecessorTaskId
+        ? buildContinuePrompt(task)
+        : buildPrompt(task, workdir);
+
+      const { bin, args, promptFlag } = getCliCommand(agentType, task.model);
+
+      const fullArgs = promptFlag
+        ? [...args, promptFlag, prompt]
+        : [...args, prompt];
+
+      await ctx.logTask('info', `Starting ${agentType} agent. Bin: ${bin}, Model: ${task.model || 'default'}`);
+
+      return new Promise<RunResult>((resolve, reject) => {
+        const child = spawn(bin, fullArgs, {
+          cwd: workdir,
+          env: { ...process.env },
+          stdio: ['pipe', 'pipe', 'pipe'],
+          shell: false,
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout?.on('data', (data: Buffer) => {
+          const text = data.toString('utf-8');
+          stdout += text;
+          // Log chunks
+          const lines = text.split('\n').filter(Boolean);
+          for (const line of lines) {
+            ctx.logTask('info', `[${agentType}] ${line.slice(0, 200)}`);
+          }
+        });
+
+        child.stderr?.on('data', (data: Buffer) => {
+          const text = data.toString('utf-8');
+          stderr += text;
+          const lines = text.split('\n').filter(Boolean);
+          for (const line of lines) {
+            ctx.logTask('warn', `[${agentType}] ${line.slice(0, 200)}`);
+          }
+        });
+
+        // Handle abort
+        const abortHandler = () => {
+          try {
+            child.kill('SIGTERM');
+            setTimeout(() => {
+              if (!child.killed) child.kill('SIGKILL');
+            }, 5000);
+          } catch {}
+        };
+        abortController.signal.addEventListener('abort', abortHandler, { once: true });
+
+        child.on('close', (code: number) => {
+          abortController.signal.removeEventListener('abort', abortHandler);
+
+          if (code === 0 || abortController.signal.aborted) {
+            ctx.logTask('info', `${agentType} completed. Exit code: ${code}`);
+            resolve({
+              result: stdout.slice(0, 10000),
+              costUsd: 0, // CLI doesn't report cost directly
+              tokenCount: { input: 0, output: 0 },
+            });
+          } else {
+            ctx.logTask('error', `${agentType} failed. Exit code: ${code}. stderr: ${stderr.slice(0, 500)}`);
+            reject(new Error(`${agentType} exited with code ${code}: ${stderr.slice(0, 500)}`));
+          }
+        });
+
+        child.on('error', (err: Error) => {
+          abortController.signal.removeEventListener('abort', abortHandler);
+          ctx.logTask('error', `${agentType} spawn error: ${err.message}`);
+          reject(err);
+        });
+      });
+    },
+  };
+}

package/server/modules/tasks/runners/types.ts

@@ -0,0 +1,25 @@
+// ============================================================
+// Runner Types — Interface for agent runners
+// ============================================================
+
+import type { Task } from '../task-types.js';
+
+export interface RunContext {
+  task: Task;
+  projectPath: string;
+  abortController: AbortController;
+  logTask: (level: 'info' | 'warn' | 'error' | 'debug', message: string) => void;
+  broadcastStatus: (status: string) => void;
+  askUser: (question: string, options?: string[]) => Promise<string>;
+}
+
+export interface RunResult {
+  result?: string;
+  costUsd?: number;
+  tokenCount?: { input: number; output: number };
+  sessionId?: string;
+}
+
+export interface AgentRunner {
+  run(ctx: RunContext): Promise<RunResult>;
+}

package/server/modules/tasks/scheduler.ts

@@ -0,0 +1,75 @@
+// ============================================================
+// Scheduler — Polls the queue every 2 seconds and runs ready tasks
+// ============================================================
+
+import { taskEvents } from './task-runner.js';
+import { getTasksToRun, onTaskTerminated, enqueue } from './task-queue.js';
+import { getTask, updateTask } from './task-store.js';
+import { runTask } from './task-runner.js';
+import { resolveProjectPath } from './task-runner.js';
+
+export class TaskScheduler {
+  private intervalId: NodeJS.Timeout | null = null;
+  private running = false;
+
+  start(): void {
+    if (this.intervalId) return;
+
+    // Poll every 2 seconds
+    this.intervalId = setInterval(() => this.processQueue(), 2000);
+
+    // Listen for events to trigger immediate processing
+    taskEvents.on('task:completed', (taskId: string) => this.onTaskTerminated(taskId));
+    taskEvents.on('task:failed', (taskId: string) => this.onTaskTerminated(taskId));
+    taskEvents.on('task:cancelled', (taskId: string) => this.onTaskTerminated(taskId));
+
+    // Listen for enqueue events
+    taskEvents.on('task:enqueued', () => this.processQueue());
+
+    console.log('[scheduler] Task scheduler started (poll interval: 2s)');
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    taskEvents.removeAllListeners('task:completed');
+    taskEvents.removeAllListeners('task:failed');
+    taskEvents.removeAllListeners('task:cancelled');
+    taskEvents.removeAllListeners('task:enqueued');
+    console.log('[scheduler] Task scheduler stopped');
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.running) return; // prevent re-entrant
+    this.running = true;
+    try {
+      const tasksToRun = getTasksToRun();
+      for (const task of tasksToRun) {
+        // Fire and forget — don't await runTask
+        const projectPath = await resolveProjectPath(task.projectId);
+        runTask(task, projectPath).catch((err) => {
+          console.error(`[scheduler] Task ${task.id} failed:`, err);
+        });
+      }
+    } catch (err) {
+      console.error('[scheduler] Error processing queue:', err);
+    } finally {
+      this.running = false;
+    }
+  }
+
+  private async onTaskTerminated(taskId: string): Promise<void> {
+    try {
+      await onTaskTerminated(taskId);
+      // Immediately check if dependent tasks can run
+      this.processQueue();
+    } catch (err) {
+      console.error('[scheduler] Error handling task termination:', err);
+    }
+  }
+}
+
+// Singleton
+export const taskScheduler = new TaskScheduler();

package/server/modules/tasks/task-queue.ts

@@ -0,0 +1,91 @@
+// ============================================================
+// Task Queue — Manages task dependencies and concurrency
+// ============================================================
+
+import { getTask, updateTask, getTasksByStatus, getPredecessor } from './task-store.js';
+import { taskEvents } from './task-runner.js';
+import type { Task, TaskStatus } from './task-types.js';
+
+const TERMINAL_STATUSES: TaskStatus[] = ['COMPLETED', 'FAILED', 'CANCELLED'];
+
+// Default concurrency: 3 concurrent tasks
+let MAX_CONCURRENT = parseInt(process.env.PIXCODE_MAX_CONCURRENT_TASKS || '3', 10);
+
+export function setMaxConcurrent(n: number): void {
+  MAX_CONCURRENT = Math.max(1, n);
+}
+
+export function getMaxConcurrent(): number {
+  return MAX_CONCURRENT;
+}
+
+/**
+ * Enqueue a task — checks predecessor, transitions to QUEUED if ready.
+ */
+export async function enqueue(taskId: string): Promise<void> {
+  const task = getTask(taskId);
+  if (!task) throw new Error(`Task ${taskId} not found`);
+
+  // Check predecessor
+  if (task.predecessorTaskId) {
+    const predecessor = getPredecessor(task);
+    if (predecessor && !TERMINAL_STATUSES.includes(predecessor.status)) {
+      // Predecessor still running — task stays PENDING
+      return;
+    }
+    if (predecessor && predecessor.status !== 'COMPLETED') {
+      // Predecessor failed or cancelled — cancel this task too
+      updateTask(taskId, {
+        status: 'CANCELLED',
+        result: `Predecessor task "${predecessor.title}" is ${predecessor.status}`,
+      });
+      taskEvents.emit('task:status', { taskId, status: 'CANCELLED' });
+      return;
+    }
+    // Predecessor completed — continue session if requested
+    if (predecessor && task.continueSession && predecessor.sessionId) {
+      updateTask(taskId, { sessionId: predecessor.sessionId });
+    }
+  }
+
+  // Ready to queue
+  updateTask(taskId, { status: 'QUEUED' });
+  taskEvents.emit('task:status', { taskId, status: 'QUEUED' });
+}
+
+/**
+ * Get tasks that are ready to run (QUEUED + within concurrency limit).
+ */
+export function getTasksToRun(): Task[] {
+  const runningCount = getTasksByStatus('RUNNING').length +
+    getTasksByStatus('AWAITING_INPUT').length;
+
+  if (runningCount >= MAX_CONCURRENT) return [];
+
+  const queued = getTasksByStatus('QUEUED');
+  const slotsAvailable = MAX_CONCURRENT - runningCount;
+
+  // Sort by priority then creation time
+  const priorityOrder: Record<string, number> = { urgent: 0, high: 1, normal: 2, low: 3 };
+  return queued
+    .sort((a, b) => {
+      const pDiff = (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
+      if (pDiff !== 0) return pDiff;
+      return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+    })
+    .slice(0, slotsAvailable);
+}
+
+/**
+ * Called when a task terminates — check if dependent tasks can proceed.
+ */
+export async function onTaskTerminated(taskId: string): Promise<void> {
+  // Find tasks that have this task as predecessor
+  // We need to scan all PENDING tasks
+  const pending = getTasksByStatus('PENDING');
+  for (const p of pending) {
+    if (p.predecessorTaskId === taskId) {
+      await enqueue(p.id);
+    }
+  }
+}

package/server/modules/tasks/task-routes.ts

@@ -0,0 +1,245 @@
+// ============================================================
+// Task Routes — Express API endpoints for task management
+// ============================================================
+
+import type { Router, Request, Response } from 'express';
+import express from 'express';
+
+import {
+  createTask,
+  getTask,
+  getTasksByProject,
+  getAllTasks,
+  updateTask,
+  deleteTask,
+  getLogs,
+  getPendingInteractions,
+  addLog,
+} from './task-store.js';
+import { enqueue } from './task-queue.js';
+import { cancelTask, taskEvents } from './task-runner.js';
+import { submitAnswer } from './user-interaction.js';
+import { getMaxConcurrent, setMaxConcurrent } from './task-queue.js';
+import { listRoles } from './role-presets.js';
+import type { CreateTaskInput, AgentType, TaskRole, TaskPriority } from './task-types.js';
+
+export function taskRouter(): Router {
+  const router = express.Router();
+
+  // ============================================================
+  // GET /api/tasks — List all tasks
+  // ============================================================
+  router.get('/', (req: Request, res: Response) => {
+    const limit = parseInt(String(req.query.limit)) || 100;
+    const projectId = String(req.query.projectId);
+    const tasks = projectId ? getTasksByProject(projectId) : getAllTasks(limit);
+    res.json({ tasks });
+  });
+
+  // ============================================================
+  // GET /api/tasks/:id — Get a single task
+  // ============================================================
+  router.get('/:id', (req: Request, res: Response) => {
+    const task = getTask(String(req.params.id));
+    if (!task) {
+      res.status(404).json({ error: 'Task not found' });
+      return;
+    }
+    res.json({ task });
+  });
+
+  // ============================================================
+  // POST /api/tasks — Create a new task
+  // ============================================================
+  router.post('/', async (req: Request, res: Response) => {
+    try {
+      const {
+        projectId,
+        title,
+        prompt,
+        agentType,
+        model,
+        role,
+        priority,
+        predecessorTaskId,
+        continueSession,
+        maxBudgetUsd,
+        interactionTimeout,
+        thinkingEnabled,
+        permissionMode,
+      } = req.body;
+
+      if (!projectId || !title || !prompt || !agentType) {
+        res.status(400).json({
+          error: 'Missing required fields: projectId, title, prompt, agentType',
+        });
+        return;
+      }
+
+      const validAgents: AgentType[] = ['claude-code', 'codex', 'gemini', 'qwen', 'opencode'];
+      if (!validAgents.includes(agentType)) {
+        res.status(400).json({ error: `Invalid agentType. Valid: ${validAgents.join(', ')}` });
+        return;
+      }
+
+      const input: CreateTaskInput = {
+        projectId,
+        title,
+        prompt,
+        agentType,
+        model,
+        role: role as TaskRole,
+        priority: priority as TaskPriority,
+        predecessorTaskId,
+        continueSession,
+        maxBudgetUsd,
+        interactionTimeout,
+        thinkingEnabled,
+        permissionMode,
+      };
+
+      const task = createTask(input);
+      await enqueue(task.id);
+      taskEvents.emit('task:enqueued', task.id);
+
+      res.status(201).json({ task });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ============================================================
+  // POST /api/tasks/:id/cancel — Cancel a task
+  // ============================================================
+  router.post('/:id/cancel', async (req: Request, res: Response) => {
+    const success = await cancelTask(String(req.params.id));
+    if (!success) {
+      res.status(404).json({ error: 'Task not found' });
+      return;
+    }
+    res.json({ success: true });
+  });
+
+  // ============================================================
+  // DELETE /api/tasks/:id — Delete a task
+  // ============================================================
+  router.delete('/:id', (req: Request, res: Response) => {
+    const success = deleteTask(String(req.params.id));
+    if (!success) {
+      res.status(404).json({ error: 'Task not found' });
+      return;
+    }
+    res.json({ success: true });
+  });
+
+  // ============================================================
+  // GET /api/tasks/:id/logs — Get task logs
+  // ============================================================
+  router.get('/:id/logs', (req: Request, res: Response) => {
+    const limit = parseInt(String(req.query.limit)) || 200;
+    const logs = getLogs(String(req.params.id), limit);
+    res.json({ logs });
+  });
+
+  // ============================================================
+  // GET /api/tasks/:id/interactions — Get pending interactions
+  // ============================================================
+  router.get('/:id/interactions', (req: Request, res: Response) => {
+    const interactions = getPendingInteractions(String(req.params.id));
+    res.json({ interactions });
+  });
+
+  // ============================================================
+  // POST /api/tasks/interactions/:interactionId/answer — Answer a question
+  // ============================================================
+  router.post('/interactions/:interactionId/answer', (req: Request, res: Response) => {
+    const { answer } = req.body;
+    if (!answer) {
+      res.status(400).json({ error: 'Missing required field: answer' });
+      return;
+    }
+    const success = submitAnswer(String(req.params.interactionId), answer);
+    if (!success) {
+      res.status(404).json({ error: 'Interaction not found or already answered' });
+      return;
+    }
+    res.json({ success: true });
+  });
+
+  // ============================================================
+  // GET /api/tasks/meta/roles — List available roles
+  // ============================================================
+  router.get('/meta/roles', (req: Request, res: Response) => {
+    res.json({ roles: listRoles() });
+  });
+
+  // ============================================================
+  // GET /api/tasks/meta/agents — List available agents
+  // ============================================================
+  router.get('/meta/agents', (req: Request, res: Response) => {
+    res.json({
+      agents: [
+        { value: 'claude-code', label: 'Claude Code', provider: 'anthropic' },
+        { value: 'codex', label: 'Codex CLI', provider: 'openai' },
+        { value: 'gemini', label: 'Gemini CLI', provider: 'google' },
+        { value: 'qwen', label: 'Qwen Code', provider: 'alibaba' },
+        { value: 'opencode', label: 'OpenCode', provider: 'anomaly' },
+      ],
+    });
+  });
+
+  // ============================================================
+  // GET /api/tasks/meta/config — Get task system config
+  // ============================================================
+  router.get('/meta/config', (req: Request, res: Response) => {
+    res.json({
+      maxConcurrent: getMaxConcurrent(),
+    });
+  });
+
+  // ============================================================
+  // POST /api/tasks/meta/config — Set task system config
+  // ============================================================
+  router.post('/meta/config', (req: Request, res: Response) => {
+    const { maxConcurrent } = req.body;
+    if (typeof maxConcurrent === 'number' && maxConcurrent > 0) {
+      setMaxConcurrent(maxConcurrent);
+    }
+    res.json({ maxConcurrent: getMaxConcurrent() });
+  });
+
+  // ============================================================
+  // WebSocket event stream (SSE) — /api/tasks/events
+  // ============================================================
+  router.get('/events', (req: Request, res: Response) => {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    });
+
+    const send = (data: any) => {
+      res.write(`data: ${JSON.stringify(data)}\n\n`);
+    };
+
+    const handlers: Record<string, (data: any) => void> = {
+      'task:status': (data) => send({ type: 'task:status', ...data }),
+      'task:log': (data) => send({ type: 'task:log', ...data }),
+      'task:completed': (data) => send({ type: 'task:completed', ...data }),
+      'task:failed': (data) => send({ type: 'task:failed', ...data }),
+      'task:cancelled': (data) => send({ type: 'task:cancelled', ...data }),
+    };
+
+    for (const [event, handler] of Object.entries(handlers)) {
+      taskEvents.on(event, handler);
+    }
+
+    req.on('close', () => {
+      for (const [event, handler] of Object.entries(handlers)) {
+        taskEvents.off(event, handler);
+      }
+    });
+  });
+
+  return router;
+}