@pixelbyte-software/pixcode 1.54.10 → 1.55.0

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;
+}

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

@@ -0,0 +1,219 @@
+// ============================================================
+// Task Runner — Dispatches tasks to the right agent runner
+// ============================================================
+
+import { updateTask, addLog, getTask } from './task-store.js';
+import { createWorktree, removeWorktree, getChangedFiles } from './git-worktree.js';
+import { askUser, cancelTaskInteractions } from './user-interaction.js';
+import { buildSummaryPrompt } from './prompt-builder.js';
+import { claudeRunner } from './runners/claude-runner.js';
+import { codexRunner } from './runners/codex-runner.js';
+import { createSpawnRunner } from './runners/spawn-runner.js';
+import type { Task, AgentType } from './task-types.js';
+import type { AgentRunner, RunContext } from './runners/types.js';
+
+// Runner registry
+const runners: Partial<Record<AgentType, AgentRunner>> = {
+  'claude-code': claudeRunner,
+  'codex': codexRunner,
+  'gemini': createSpawnRunner('gemini'),
+  'qwen': createSpawnRunner('qwen'),
+  'opencode': createSpawnRunner('opencode'),
+};
+
+// Track running tasks for cancellation
+const runningTasks = new Map<string, AbortController>();
+
+export function getAbortController(taskId: string): AbortController | undefined {
+  return runningTasks.get(taskId);
+}
+
+// Event emitter for WebSocket updates
+import { EventEmitter } from 'node:events';
+export const taskEvents = new EventEmitter();
+
+// ============================================================
+// Resolve project path from projectId
+// ============================================================
+
+export async function resolveProjectPath(projectId: string): Promise<string> {
+  // Try to import pixcode's project service
+  try {
+    const { getProjects } = await import('../../projects.js');
+    const projects = await getProjects();
+    const project = projects.find((p: any) => p.name === projectId || p.id === projectId);
+    if (project) {
+      return project.fullPath || project.path || projectId;
+    }
+  } catch {
+    // Fall through to treating projectId as a path
+  }
+  return projectId;
+}
+
+// ============================================================
+// Generate summary using Claude SDK
+// ============================================================
+
+async function generateSummary(task: Task, projectPath: string): Promise<string> {
+  try {
+    const { query } = await import('@anthropic-ai/claude-agent-sdk');
+    const summaryPrompt = buildSummaryPrompt(task);
+
+    const response = await query({
+      prompt: summaryPrompt,
+      options: {
+        cwd: task.worktreePath || projectPath,
+        maxTurns: 3,
+        model: 'claude-sonnet-4-20250514',
+        permissionMode: 'plan' as any,
+      },
+    });
+
+    let summary = '';
+    for await (const message of response) {
+      if (message.type === 'result' && message.subtype === 'success') {
+        const success = message as any;
+        summary = success.result || '';
+      }
+    }
+    return summary.slice(0, 2000);
+  } catch {
+    // Fallback: simple summary
+    return `Task "${task.title}" completed with ${task.agentType}.`;
+  }
+}
+
+// ============================================================
+// Run a single task
+// ============================================================
+
+export async function runTask(task: Task, projectPath: string): Promise<void> {
+  const abortController = new AbortController();
+  runningTasks.set(task.id, abortController);
+
+  const logTask = (level: 'info' | 'warn' | 'error' | 'debug', message: string) => {
+    addLog(task.id, level, message);
+    taskEvents.emit('task:log', { taskId: task.id, level, message });
+  };
+
+  const broadcastStatus = (status: string) => {
+    taskEvents.emit('task:status', { taskId: task.id, status });
+  };
+
+  try {
+    // Update status to RUNNING
+    updateTask(task.id, {
+      status: 'RUNNING',
+      startedAt: new Date().toISOString(),
+    });
+    broadcastStatus('RUNNING');
+
+    // Create git worktree for isolation
+    let worktreePath: string | undefined;
+    let branchName: string | undefined;
+    try {
+      const wt = createWorktree(task, projectPath);
+      worktreePath = wt.worktreePath;
+      branchName = wt.branchName;
+      updateTask(task.id, { worktreePath, branchName });
+    } catch (err: any) {
+      logTask('warn', `Could not create worktree: ${err.message}. Running in main directory.`);
+    }
+
+    // Get the right runner
+    const runner = runners[task.agentType];
+    if (!runner) {
+      throw new Error(`No runner registered for agent type: ${task.agentType}`);
+    }
+
+    // Build context
+    const ctx: RunContext = {
+      task: { ...task, worktreePath, branchName },
+      projectPath,
+      abortController,
+      logTask,
+      broadcastStatus,
+      askUser: (question: string, options?: string[]) =>
+        askUser(task.id, question, options, task.interactionTimeout),
+    };
+
+    // Run the agent
+    const { result, costUsd, tokenCount, sessionId } = await runner.run(ctx);
+
+    // Get changed files
+    const changedFiles = getChangedFiles({ ...task, worktreePath }, projectPath);
+
+    // Generate summary
+    logTask('info', 'Generating task summary...');
+    const summary = await generateSummary({ ...task, worktreePath }, projectPath);
+
+    // Update task with results
+    updateTask(task.id, {
+      status: 'COMPLETED',
+      result: result || 'Completed',
+      summary,
+      costUsd: costUsd || 0,
+      tokenCount: tokenCount || { input: 0, output: 0 },
+      sessionId,
+      changedFiles,
+      completedAt: new Date().toISOString(),
+    });
+    broadcastStatus('COMPLETED');
+
+    logTask('info', `Task completed. Cost: $${(costUsd || 0).toFixed(4)}, Files changed: ${changedFiles.length}`);
+
+    taskEvents.emit('task:completed', {
+      taskId: task.id,
+      summary,
+      costUsd: costUsd || 0,
+      changedFiles,
+    });
+
+    // Clean up worktree (optional — keep for review)
+    // removeWorktree(updatedTask, projectPath);
+
+  } catch (err: any) {
+    logTask('error', `Task failed: ${err.message}`);
+
+    updateTask(task.id, {
+      status: 'FAILED',
+      result: err.message,
+      completedAt: new Date().toISOString(),
+    });
+    broadcastStatus('FAILED');
+
+    taskEvents.emit('task:failed', { taskId: task.id, error: err.message });
+  } finally {
+    runningTasks.delete(task.id);
+  }
+}
+
+// ============================================================
+// Cancel a running task
+// ============================================================
+
+export async function cancelTask(taskId: string): Promise<boolean> {
+  const task = getTask(taskId);
+  if (!task) return false;
+
+  // Abort the running process
+  const abortController = runningTasks.get(taskId);
+  if (abortController) {
+    abortController.abort();
+  }
+
+  // Cancel pending interactions
+  cancelTaskInteractions(taskId);
+
+  // Update status
+  updateTask(taskId, {
+    status: 'CANCELLED',
+    completedAt: new Date().toISOString(),
+  });
+
+  taskEvents.emit('task:status', { taskId, status: 'CANCELLED' });
+  taskEvents.emit('task:cancelled', { taskId });
+
+  return true;
+}