@pixelbyte-software/pixcode 1.54.11 → 1.55.0

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

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

@@ -0,0 +1,223 @@
+// ============================================================
+// Task Store — JSON-backed persistent storage for tasks
+// ============================================================
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { randomUUID } from 'node:crypto';
+
+import { findAppRoot, getModuleDir } from '@/utils/runtime-paths.js';
+
+import type { Task, TaskInteraction, TaskLog, TaskStatus, CreateTaskInput } from './task-types.js';
+
+const require = createRequire(import.meta.url);
+const __dirname = getModuleDir(import.meta.url);
+const APP_ROOT = findAppRoot(__dirname);
+
+const TASKS_FILE = process.env.PIXCODE_TASKS_DB || path.join(APP_ROOT, 'tasks.json');
+
+interface TaskStoreData {
+  _version: number;
+  tasks: Task[];
+  interactions: TaskInteraction[];
+  logs: TaskLog[];
+}
+
+function loadStore(): TaskStoreData {
+  try {
+    if (fs.existsSync(TASKS_FILE)) {
+      const raw = fs.readFileSync(TASKS_FILE, 'utf-8');
+      const data = JSON.parse(raw);
+      if (!data.tasks) data.tasks = [];
+      if (!data.interactions) data.interactions = [];
+      if (!data.logs) data.logs = [];
+      return data;
+    }
+  } catch (err) {
+    console.error('[task-store] Failed to load tasks.json:', err);
+  }
+  return { _version: 1, tasks: [], interactions: [], logs: [] };
+}
+
+function saveStore(data: TaskStoreData): void {
+  try {
+    const dir = path.dirname(TASKS_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const tmp = TASKS_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+    fs.renameSync(tmp, TASKS_FILE);
+  } catch (err) {
+    console.error('[task-store] Failed to save tasks.json:', err);
+  }
+}
+
+// In-memory cache — loaded once, kept in sync
+let storeData = loadStore();
+
+// Rate-limit saves to avoid hammering disk on every log write
+let saveTimer: NodeJS.Timeout | null = null;
+function scheduleSave(): void {
+  if (saveTimer) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    saveStore(storeData);
+  }, 500);
+}
+
+// Force immediate save (for critical state changes)
+function flushSave(): void {
+  if (saveTimer) {
+    clearTimeout(saveTimer);
+    saveTimer = null;
+  }
+  saveStore(storeData);
+}
+
+// ============================================================
+// Task CRUD
+// ============================================================
+
+export function createTask(input: CreateTaskInput): Task {
+  const now = new Date().toISOString();
+  const task: Task = {
+    id: randomUUID(),
+    projectId: input.projectId,
+    title: input.title,
+    prompt: input.prompt,
+    status: 'PENDING',
+    agentType: input.agentType,
+    model: input.model,
+    role: input.role || 'fullstack',
+    priority: input.priority || 'normal',
+    predecessorTaskId: input.predecessorTaskId,
+    continueSession: input.continueSession || false,
+    maxBudgetUsd: input.maxBudgetUsd,
+    interactionTimeout: input.interactionTimeout || 300_000,
+    thinkingEnabled: input.thinkingEnabled || false,
+    permissionMode: input.permissionMode,
+    costUsd: 0,
+    tokenCount: { input: 0, output: 0 },
+    createdAt: now,
+  };
+  storeData.tasks.push(task);
+  flushSave();
+  return task;
+}
+
+export function getTask(id: string): Task | undefined {
+  return storeData.tasks.find((t) => t.id === id);
+}
+
+export function getTasksByProject(projectId: string): Task[] {
+  return storeData.tasks
+    .filter((t) => t.projectId === projectId)
+    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+
+export function getAllTasks(limit = 100): Task[] {
+  return storeData.tasks
+    .slice()
+    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+    .slice(0, limit);
+}
+
+export function updateTask(id: string, updates: Partial<Task>): Task | undefined {
+  const task = storeData.tasks.find((t) => t.id === id);
+  if (!task) return undefined;
+  Object.assign(task, updates, { updatedAt: new Date().toISOString() });
+  flushSave();
+  return task;
+}
+
+export function deleteTask(id: string): boolean {
+  const idx = storeData.tasks.findIndex((t) => t.id === id);
+  if (idx === -1) return false;
+  storeData.tasks.splice(idx, 1);
+  // Also remove related interactions and logs
+  storeData.interactions = storeData.interactions.filter((i) => i.taskId !== id);
+  storeData.logs = storeData.logs.filter((l) => l.taskId !== id);
+  flushSave();
+  return true;
+}
+
+export function getTasksByStatus(status: TaskStatus): Task[] {
+  return storeData.tasks.filter((t) => t.status === status);
+}
+
+export function getPredecessor(task: Task): Task | undefined {
+  if (!task.predecessorTaskId) return undefined;
+  return getTask(task.predecessorTaskId);
+}
+
+// ============================================================
+// Task Interactions
+// ============================================================
+
+export function createInteraction(taskId: string, question: string, options?: string[]): TaskInteraction {
+  const interaction: TaskInteraction = {
+    id: randomUUID(),
+    taskId,
+    question,
+    options,
+    status: 'pending',
+    createdAt: new Date().toISOString(),
+  };
+  storeData.interactions.push(interaction);
+  flushSave();
+  return interaction;
+}
+
+export function getPendingInteractions(taskId: string): TaskInteraction[] {
+  return storeData.interactions.filter(
+    (i) => i.taskId === taskId && i.status === 'pending',
+  );
+}
+
+export function answerInteraction(interactionId: string, answer: string): TaskInteraction | undefined {
+  const interaction = storeData.interactions.find((i) => i.id === interactionId);
+  if (!interaction) return undefined;
+  interaction.answer = answer;
+  interaction.status = 'answered';
+  interaction.answeredAt = new Date().toISOString();
+  flushSave();
+  return interaction;
+}
+
+export function timeoutInteraction(interactionId: string): void {
+  const interaction = storeData.interactions.find((i) => i.id === interactionId);
+  if (interaction && interaction.status === 'pending') {
+    interaction.status = 'timeout';
+    flushSave();
+  }
+}
+
+// ============================================================
+// Task Logs
+// ============================================================
+
+export function addLog(taskId: string, level: TaskLog['level'], message: string): void {
+  storeData.logs.push({
+    id: randomUUID(),
+    taskId,
+    level,
+    message,
+    timestamp: new Date().toISOString(),
+  });
+  scheduleSave();
+}
+
+export function getLogs(taskId: string, limit = 200): TaskLog[] {
+  return storeData.logs
+    .filter((l) => l.taskId === taskId)
+    .sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime())
+    .slice(-limit);
+}
+
+// ============================================================
+// Utility
+// ============================================================
+
+export function getTaskStorePath(): string {
+  return TASKS_FILE;
+}

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

