@oar-sh/oar 0.9.0

package/server/grok-worker/sdk-message-normalizer.mjs

@@ -0,0 +1,311 @@
+/**
+ * Map ACP session/update payloads onto the six relay channels used by
+ * Claude/Cursor workers: init, stream, thought, activity, subagent, result.
+ */
+import { capThought } from '../../shared/thought-cap.mjs';
+import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
+
+const MAX_TOOL_DETAIL_LENGTH = 140;
+const SUBAGENT_TOOL_NAMES = new Set(['task', 'agent', 'subagent']);
+
+function truncate(text, maxLength = MAX_TOOL_DETAIL_LENGTH) {
+  const value = String(text || '').trim();
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+export function extractTextContent(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (typeof content === 'object') {
+    if (typeof content.text === 'string') return content.text;
+    if (content.content && typeof content.content === 'object' && typeof content.content.text === 'string') {
+      return content.content.text;
+    }
+  }
+  return '';
+}
+
+// Re-exported (rather than defined here) so existing importers of this
+// normalizer keep working; the rule itself lives in shared/.
+export { shouldEmitStreamUpdate };
+
+export function summarizeToolInput(input) {
+  if (!input || typeof input !== 'object') {
+    if (typeof input === 'string') return truncate(input);
+    return '';
+  }
+  const candidates = [
+    input.command,
+    input.file_path,
+    input.path,
+    input.pattern,
+    input.description,
+    input.url,
+    input.query,
+    input.prompt,
+    input.title,
+  ];
+  for (const candidate of candidates) {
+    const value = String(candidate ?? '').trim();
+    if (value) return value;
+  }
+  try {
+    const serialized = JSON.stringify(input);
+    return serialized === '{}' ? '' : serialized;
+  } catch {
+    return '';
+  }
+}
+
+export function formatToolActivityText(toolName, input, title = '') {
+  const name = String(toolName || title || 'tool').trim() || 'tool';
+  const summary = summarizeToolInput(input) || String(title || '').trim();
+  return truncate(summary ? `Tool (${name}): ${summary}` : `Tool (${name})`);
+}
+
+export function isSubagentToolName(name) {
+  return SUBAGENT_TOOL_NAMES.has(String(name || '').trim().toLowerCase());
+}
+
+/**
+ * One instance per turn. `normalizeAcpUpdate(update)` returns zero or more
+ * `{ channel, payload }` actions.
+ */
+export function createSdkMessageNormalizer() {
+  let streamText = '';
+  let lastEmittedStreamText = '';
+  let openThought = null; // { reasoningId, text }
+  let stepIndex = 0;
+  let thoughtIndex = 0;
+  let lastUsage = null;
+  const knownSubagentRuns = new Map();
+  const seenToolFrames = new Set();
+
+  function allocateThoughtId() {
+    const id = `grok-thought-main-${stepIndex}-${thoughtIndex}`;
+    thoughtIndex += 1;
+    return id;
+  }
+
+  function closeOpenThought(actions) {
+    if (!openThought) return;
+    if (openThought.text.trim()) {
+      actions.push({
+        channel: 'thought',
+        payload: {
+          reasoningId: openThought.reasoningId,
+          text: openThought.text,
+          done: true,
+          subagentRunId: null,
+        },
+      });
+    }
+    openThought = null;
+  }
+
+  function normalizeAcpUpdate(update) {
+    const actions = [];
+    if (!update || typeof update !== 'object') return actions;
+
+    const kind = String(update.sessionUpdate || update.type || '').trim();
+
+    if (kind === 'agent_message_chunk' || kind === 'agent_message') {
+      const chunk = extractTextContent(update.content);
+      if (!chunk) return actions;
+      streamText += chunk;
+      if (shouldEmitStreamUpdate(streamText, lastEmittedStreamText)) {
+        lastEmittedStreamText = streamText;
+        actions.push({
+          channel: 'stream',
+          payload: {
+            text: streamText,
+            done: false,
+            subagentRunId: null,
+          },
+        });
+      }
+      return actions;
+    }
+
+    if (kind === 'agent_thought_chunk' || kind === 'agent_thought') {
+      const chunk = extractTextContent(update.content);
+      if (!chunk) return actions;
+      if (!openThought) {
+        openThought = { reasoningId: allocateThoughtId(), text: '' };
+      }
+      openThought.text = capThought(openThought.text + chunk);
+      actions.push({
+        channel: 'thought',
+        payload: {
+          reasoningId: openThought.reasoningId,
+          text: openThought.text,
+          done: false,
+          subagentRunId: null,
+        },
+      });
+      return actions;
+    }
+
+    if (kind === 'tool_call' || kind === 'tool_call_update') {
+      const toolCallId = String(update.toolCallId || update.tool_call_id || update.id || '').trim();
+      const title = String(update.title || '').trim();
+      // ACP's `kind` on a tool_call is the tool CATEGORY (read/edit/execute/
+      // think/…), not the tool's name — using it as the name produced labels
+      // like "Tool (execute)" and made subagent detection unreachable (a
+      // category is never 'task'/'agent'). Name fields win, then the title,
+      // with the category as the last-resort label.
+      const toolCategory = String(update.kind || '').trim();
+      const explicitToolName = String(update.name || update.toolName || '').trim();
+      const toolName = explicitToolName || title || toolCategory || 'tool';
+      const status = String(update.status || (kind === 'tool_call' ? 'pending' : '')).trim().toLowerCase();
+      const frameKey = `${toolCallId}\u0000${status || kind}`;
+      if (toolCallId && seenToolFrames.has(frameKey)) return actions;
+      if (toolCallId) seenToolFrames.add(frameKey);
+
+      const input = update.rawInput || update.input || update.arguments || null;
+      const activityText = formatToolActivityText(toolName, input, title);
+      if (activityText) {
+        actions.push({
+          channel: 'activity',
+          payload: {
+            text: activityText,
+            subagentRunId: null,
+          },
+        });
+      }
+
+      // Subagent lifecycle keys on the explicit tool name when present, and
+      // otherwise on a task/agent-shaped title — the category can never match.
+      const subagentLike = isSubagentToolName(explicitToolName)
+        || (!explicitToolName && /^(task|agent|subagent)\b/i.test(title));
+      if (subagentLike && toolCallId) {
+        const displayName = title || toolName;
+        if (status === 'pending' || status === 'in_progress' || status === 'running' || kind === 'tool_call') {
+          if (!knownSubagentRuns.has(toolCallId)) {
+            knownSubagentRuns.set(toolCallId, displayName);
+            actions.push({
+              channel: 'subagent',
+              payload: {
+                subagentRunId: toolCallId,
+                displayName,
+                status: 'running',
+                parentSubagentId: null,
+              },
+            });
+          }
+        }
+        if (status === 'completed' || status === 'failed' || status === 'error' || status === 'cancelled') {
+          if (knownSubagentRuns.has(toolCallId) || status) {
+            actions.push({
+              channel: 'subagent',
+              payload: {
+                subagentRunId: toolCallId,
+                displayName: knownSubagentRuns.get(toolCallId) || displayName,
+                status: status === 'completed' ? 'completed' : 'failed',
+                parentSubagentId: null,
+              },
+            });
+            knownSubagentRuns.delete(toolCallId);
+          }
+        }
+      }
+      return actions;
+    }
+
+    if (kind === 'usage_update' || kind === 'usage') {
+      lastUsage = {
+        used: update.used,
+        size: update.size,
+        cost: update.cost,
+        ...(typeof update === 'object' ? update : {}),
+      };
+      return actions;
+    }
+
+    if (kind === 'plan') {
+      const entries = Array.isArray(update.entries) ? update.entries : [];
+      const lines = entries
+        .map((entry) => String(entry?.content || entry?.text || entry?.title || '').trim())
+        .filter(Boolean);
+      if (lines.length) {
+        actions.push({
+          channel: 'activity',
+          payload: {
+            text: truncate(`Plan: ${lines.join(' · ')}`, 200),
+            subagentRunId: null,
+          },
+        });
+      }
+      return actions;
+    }
+
+    // Ignore user_message_chunk and unknown updates.
+    return actions;
+  }
+
+  function finalizeResult({
+    stopReason = '',
+    text = '',
+    isError = false,
+    errorMessage = '',
+    model = '',
+    usage = null,
+  } = {}) {
+    const actions = [];
+    closeOpenThought(actions);
+    const finalText = String(text || streamText || '').trim();
+    if (finalText && finalText !== lastEmittedStreamText) {
+      actions.push({
+        channel: 'stream',
+        payload: {
+          text: finalText,
+          done: true,
+          subagentRunId: null,
+        },
+      });
+      lastEmittedStreamText = finalText;
+      streamText = finalText;
+    } else if (streamText) {
+      actions.push({
+        channel: 'stream',
+        payload: {
+          text: streamText,
+          done: true,
+          subagentRunId: null,
+        },
+      });
+    }
+    // Prefer the prompt-result usage (authoritative per-turn totals). Fall back
+    // to any usage_update stream payload the normalizer already observed.
+    const resolvedUsage = usage && typeof usage === 'object' ? usage : lastUsage;
+    actions.push({
+      channel: 'result',
+      payload: {
+        text: finalText,
+        isError: isError === true,
+        errorMessage: String(errorMessage || '').trim(),
+        stopReason: String(stopReason || '').trim(),
+        usage: resolvedUsage,
+        model: String(model || '').trim(),
+      },
+    });
+    return actions;
+  }
+
+  function finalStreamText() {
+    return streamText;
+  }
+
+  return {
+    normalizeAcpUpdate,
+    finalizeResult,
+    finalStreamText,
+    get model() {
+      return '';
+    },
+    get lastUsage() {
+      return lastUsage;
+    },
+  };
+}

package/server/migrations/0001-add-structured-answer.mjs

@@ -0,0 +1,80 @@
+'use strict';
+
+/**
+ * Migration: add structured answer support to relay_questions.
+ *
+ * Adds two nullable TEXT columns used for multi-field `ask_user` / elicitation
+ * forms while preserving the existing single-string `answer` column for
+ * backward compatibility:
+ *   - structured_answer: JSON object of the user's per-field answers
+ *   - request_schema:     JSON of the elicitation requestedSchema (for validation)
+ *
+ * Safe to run repeatedly (idempotent) and against a live database — ADD COLUMN
+ * only takes a brief write lock and new columns default to NULL.
+ *
+ * Usage: node server/migrations/0001-add-structured-answer.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+const NEW_COLUMNS = [
+  { name: 'structured_answer', ddl: 'ALTER TABLE relay_questions ADD COLUMN structured_answer TEXT' },
+  { name: 'request_schema', ddl: 'ALTER TABLE relay_questions ADD COLUMN request_schema TEXT' },
+];
+
+export function migrate(dbPath) {
+  const db = new Database(dbPath);
+  try {
+    const tableExists = db
+      .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'relay_questions'`)
+      .get();
+    if (!tableExists) {
+      return { applied: [], skipped: NEW_COLUMNS.map((c) => c.name), reason: 'relay_questions table not found' };
+    }
+    const existing = new Set(
+      db.prepare(`PRAGMA table_info(relay_questions)`).all().map((c) => String(c.name)),
+    );
+    const applied = [];
+    const skipped = [];
+    const tx = db.transaction(() => {
+      for (const column of NEW_COLUMNS) {
+        if (existing.has(column.name)) {
+          skipped.push(column.name);
+          continue;
+        }
+        db.exec(column.ddl);
+        applied.push(column.name);
+      }
+    });
+    tx();
+    return { applied, skipped };
+  } finally {
+    db.close();
+  }
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    const applied = result.applied.length ? result.applied.join(', ') : '(none)';
+    const skipped = result.skipped.length ? result.skipped.join(', ') : '(none)';
+    console.log(`Migration 0001 on ${dbPath}`);
+    console.log(`  added:   ${applied}`);
+    console.log(`  existed: ${skipped}`);
+    if (result.reason) console.log(`  note:    ${result.reason}`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0001 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0002-recent-workspace-roots-path-key.mjs

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Migration: add a case-normalized dedupe key to recent_workspace_roots.
+ *
+ * The table's primary key used to be the raw `path`, which is case-sensitive.
+ * On Windows that means "C:\Git\Repo" and "c:\git\repo" are two rows for one
+ * directory: they burn through the 12-row cap and the UI then silently hides
+ * the duplicates (the client dedupes case-insensitively). This adds
+ *
+ *   path_key TEXT PRIMARY KEY   -- normalizeWorkspaceRootKey(path)
+ *   path     TEXT NOT NULL      -- most recently seen casing, for display
+ *
+ * and collapses existing rows, keeping the newest last_seen_at for each
+ * directory. The grouping is done in JS, not SQL, because SQLite's LOWER() and
+ * COLLATE NOCASE are ASCII-only and would also fold on POSIX, where paths
+ * really are case-sensitive.
+ *
+ * Idempotent: re-running once path_key exists is a no-op.
+ *
+ * Usage: node server/migrations/0002-recent-workspace-roots-path-key.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { normalizeWorkspaceRootKey } from '../services/workspace-root-path-policy.mjs';
+
+/**
+ * Rebuild against an already-open database handle.
+ * server-runtime.mjs calls this at startup so an existing database is upgraded
+ * before any prepared statement references path_key; the CLI entry point below
+ * wraps it for offline runs. Both paths therefore execute the same code.
+ */
+export function rebuildRecentWorkspaceRootsTable(db, { platform = process.platform } = {}) {
+  const tableExists = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'recent_workspace_roots'`)
+    .get();
+  if (!tableExists) {
+    return { applied: false, reason: 'recent_workspace_roots table not found', rowsBefore: 0, rowsAfter: 0 };
+  }
+  const columns = new Set(
+    db.prepare(`PRAGMA table_info(recent_workspace_roots)`).all().map((column) => String(column.name)),
+  );
+  if (columns.has('path_key')) {
+    return { applied: false, reason: 'path_key already present', rowsBefore: 0, rowsAfter: 0 };
+  }
+
+  const rows = db.prepare(`SELECT path, last_seen_at FROM recent_workspace_roots`).all();
+  const byKey = new Map();
+  for (const row of rows) {
+    const rawPath = String(row?.path || '').trim();
+    if (!rawPath) continue;
+    const key = normalizeWorkspaceRootKey(rawPath, platform);
+    if (!key) continue;
+    const lastSeenAt = String(row?.last_seen_at || '');
+    const existing = byKey.get(key);
+    // Newest last_seen_at wins, and with it the casing shown in the picker.
+    if (!existing || lastSeenAt > existing.lastSeenAt) {
+      byKey.set(key, { key, path: rawPath, lastSeenAt });
+    }
+  }
+
+  db.transaction(() => {
+    db.exec(`
+      CREATE TABLE recent_workspace_roots__new (
+        path_key     TEXT PRIMARY KEY,
+        path         TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL
+      );
+    `);
+    const insert = db.prepare(`
+      INSERT INTO recent_workspace_roots__new (path_key, path, last_seen_at)
+      VALUES (?, ?, ?)
+    `);
+    for (const entry of byKey.values()) insert.run(entry.key, entry.path, entry.lastSeenAt);
+    db.exec(`DROP INDEX IF EXISTS idx_recent_workspace_roots_last_seen`);
+    db.exec(`DROP TABLE recent_workspace_roots`);
+    db.exec(`ALTER TABLE recent_workspace_roots__new RENAME TO recent_workspace_roots`);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_recent_workspace_roots_last_seen
+        ON recent_workspace_roots(last_seen_at DESC)
+    `);
+  })();
+
+  return { applied: true, rowsBefore: rows.length, rowsAfter: byKey.size };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath);
+  try {
+    return rebuildRecentWorkspaceRootsTable(db, options);
+  } finally {
+    db.close();
+  }
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0002 on ${dbPath}`);
+    if (result.applied) {
+      console.log(`  rebuilt: ${result.rowsBefore} row(s) -> ${result.rowsAfter} distinct directory/ies`);
+    } else {
+      console.log(`  skipped: ${result.reason}`);
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0002 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0003-push-subscriptions.mjs

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * Migration: add the push_subscriptions table for Web Push notifications.
+ *
+ * One row per subscribed browser installation. `endpoint` is unique because a
+ * re-subscribe from the same browser must update in place, and `device_id` is
+ * the durable per-device identity (localStorage `copilot_device_id`) that a
+ * device keeps across subscription churn. `preferences_json` carries the whole
+ * per-device notification preference set so it travels with the subscription.
+ *
+ * Idempotent: re-running once the table exists is a no-op. The main schema
+ * block in server-runtime.mjs also has a CREATE TABLE IF NOT EXISTS for fresh
+ * databases; this module exists so existing databases upgrade at startup and
+ * so the migration can be run offline against a db file.
+ *
+ * Usage: node server/migrations/0003-push-subscriptions.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const PUSH_SUBSCRIPTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS push_subscriptions (
+    id             TEXT PRIMARY KEY,
+    device_id      TEXT NOT NULL,
+    device_label   TEXT,
+    endpoint       TEXT NOT NULL UNIQUE,
+    keys_json      TEXT NOT NULL,
+    preferences_json TEXT NOT NULL,
+    user_agent     TEXT,
+    created_at     TEXT NOT NULL,
+    updated_at     TEXT NOT NULL,
+    last_success_at TEXT,
+    last_error     TEXT,
+    failure_count  INTEGER NOT NULL DEFAULT 0
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_push_subscriptions_device
+    ON push_subscriptions(device_id);
+`;
+
+/**
+ * Ensure the table exists on an already-open database handle.
+ * server-runtime.mjs calls this at startup; the CLI entry point below wraps it
+ * for offline runs. Both paths execute the same code.
+ */
+export function ensurePushSubscriptionsTable(db) {
+  const tableExists = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'push_subscriptions'`)
+    .get();
+  if (tableExists) {
+    return { applied: false, reason: 'push_subscriptions already present' };
+  }
+  db.exec(PUSH_SUBSCRIPTIONS_SCHEMA);
+  return { applied: true };
+}
+
+export function migrate(dbPath) {
+  const db = new Database(dbPath);
+  try {
+    return ensurePushSubscriptionsTable(db);
+  } finally {
+    db.close();
+  }
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0003 on ${dbPath}`);
+    console.log(result.applied ? '  created push_subscriptions' : `  skipped: ${result.reason}`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0003 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}