crewos 0.1.0

package/backend/src/services/task.service.js

@@ -0,0 +1,665 @@
+import crypto from 'crypto';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { spawn } from 'child_process';
+
+import { getDB } from '../configs/db.config.js';
+import { getCachedModels } from './config.service.js';
+import { getProjectKnowledge } from './onboarding.service.js';
+import { sanitizeProgressLine } from '../utils/sanitize.js';
+
+const CREWOS_CONFIG_PATH = path.join(os.homedir(), '.crewos', 'config.json');
+const TASK_TIMEOUT_MS = 15 * 60 * 1_000;
+
+const KNOWLEDGE_SECTIONS = [
+  { key: 'folderStructure', label: 'Project Structure' },
+  { key: 'techStack', label: 'Tech Stack' },
+  { key: 'codingConventions', label: 'Coding Conventions' },
+  { key: 'databaseDesign', label: 'Database Design' },
+  { key: 'apiDesign', label: 'API Design' },
+  { key: 'configSystem', label: 'Configuration System' },
+  { key: 'keyPatterns', label: 'Key Patterns & Conventions' },
+];
+
+function buildKnowledgeContext(knowledge) {
+  if (!knowledge || typeof knowledge !== 'object') return '';
+
+  const sections = KNOWLEDGE_SECTIONS.map(({ key, label }) => {
+    const content = (knowledge[key] || '').trim();
+    if (!content || content === 'N/A') return null;
+    return `## ${label}\n${content}`;
+  }).filter(Boolean);
+
+  if (sections.length === 0) return '';
+
+  return `<project_context>\nThe following is the project knowledge base. Use it to inform your work:\n\n${sections.join('\n\n')}\n</project_context>`;
+}
+
+let activeProcess = null;
+let activeTaskId = null;
+let progressLines = [];
+let stopped = false;
+let pendingTokens = null;
+
+let autoRunning = false;
+let autoQueue = [];
+let autoStopRequested = false;
+
+export const isTaskRunning = () => activeProcess !== null;
+export const isAutoRunning = () => autoRunning;
+
+export const getProgress = () => ({ lines: progressLines, tokens: pendingTokens });
+
+function parseTokensFromOutput(lines) {
+  if (pendingTokens && (pendingTokens.inputTokens > 0 || pendingTokens.outputTokens > 0)) {
+    return pendingTokens;
+  }
+
+  const combined = lines.join('\n');
+
+  const jsonMatch =
+    combined.match(/"input_tokens":\s*(\d+).*?"output_tokens":\s*(\d+)/s) ||
+    combined.match(/"output_tokens":\s*(\d+).*?"input_tokens":\s*(\d+)/s);
+  if (jsonMatch) {
+    const inputIdx =
+      jsonMatch[0].indexOf('input_tokens') <
+      jsonMatch[0].indexOf('output_tokens')
+        ? 1
+        : 2;
+    const outputIdx = inputIdx === 1 ? 2 : 1;
+    return {
+      inputTokens: parseInt(jsonMatch[inputIdx], 10),
+      outputTokens: parseInt(jsonMatch[outputIdx], 10),
+    };
+  }
+
+  const lineMatch =
+    combined.match(/Input tokens:\s*([\d,]+).*?Output tokens:\s*([\d,]+)/is) ||
+    combined.match(/Output tokens:\s*([\d,]+).*?Input tokens:\s*([\d,]+)/is);
+  if (lineMatch) {
+    const inputIdx =
+      lineMatch[0].toLowerCase().indexOf('input tokens:') <
+      lineMatch[0].toLowerCase().indexOf('output tokens:')
+        ? 1
+        : 2;
+    const outputIdx = inputIdx === 1 ? 2 : 1;
+    return {
+      inputTokens: parseInt(lineMatch[inputIdx].replace(/,/g, ''), 10),
+      outputTokens: parseInt(lineMatch[outputIdx].replace(/,/g, ''), 10),
+    };
+  }
+
+  const inputMatch = combined.match(/Input tokens:\s*([\d,]+)/i);
+  const outputMatch = combined.match(/Output tokens:\s*([\d,]+)/i);
+  if (inputMatch && outputMatch) {
+    return {
+      inputTokens: parseInt(inputMatch[1].replace(/,/g, ''), 10),
+      outputTokens: parseInt(outputMatch[1].replace(/,/g, ''), 10),
+    };
+  }
+
+  return null;
+}
+
+export const getAutoStatus = () => ({
+  running: autoRunning,
+  queue: autoQueue,
+  processing: activeTaskId,
+});
+
+export const get = ({ status }) => {
+  const db = getDB();
+  let tasks = db.data.tasks;
+  if (status) {
+    tasks = tasks.filter((t) => t.status === status);
+  }
+  return tasks;
+};
+
+export const getById = (id) => {
+  const db = getDB();
+  return db.data.tasks.find((t) => t.id === id) || null;
+};
+
+export const create = ({ priority, description, assignee }) => {
+  const db = getDB();
+
+  if (assignee && !db.data.members.find((m) => m.id === assignee)) {
+    return { error: `Assignee "${assignee}" not found` };
+  }
+
+  const task = {
+    id: crypto.randomUUID(),
+    priority: priority || 'medium',
+    description,
+    assignee: assignee || null,
+    status: 'todo',
+    inputTokens: null,
+    outputTokens: null,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  db.data.tasks.push(task);
+  db.write();
+
+  return task;
+};
+
+export const update = (id, updates) => {
+  const db = getDB();
+  const idx = db.data.tasks.findIndex((t) => t.id === id);
+
+  if (idx === -1) return null;
+
+  const allowed = ['priority', 'description', 'assignee', 'status'];
+  for (const key of allowed) {
+    if (updates[key] !== undefined) {
+      db.data.tasks[idx][key] = updates[key];
+    }
+  }
+
+  db.data.tasks[idx].updatedAt = new Date().toISOString();
+  db.write();
+  return db.data.tasks[idx];
+};
+
+export const remove = (id) => {
+  const db = getDB();
+  const idx = db.data.tasks.findIndex((t) => t.id === id);
+
+  if (idx === -1) return false;
+
+  db.data.tasks.splice(idx, 1);
+  db.write();
+  return true;
+};
+
+export const startTask = (id) => {
+  const db = getDB();
+
+  if (activeProcess) {
+    return { error: 'Another task is already running' };
+  }
+
+  const task = db.data.tasks.find((t) => t.id === id);
+  if (!task) return { error: 'Task not found' };
+
+  const { baseURL, apiKey, model } = db.data.meta;
+  if (!baseURL || !apiKey) {
+    return { error: 'Base URL and API Key must be configured in Settings' };
+  }
+
+  const effectiveModel = model && model !== 'auto' ? model : null;
+  const models = getCachedModels();
+  const resolvedModelId =
+    effectiveModel || (models.length > 0 ? models[0].id : null);
+
+  if (!resolvedModelId) {
+    return { error: 'No model available. Fetch models in Settings first.' };
+  }
+
+  task.status = 'doing';
+  task.updatedAt = new Date().toISOString();
+  db.write();
+
+  const startedAt = new Date().toISOString();
+  console.log(`[crewOS:${id}] ====== TASK STARTED ======`);
+  console.log(`[crewOS:${id}] time: ${startedAt}`);
+  console.log(`[crewOS:${id}] description: ${task.description}`);
+  console.log(`[crewOS:${id}] model: ${resolvedModelId}`);
+
+  let workingDir = process.cwd();
+  if (fs.existsSync(CREWOS_CONFIG_PATH)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(CREWOS_CONFIG_PATH, 'utf-8'));
+      workingDir = cfg.workingDir || process.cwd();
+    } catch {
+      /* ignore */
+    }
+  }
+  console.log(`[crewOS:${id}] cwd: ${workingDir}`);
+
+  const knowledge = getProjectKnowledge();
+  const knowledgeBlock = buildKnowledgeContext(knowledge);
+
+  let roleBlock = '';
+  if (task.assignee) {
+    const assignee = db.data.members.find((m) => m.id === task.assignee);
+    if (assignee) {
+      const roleParts = [];
+      if (assignee.role) roleParts.push(`# Role: ${assignee.role}`);
+      if (assignee.skills) roleParts.push(`## Skills\n${assignee.skills}`);
+      if (assignee.rules) roleParts.push(`## Rules\n${assignee.rules}`);
+      if (assignee.memory) roleParts.push(`## Memory\n${assignee.memory}`);
+      if (roleParts.length > 0) {
+        roleBlock = `<role_context>\nYou are acting as a "${assignee.name}" (${assignee.role}). Follow these instructions strictly:\n\n${roleParts.join('\n\n')}\n\nStay within the scope of your role. Do not edit files outside your domain.\n</role_context>`;
+      }
+    }
+  }
+
+  let prompt = task.description;
+  if (knowledgeBlock || roleBlock) {
+    prompt = [knowledgeBlock, roleBlock, `<task>\n${task.description}\n</task>`]
+      .filter(Boolean)
+      .join('\n\n');
+    console.log(
+      `[crewOS:${id}] prompt built (knowledge=${knowledgeBlock.length} chars, role=${roleBlock.length} chars)`,
+    );
+  }
+
+  const args = ['run', '--dangerously-skip-permissions', '--format', 'json', prompt];
+
+  const child = spawn('opencode', args, {
+    cwd: workingDir,
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  console.log(`[crewOS:${id}] spawned pid=${child.pid}`);
+
+  activeProcess = child;
+  activeTaskId = id;
+  progressLines = [];
+  stopped = false;
+  pendingTokens = null;
+
+  let disposition = null;
+  let timeout = null;
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+
+  timeout = setTimeout(() => {
+    if (disposition) {
+      console.log(
+        `[crewOS:${id}] timeout ignored (already disposed: ${disposition})`,
+      );
+      return;
+    }
+    if (stopped) {
+      console.log(`[crewOS:${id}] timeout ignored (stopped flag set)`);
+      return;
+    }
+
+    disposition = 'timeout';
+    console.warn(
+      `[crewOS:${id}] ====== TIMEOUT (${TASK_TIMEOUT_MS / 60000}m) ======`,
+    );
+
+    try {
+      const freshDb = getDB();
+      const t = freshDb.data.tasks.find((task) => task.id === id);
+      if (t) {
+        t.status = 'todo';
+        t.updatedAt = new Date().toISOString();
+        freshDb.write();
+        console.log(`[crewOS:${id}] status -> todo (timeout)`);
+      } else {
+        console.warn(`[crewOS:${id}] task not found in DB during timeout`);
+      }
+    } catch (e) {
+      console.error(`[crewOS:${id}] DB write failed on timeout: ${e.message}`);
+    }
+
+    try {
+      child.kill('SIGTERM');
+      const sigkillTimer = setTimeout(() => {
+        if (!child.killed) {
+          try {
+            child.kill('SIGKILL');
+          } catch {
+            /* noop */
+          }
+        }
+      }, 5000);
+      sigkillTimer.unref();
+    } catch (e) {
+      console.error(`[crewOS:${id}] kill failed on timeout: ${e.message}`);
+    }
+
+    activeProcess = null;
+    activeTaskId = null;
+  }, TASK_TIMEOUT_MS);
+
+  child.stdout.on('data', (data) => {
+    const text = data.toString();
+    stdoutBytes += Buffer.byteLength(text, 'utf-8');
+    const lines = text.split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        const part = event.part;
+        if (!part) continue;
+
+        if (part.type === 'text' && part.text) {
+          const sanitized = sanitizeProgressLine(part.text);
+          if (sanitized) progressLines.push(sanitized);
+        } else if (part.type === 'step-finish' && part.tokens) {
+          const prev = pendingTokens || { inputTokens: 0, outputTokens: 0 };
+          pendingTokens = {
+            inputTokens: prev.inputTokens + (part.tokens.input || 0),
+            outputTokens: prev.outputTokens + (part.tokens.output || 0),
+          };
+        } else {
+          const label = part.type || event.type || 'step';
+          progressLines.push(`[${label}]`);
+        }
+      } catch {
+        const sanitized = sanitizeProgressLine(line);
+        if (sanitized) progressLines.push(sanitized);
+      }
+    }
+  });
+
+  child.stderr.on('data', (data) => {
+    const text = data.toString();
+    stderrBytes += Buffer.byteLength(text, 'utf-8');
+    const lines = text.split('\n').filter(Boolean);
+    const sanitized = lines.map(sanitizeProgressLine).filter(Boolean);
+    progressLines.push(...sanitized);
+    console.log(`[crewOS:${id} stderr]`, text.slice(0, 500));
+  });
+
+  child.on('exit', (code, signal) => {
+    console.log(
+      `[crewOS:${id}] ====== EXIT ====== code=${code} signal=${signal} disposition=${disposition} stopped=${stopped}`,
+    );
+    console.log(
+      `[crewOS:${id}] io: stdout=${stdoutBytes}B stderr=${stderrBytes}B progressLines=${progressLines.length}`,
+    );
+
+    if (disposition) {
+      console.log(
+        `[crewOS:${id}] exit ignored — already disposed as '${disposition}'`,
+      );
+      return;
+    }
+
+    if (timeout) clearTimeout(timeout);
+
+    if (stopped) {
+      console.log(`[crewOS:${id}] exit ignored — task was stopped by user`);
+      return;
+    }
+
+    if (code === 0) {
+      disposition = 'done';
+      try {
+        const freshDb = getDB();
+        const t = freshDb.data.tasks.find((task) => task.id === id);
+        if (t) {
+          t.status = 'done';
+          t.updatedAt = new Date().toISOString();
+
+          const tokens = parseTokensFromOutput(progressLines);
+          if (tokens) {
+            t.inputTokens = tokens.inputTokens;
+            t.outputTokens = tokens.outputTokens;
+            console.log(
+              `[crewOS:${id}] tokens: input=${tokens.inputTokens} output=${tokens.outputTokens}`,
+            );
+          }
+
+          freshDb.write();
+          console.log(`[crewOS:${id}] status -> done (exit 0)`);
+        } else {
+          console.warn(`[crewOS:${id}] task not found in DB on exit`);
+        }
+      } catch (e) {
+        console.error(`[crewOS:${id}] DB write failed on exit: ${e.message}`);
+        disposition = null;
+      }
+    } else {
+      disposition = 'error';
+      console.warn(`[crewOS:${id}] non-zero exit code, reverting to todo`);
+      try {
+        const freshDb = getDB();
+        const t = freshDb.data.tasks.find((task) => task.id === id);
+        if (t) {
+          t.status = 'todo';
+          t.updatedAt = new Date().toISOString();
+          freshDb.write();
+          console.log(`[crewOS:${id}] status -> todo (exit ${code})`);
+        } else {
+          console.warn(`[crewOS:${id}] task not found in DB on error exit`);
+        }
+      } catch (e) {
+        console.error(
+          `[crewOS:${id}] DB write failed on error exit: ${e.message}`,
+        );
+        disposition = null;
+      }
+    }
+  });
+
+  child.on('close', (code, signal) => {
+    console.log(
+      `[crewOS:${id}] ====== CLOSE ====== code=${code} signal=${signal} disposition=${disposition} stopped=${stopped}`,
+    );
+
+    if (
+      disposition !== 'done' &&
+      disposition !== 'error' &&
+      disposition !== 'timeout'
+    ) {
+      if (!stopped) {
+        console.warn(
+          `[crewOS:${id}] close fired without prior exit! code=${code}`,
+        );
+        if (timeout) clearTimeout(timeout);
+        disposition = 'close-fallback';
+        try {
+          const freshDb = getDB();
+          const t = freshDb.data.tasks.find((task) => task.id === id);
+          if (t) {
+            t.status = code === 0 ? 'done' : 'todo';
+            t.updatedAt = new Date().toISOString();
+
+            if (code === 0) {
+              const tokens = parseTokensFromOutput(progressLines);
+              if (tokens) {
+                t.inputTokens = tokens.inputTokens;
+                t.outputTokens = tokens.outputTokens;
+                console.log(
+                  `[crewOS:${id}] tokens (close-fallback): input=${tokens.inputTokens} output=${tokens.outputTokens}`,
+                );
+              }
+            }
+
+            freshDb.write();
+            console.log(
+              `[crewOS:${id}] status -> ${t.status} (close-fallback)`,
+            );
+          }
+        } catch (e) {
+          console.error(
+            `[crewOS:${id}] DB write failed on close-fallback: ${e.message}`,
+          );
+        }
+      }
+    }
+
+    if (timeout) clearTimeout(timeout);
+    activeProcess = null;
+    activeTaskId = null;
+    console.log(`[crewOS:${id}] ====== TASK COMPLETE (${disposition}) ======`);
+  });
+
+  child.on('error', (err) => {
+    console.error(`[crewOS:${id}] ====== SPAWN ERROR ====== ${err.message}`);
+    if (disposition) {
+      console.log(
+        `[crewOS:${id}] spawn error ignored (already disposed: ${disposition})`,
+      );
+      return;
+    }
+    if (timeout) clearTimeout(timeout);
+
+    disposition = 'spawn-error';
+    try {
+      const freshDb = getDB();
+      const t = freshDb.data.tasks.find((task) => task.id === id);
+      if (t) {
+        t.status = 'todo';
+        t.updatedAt = new Date().toISOString();
+        freshDb.write();
+        console.log(`[crewOS:${id}] status -> todo (spawn error)`);
+      }
+    } catch (e) {
+      console.error(
+        `[crewOS:${id}] DB write failed on spawn error: ${e.message}`,
+      );
+    }
+
+    activeProcess = null;
+    activeTaskId = null;
+  });
+
+  return task;
+};
+
+export const stopTask = () => {
+  if (!activeProcess) {
+    return { error: 'No task is running' };
+  }
+
+  const taskId = activeTaskId;
+  console.log(`[crewOS:${taskId}] ====== STOP REQUESTED ======`);
+
+  stopped = true;
+  try {
+    activeProcess.kill('SIGTERM');
+    console.log(`[crewOS:${taskId}] SIGTERM sent`);
+  } catch (e) {
+    console.warn(`[crewOS:${taskId}] SIGTERM failed: ${e.message}`);
+  }
+
+  const db = getDB();
+  const t = db.data.tasks.find((task) => task.id === taskId);
+  if (t) {
+    t.status = 'todo';
+    t.updatedAt = new Date().toISOString();
+    db.write();
+    console.log(`[crewOS:${taskId}] status -> todo (stopped)`);
+  } else {
+    console.warn(`[crewOS:${taskId}] task not found in DB on stop`);
+  }
+
+  activeProcess = null;
+  activeTaskId = null;
+
+  return { success: true };
+};
+
+/* ---- auto-do ---- */
+
+function processNextAutoTask() {
+  if (autoStopRequested || !autoRunning) {
+    autoRunning = false;
+    autoStopRequested = false;
+    autoQueue = [];
+    console.log('[crewOS] Auto-do: cancelled');
+    return;
+  }
+
+  if (autoQueue.length === 0) {
+    autoRunning = false;
+    console.log('[crewOS] Auto-do: queue empty, done');
+    return;
+  }
+
+  const nextId = autoQueue.shift();
+  const db = getDB();
+  const task = db.data.tasks.find((t) => t.id === nextId);
+
+  if (!task || task.status === 'done') {
+    console.log(
+      `[crewOS] Auto-do: skipping ${nextId} (${!task ? 'not found' : 'already done'})`,
+    );
+    processNextAutoTask();
+    return;
+  }
+
+  if (task.status !== 'todo') {
+    task.status = 'todo';
+    task.updatedAt = new Date().toISOString();
+    db.write();
+    console.log(`[crewOS] Auto-do: reset ${nextId} to todo`);
+  }
+
+  console.log(
+    `[crewOS] Auto-do: starting "${task.description}" (${autoQueue.length} remaining)`,
+  );
+  const result = startTask(nextId);
+
+  if (result.error) {
+    console.log(`[crewOS] Auto-do: failed to start — ${result.error}`);
+    processNextAutoTask();
+    return;
+  }
+
+  const poll = () => {
+    if (autoStopRequested || !autoRunning) {
+      autoRunning = false;
+      autoStopRequested = false;
+      autoQueue = [];
+      return;
+    }
+
+    if (!activeProcess) {
+      processNextAutoTask();
+      return;
+    }
+
+    setTimeout(poll, 500);
+  };
+
+  setTimeout(poll, 500);
+}
+
+export const startAutoDo = (taskIds) => {
+  if (!Array.isArray(taskIds) || taskIds.length === 0) {
+    return { error: 'No tasks provided' };
+  }
+  if (activeProcess) {
+    return { error: 'Another task is already running' };
+  }
+
+  const db = getDB();
+  const validIds = taskIds.filter((id) => {
+    const t = db.data.tasks.find((task) => task.id === id);
+    return t && t.status !== 'done';
+  });
+
+  if (validIds.length === 0) {
+    return { error: 'No valid tasks to process' };
+  }
+
+  autoQueue = [...validIds];
+  autoRunning = true;
+  autoStopRequested = false;
+
+  processNextAutoTask();
+  return { success: true, queue: autoQueue };
+};
+
+export const stopAutoDo = () => {
+  if (!autoRunning) return { error: 'No auto process running' };
+
+  console.log('[crewOS] ====== AUTO-DO STOP REQUESTED ======');
+
+  autoStopRequested = true;
+  autoQueue = [];
+
+  if (activeProcess) {
+    console.log('[crewOS] Auto-do: stopping active task');
+    stopTask();
+  }
+
+  autoRunning = false;
+  autoStopRequested = false;
+
+  console.log('[crewOS] Auto-do: stopped');
+  return { success: true };
+};

package/backend/src/utils/catcher.js

@@ -0,0 +1,9 @@
+export const controllerCatcher = (fn) => {
+  return async (req, res, next) => {
+    try {
+      await fn(req, res, next);
+    } catch (err) {
+      next(err);
+    }
+  };
+};

package/backend/src/utils/sanitize.js

@@ -0,0 +1,13 @@
+const ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+const CONTROL_RE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+
+export function sanitizeProgressLine(line) {
+  let cleaned = line
+    .replace(ANSI_RE, '')
+    .replace(/\r/g, '')
+    .replace(CONTROL_RE, '')
+    .trim();
+
+  return cleaned;
+}