@@ -0,0 +1,100 @@
+// ============================================================
+// Task Types — Core type definitions for the task system
+// ============================================================
+
+export type TaskStatus =
+  | 'PENDING'       // Created but waiting for predecessor or queue slot
+  | 'QUEUED'        // Ready to run, waiting for scheduler
+  | 'RUNNING'       // Agent is executing
+  | 'AWAITING_INPUT' // Agent asked a question, waiting for user
+  | 'COMPLETED'     // Finished successfully
+  | 'FAILED'        // Finished with error
+  | 'CANCELLED';    // User cancelled
+
+export type AgentType = 'claude-code' | 'codex' | 'gemini' | 'qwen' | 'opencode';
+
+export type TaskRole = 'backend' | 'frontend' | 'fullstack' | 'reviewer' | 'tester' | 'custom';
+
+export type TaskPriority = 'low' | 'normal' | 'high' | 'urgent';
+
+export interface TaskInteraction {
+  id: string;
+  taskId: string;
+  question: string;
+  options?: string[];
+  answer?: string;
+  status: 'pending' | 'answered' | 'timeout';
+  createdAt: string;
+  answeredAt?: string;
+}
+
+export interface TaskLog {
+  id: string;
+  taskId: string;
+  level: 'info' | 'warn' | 'error' | 'debug';
+  message: string;
+  timestamp: string;
+}
+
+export interface Task {
+  id: string;
+  projectId: string;
+  title: string;
+  prompt: string;
+  status: TaskStatus;
+  agentType: AgentType;
+  model?: string;
+  role: TaskRole;
+  priority: TaskPriority;
+
+  // Dependency chain — predecessor must complete before this starts
+  predecessorTaskId?: string;
+  continueSession?: boolean;  // Continue predecessor's session
+  sessionId?: string;         // Session ID from agent (for continuation)
+
+  // Budget
+  maxBudgetUsd?: number;
+  costUsd?: number;
+  tokenCount?: { input: number; output: number };
+
+  // Git worktree
+  branchName?: string;
+  worktreePath?: string;
+
+  // Result
+  result?: string;
+  summary?: string;
+  changedFiles?: string[];
+
+  // Timestamps
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+
+  // Metadata
+  interactionTimeout?: number;  // ms, default 300000 (5 min)
+  thinkingEnabled?: boolean;
+  permissionMode?: string;
+}
+
+export interface CreateTaskInput {
+  projectId: string;
+  title: string;
+  prompt: string;
+  agentType: AgentType;
+  model?: string;
+  role?: TaskRole;
+  priority?: TaskPriority;
+  predecessorTaskId?: string;
+  continueSession?: boolean;
+  maxBudgetUsd?: number;
+  interactionTimeout?: number;
+  thinkingEnabled?: boolean;
+  permissionMode?: string;
+}
+
+export interface DispatchTaskInput {
+  agentType: AgentType;
+  model?: string;
+  permissionMode?: string;
+}

