@pixelbyte-software/pixcode 1.55.1 → 1.55.3

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

@@ -0,0 +1,120 @@
+// ============================================================
+// Claude Runner — Uses @anthropic-ai/claude-agent-sdk
+// ============================================================
+
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
+import { buildPrompt, buildContinuePrompt } from '../prompt-builder.js';
+import type { AgentRunner, RunContext, RunResult } from './types.js';
+
+export const claudeRunner: AgentRunner = {
+  async run(ctx: RunContext): Promise<RunResult> {
+    const { task, projectPath, abortController } = ctx;
+    const workdir = task.worktreePath || projectPath;
+
+    // Build prompt — continue or fresh
+    const prompt = task.continueSession && task.predecessorTaskId
+      ? buildContinuePrompt(task)
+      : buildPrompt(task, workdir);
+
+    // Build clean env
+    const cleanEnv: Record<string, string | undefined> = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+
+    // Permission mode
+    const permissionMode = task.permissionMode || 'auto_edit';
+
+    await ctx.logTask('info', `Starting Claude Code agent. Model: ${task.model || 'default'}, Permission: ${permissionMode}`);
+
+    let resultText = '';
+    let costUsd = 0;
+    let tokenInput = 0;
+    let tokenOutput = 0;
+    let sessionId: string | undefined;
+
+    try {
+      const response = query({
+        prompt,
+        options: {
+          cwd: workdir,
+          model: task.model,
+          permissionMode: permissionMode as any,
+          maxTurns: 150,
+          env: cleanEnv,
+          abortController,
+          ...(task.continueSession && task.sessionId
+            ? { resume: task.sessionId }
+            : {}),
+        },
+      });
+
+      for await (const message of response) {
+        if (abortController.signal.aborted) break;
+
+        switch (message.type) {
+          case 'assistant': {
+            if (message.message?.content) {
+              for (const block of message.message.content) {
+                if (block.type === 'text') {
+                  resultText += block.text + '\n';
+                  await ctx.logTask('info', `[Claude] ${block.text.slice(0, 200)}`);
+                }
+              }
+            }
+            // Extract token usage
+            if (message.message?.usage) {
+              tokenInput += message.message.usage.input_tokens || 0;
+              tokenOutput += message.message.usage.output_tokens || 0;
+              costUsd += ((message.message.usage.input_tokens || 0) * 0.000003) +
+                         ((message.message.usage.output_tokens || 0) * 0.000015);
+            }
+            break;
+          }
+
+          case 'result': {
+            // SDKResultMessage is a union — check subtype before accessing fields
+            if (message.subtype === 'success') {
+              const success = message as any;
+              if (success.result) resultText = success.result;
+              if (success.session_id) sessionId = success.session_id;
+              if (success.total_cost_usd) costUsd = success.total_cost_usd;
+              if (success.usage) {
+                tokenInput = success.usage.input_tokens || tokenInput;
+                tokenOutput = success.usage.output_tokens || tokenOutput;
+              }
+            }
+            break;
+          }
+
+          case 'system': {
+            if (message.subtype === 'init' && message.session_id) {
+              sessionId = message.session_id;
+              await ctx.logTask('info', `Claude session: ${sessionId}`);
+            }
+            break;
+          }
+        }
+      }
+
+      // Check budget
+      if (task.maxBudgetUsd && costUsd > task.maxBudgetUsd) {
+        await ctx.logTask('warn', `Budget exceeded: $${costUsd.toFixed(4)} > $${task.maxBudgetUsd}`);
+      }
+
+      await ctx.logTask('info', `Claude completed. Tokens: ${tokenInput} in / ${tokenOutput} out. Cost: $${costUsd.toFixed(4)}`);
+
+      return {
+        result: resultText.slice(0, 10000),
+        costUsd,
+        tokenCount: { input: tokenInput, output: tokenOutput },
+        sessionId,
+      };
+    } catch (err: any) {
+      if (err?.name === 'AbortError' || abortController.signal.aborted) {
+        await ctx.logTask('info', 'Claude task was cancelled');
+        return { result: 'Task cancelled by user', sessionId };
+      }
+      throw err;
+    }
+  },
+};

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

@@ -0,0 +1,80 @@
+// ============================================================
+// Codex Runner — Uses @openai/codex-sdk
+// ============================================================
+
+import { Codex } from '@openai/codex-sdk';
+
+import { buildPrompt, buildContinuePrompt } from '../prompt-builder.js';
+import type { AgentRunner, RunContext, RunResult } from './types.js';
+
+export const codexRunner: AgentRunner = {
+  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);
+
+    // Clean env
+    const cleanEnv: Record<string, string> = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (v !== undefined && k !== 'CLAUDECODE') {
+        cleanEnv[k] = v;
+      }
+    }
+
+    await ctx.logTask('info', `Starting Codex agent. Model: ${task.model || 'o4-mini'}, Thinking: ${task.thinkingEnabled}`);
+
+    const codex = new Codex({
+      env: cleanEnv,
+      config: {
+        model: task.model || 'o4-mini',
+        approval_policy: 'never',
+        ...(task.thinkingEnabled ? { reasoning_effort: 'high' as const } : {}),
+      },
+    });
+
+    let resultText = '';
+    let costUsd = 0;
+    let tokenInput = 0;
+    let tokenOutput = 0;
+    let sessionId: string | undefined;
+
+    try {
+      // Use startThread() — the correct Codex SDK API
+      const thread = codex.startThread();
+
+      // Use run() for non-streaming — returns a Turn with finalResponse and usage
+      const turn = await thread.run(prompt, {
+        signal: abortController.signal,
+      });
+
+      // Extract results from the completed turn
+      resultText = turn.finalResponse || '';
+      sessionId = thread.id || undefined;
+
+      if (turn.usage) {
+        tokenInput = turn.usage.input_tokens || 0;
+        tokenOutput = turn.usage.output_tokens || 0;
+        costUsd = (tokenInput * 0.0000025) + (tokenOutput * 0.00001);
+      }
+
+      await ctx.logTask('info', `[Codex] ${resultText.slice(0, 200)}`);
+      await ctx.logTask('info', `Codex completed. Tokens: ${tokenInput} in / ${tokenOutput} out. Cost: $${costUsd.toFixed(4)}`);
+
+      return {
+        result: resultText.slice(0, 10000),
+        costUsd,
+        tokenCount: { input: tokenInput, output: tokenOutput },
+        sessionId,
+      };
+    } catch (err: any) {
+      if (err?.name === 'AbortError' || abortController.signal.aborted) {
+        await ctx.logTask('info', 'Codex task was cancelled');
+        return { result: 'Task cancelled by user', sessionId };
+      }
+      throw err;
+    }
+  },
+};

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