package/server/modules/tasks/user-interaction.ts

@@ -0,0 +1,93 @@
+// ============================================================
+// User Interaction — Agent asks questions, user responds via UI
+// ============================================================
+
+import { EventEmitter } from 'node:events';
+
+import { createInteraction, answerInteraction, getPendingInteractions, timeoutInteraction, addLog } from './task-store.js';
+
+// Event bus for WebSocket notifications
+export const interactionEvents = new EventEmitter();
+
+// Pending interaction promises — keyed by interaction ID
+const pendingResolvers = new Map<string, { resolve: (answer: string) => void; reject: (err: Error) => void; timer: NodeJS.Timeout }>();
+
+/**
+ * Create a question for the user and wait for the answer.
+ * Called by agent runners when the agent needs user input.
+ */
+export function askUser(
+  taskId: string,
+  question: string,
+  options?: string[],
+  timeoutMs = 300_000,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const interaction = createInteraction(taskId, question, options);
+
+    // Emit event for WebSocket broadcast
+    interactionEvents.emit('interaction:created', {
+      taskId,
+      interactionId: interaction.id,
+      question,
+      options,
+    });
+
+    addLog(taskId, 'info', `Agent asked: "${question.slice(0, 100)}"`);
+
+    // Set timeout
+    const timer = setTimeout(() => {
+      timeoutInteraction(interaction.id);
+      pendingResolvers.delete(interaction.id);
+      addLog(taskId, 'warn', `Interaction timed out: "${question.slice(0, 60)}"`);
+      resolve('[TIMEOUT] No response from user');
+    }, timeoutMs);
+
+    pendingResolvers.set(interaction.id, { resolve, reject, timer });
+  });
+}
+
+/**
+ * Called when user answers a question via the UI.
+ */
+export function submitAnswer(interactionId: string, answer: string): boolean {
+  const pending = pendingResolvers.get(interactionId);
+  if (!pending) return false;
+
+  clearTimeout(pending.timer);
+  pendingResolvers.delete(interactionId);
+
+  // Persist the answer
+  answerInteraction(interactionId, answer);
+
+  // Resolve the promise
+  pending.resolve(answer);
+
+  // Emit event for WebSocket broadcast
+  interactionEvents.emit('interaction:answered', { interactionId, answer });
+
+  return true;
+}
+
+/**
+ * Get all pending interactions for a task.
+ */
+export function getTaskInteractions(taskId: string) {
+  return getPendingInteractions(taskId);
+}
+
+/**
+ * Cancel all pending interactions for a task (e.g. when task is cancelled).
+ */
+export function cancelTaskInteractions(taskId: string): void {
+  const pending = getPendingInteractions(taskId);
+  for (const interaction of pending) {
+    const resolver = pendingResolvers.get(interaction.id);
+    if (resolver) {
+      clearTimeout(resolver.timer);
+      pendingResolvers.delete(interaction.id);
+      resolver.resolve('[CANCELLED] Task was cancelled');
+    }
+    timeoutInteraction(interaction.id);
+  }
+}

package/server/services/control-room.js

@@ -1,8 +1,17 @@
-import { listPendingApprovals, workflowStore } from '../modules/orchestration/index.js';
 import { getProjects } from '../projects.js';
 
 import { listWebhooks } from './webhooks.js';
 
+// Stubs for removed orchestration module — will be replaced by task system
+function workflowStoreStub() {
+  return { listRuns: () => [] };
+}
+function listPendingApprovalsStub() {
+  return [];
+}
+const workflowStore = workflowStoreStub();
+const listPendingApprovals = listPendingApprovalsStub;
+
 const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
 
 function projectPath(project) {

package/server/services/public-api-manifest.js

@@ -4,7 +4,7 @@ const API_GROUPS = [
   { id: 'sessions', title: 'Sessions and messages', basePath: '/api/sessions', scopes: ['sessions:read', 'sessions:write'] },
   { id: 'providers', title: 'CLI providers', basePath: '/api/providers', scopes: ['providers:read', 'providers:write'] },
   { id: 'terminal', title: 'Visible terminal sessions', basePath: '/api/shell/sessions', scopes: ['terminal:launch'] },
-  { id: 'orchestration', title: 'Orchestration runs', basePath: '/api/orchestration', scopes: ['orchestration:read', 'orchestration:write'] },
+  { id: 'tasks', title: 'Task management', basePath: '/api/tasks', scopes: ['tasks:read', 'tasks:write'] },
   { id: 'notifications', title: 'Notifications', basePath: '/api/settings/notifications', scopes: ['notifications:read', 'notifications:write'] },
   { id: 'files', title: 'Files', basePath: '/api/projects/:projectName/files', scopes: ['files:read', 'files:write'] },
   { id: 'git', title: 'Source control', basePath: '/api/git', scopes: ['git:read', 'git:write'] },
@@ -93,11 +93,11 @@ export class PixcodeClient {
   }
 
   approvals() {
-    return this.request<{ pendingApprovals: unknown[] }>('/api/orchestration/workflows/approvals');
+    return this.request<{ pendingApprovals: unknown[] }>('/api/tasks');
   }
 
   decideApproval(approvalId: string, allow: boolean) {
-    return this.request(\`/api/orchestration/workflows/approvals/\${encodeURIComponent(approvalId)}\`, {
+    return this.request(\`/api/tasks/\${encodeURIComponent(approvalId)}\`, {
       method: 'POST',
       body: JSON.stringify({ allow, source: 'api' }),
     });
@@ -132,11 +132,11 @@ export function buildCurlCookbook({ baseUrl = '' } = {}) {
       },
       {
         title: 'List pending approvals',
-        command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/orchestration/workflows/approvals"`,
+        command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/tasks"`,
       },
       {
         title: 'Approve a pending action',
-        command: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: $PIXCODE_API_KEY" -d '{"allow":true,"source":"api"}' "$PIXCODE_URL/api/orchestration/workflows/approvals/approval_id"`,
+        command: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: $PIXCODE_API_KEY" -d '{"allow":true,"source":"api"}' "$PIXCODE_URL/api/tasks/approval_id"`,
       },
       {
         title: 'Create a webhook',