@oar-sh/oar 0.9.0

package/server/server.js

@@ -0,0 +1,24 @@
+'use strict';
+
+import { fileURLToPath } from 'url';
+import { isExternallySupervised, isRelayRuntimeInvocation, runDirectRelaySupervisor } from './relay-self-restart.mjs';
+
+const scriptPath = fileURLToPath(import.meta.url);
+const runtimeArgs = process.argv.slice(2);
+const interactiveStdio = process.stdin.isTTY && process.stdout.isTTY && process.stderr.isTTY;
+
+// `--relay-runtime` marks the child this script spawned. `--supervised` means an
+// outer supervisor (the CLI extension) owns restarts and needs to observe exit
+// code 75 itself, so the runtime runs in this process instead of a grandchild.
+if (isRelayRuntimeInvocation(runtimeArgs) || isExternallySupervised(runtimeArgs)) {
+  await import('./server-runtime.mjs');
+} else {
+  await runDirectRelaySupervisor({
+    scriptPath,
+    args: runtimeArgs,
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: interactiveStdio ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+    logger: console,
+  });
+}

package/server/services/ask-user-routing-service.mjs

@@ -0,0 +1,117 @@
+'use strict';
+
+function normalizeId(value) {
+  const text = String(value || '').trim();
+  return text || null;
+}
+
+function loadRelayQuestionColumns(db) {
+  try {
+    const rows = db.prepare(`PRAGMA table_info(relay_questions)`).all();
+    return new Set(rows.map((row) => String(row?.name || '').trim()).filter(Boolean));
+  } catch {
+    return new Set();
+  }
+}
+
+export function createAskUserRoutingService(db, options = {}) {
+  const continuationRoutingEnabled = options?.continuationRoutingEnabled === true;
+  const sessionWorkerRegistry = options?.sessionWorkerRegistry || null;
+  const relayQuestionColumns = loadRelayQuestionColumns(db);
+  const hasContinuationColumns =
+    relayQuestionColumns.has('continuation_id')
+    && relayQuestionColumns.has('continuation_question_id');
+  const hasStructuredAnswerColumn = relayQuestionColumns.has('structured_answer');
+
+  const findQuestion = db.prepare(`SELECT * FROM relay_questions WHERE id = ?`);
+  const updateAnswered = db.prepare(`
+    UPDATE relay_questions
+    SET status = 'answered', answer = ?, answered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+    WHERE id = ?
+  `);
+  const updateAnsweredStructured = hasStructuredAnswerColumn
+    ? db.prepare(`
+      UPDATE relay_questions
+      SET status = 'answered', answer = ?, structured_answer = ?, answered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+      WHERE id = ?
+    `)
+    : null;
+  const findBySdkSessionAndMessage = db.prepare(`
+    SELECT * FROM relay_questions
+    WHERE sdk_session_id = ? AND message_id = ?
+    LIMIT 1
+  `);
+  const findByContinuation = hasContinuationColumns
+    ? db.prepare(`
+      SELECT *
+      FROM relay_questions
+      WHERE continuation_id = ?
+        AND continuation_question_id = ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `)
+    : null;
+
+  function routeAnswer({ question_id, sdk_session_id, answer, structured_answer, conversation_id, continuation_id, continuation_question_id }) {
+    const row = findQuestion.get(question_id);
+    if (!row) return { ok: false, error: 'Question not found' };
+
+    const rowSession = normalizeId(row.sdk_session_id);
+    const incomingSession = normalizeId(sdk_session_id);
+    const rowConversation = normalizeId(row.conversation_id);
+    const incomingConversation = normalizeId(conversation_id);
+    const rowContinuationId = normalizeId(row.continuation_id);
+    const incomingContinuationId = normalizeId(continuation_id);
+    const rowContinuationQuestionId = normalizeId(row.continuation_question_id);
+    const incomingContinuationQuestionId = normalizeId(continuation_question_id);
+    const ownerWorkerId = normalizeId(row.owner_worker_id);
+    const workerOwnerSessionId = ownerWorkerId
+      ? normalizeId(sessionWorkerRegistry?.getWorkerByWorkerId?.(ownerWorkerId)?.sdkSessionId)
+      : null;
+
+    if (continuationRoutingEnabled) {
+      if (rowContinuationId && incomingContinuationId && rowContinuationId !== incomingContinuationId) {
+        return { ok: false, error: 'continuation mismatch' };
+      }
+      if (rowContinuationQuestionId && incomingContinuationQuestionId && rowContinuationQuestionId !== incomingContinuationQuestionId) {
+        return { ok: false, error: 'continuation question mismatch' };
+      }
+      if (rowConversation && incomingConversation && rowConversation !== incomingConversation) {
+        return { ok: false, error: 'conversation mismatch' };
+      }
+      if (rowSession && workerOwnerSessionId && rowSession !== workerOwnerSessionId) {
+        return { ok: false, error: 'owner mismatch' };
+      }
+    }
+
+    const expectedSession = rowSession || workerOwnerSessionId;
+    if (expectedSession || incomingSession) {
+      if (!expectedSession || !incomingSession || expectedSession !== incomingSession) {
+        return { ok: false, error: 'session mismatch' };
+      }
+    }
+
+    if (structured_answer && updateAnsweredStructured) {
+      updateAnsweredStructured.run(answer, structured_answer, question_id);
+    } else {
+      updateAnswered.run(answer, question_id);
+    }
+    return { ok: true };
+  }
+
+  function lookupQuestion({ sdk_session_id, message_id, continuation_id, continuation_question_id }) {
+    const continuationId = normalizeId(continuation_id);
+    const continuationQuestionId = normalizeId(continuation_question_id);
+    if (hasContinuationColumns && continuationId && continuationQuestionId) {
+      const continuationMatch = findByContinuation?.get(continuationId, continuationQuestionId) || null;
+      if (continuationMatch) return continuationMatch;
+    }
+
+    const sessionId = normalizeId(sdk_session_id);
+    const messageId = normalizeId(message_id);
+    if (!sessionId || !messageId) return null;
+    return findBySdkSessionAndMessage.get(sessionId, messageId) || null;
+  }
+
+  return { routeAnswer, lookupQuestion };
+}

package/server/services/cache-rebuild-service.mjs

@@ -0,0 +1,236 @@
+'use strict';
+
+function normalizeId(value) {
+  return String(value || '').trim();
+}
+
+function buildLegacyConversationList(db) {
+  return db.prepare(`
+    SELECT id, sdk_session_id, archived, status, updated_at
+    FROM conversations
+    WHERE status != 'deleted'
+      AND (sdk_session_id IS NULL OR sdk_session_id = '')
+    ORDER BY updated_at DESC, id ASC
+  `);
+}
+
+function buildBoundConversationList(db) {
+  return db.prepare(`
+    SELECT id, sdk_session_id
+    FROM conversations
+    WHERE status != 'deleted'
+      AND sdk_session_id IS NOT NULL
+      AND sdk_session_id != ''
+    ORDER BY updated_at DESC, id ASC
+  `);
+}
+
+function buildConversationActivityStatements(db) {
+  return {
+    queueCount: db.prepare(`
+      SELECT COUNT(*) AS cnt
+        FROM queue
+        WHERE conversation_id = ?
+        AND status IN ('pending', 'processing', 'parked')
+    `),
+    runtimeSessionCount: db.prepare(`
+      SELECT COUNT(*) AS cnt
+      FROM runtime_sessions
+      WHERE conversation_id = ?
+    `),
+    pendingQuestionCount: db.prepare(`
+      SELECT COUNT(*) AS cnt
+      FROM relay_questions
+      WHERE conversation_id = ?
+        AND status = 'pending'
+    `),
+    conversationRows: db.prepare(`
+      SELECT id
+      FROM conversations
+      WHERE status != 'deleted'
+    `),
+  };
+}
+
+export function createCacheRebuildService({
+  db,
+  stmts,
+  io,
+  fs,
+  path,
+  uploadsDir,
+  bootstrapRuntimeSessionBindings,
+  collectOrphanedUploadsFromConversation,
+  deleteOrphanedUploads,
+}) {
+  const legacyConversationList = buildLegacyConversationList(db);
+  const boundConversationList = buildBoundConversationList(db);
+  const activity = buildConversationActivityStatements(db);
+
+  function isLegacyConversationActive(conversationId) {
+    const sid = normalizeId(conversationId);
+    if (!sid) return false;
+    const queueCount = Number(activity.queueCount.get(sid)?.cnt || 0);
+    const runtimeSessionCount = Number(activity.runtimeSessionCount.get(sid)?.cnt || 0);
+    const pendingQuestionCount = Number(activity.pendingQuestionCount.get(sid)?.cnt || 0);
+    return queueCount > 0 || runtimeSessionCount > 0 || pendingQuestionCount > 0;
+  }
+
+  function purgeConversation(conversationId) {
+    const sid = normalizeId(conversationId);
+    if (!sid) return [];
+    const orphanedUploads = collectOrphanedUploadsFromConversation(sid);
+    db.transaction(() => {
+      db.prepare(`DELETE FROM relay_questions WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM relay_boards WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM relay_activity WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM relay_stream_events WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM relay_thought WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM queue WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM messages WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM runtime_sessions WHERE conversation_id = ?`).run(sid);
+      db.prepare(`DELETE FROM conversations WHERE id = ?`).run(sid);
+    })();
+    deleteOrphanedUploads(orphanedUploads);
+    return orphanedUploads;
+  }
+
+  function archiveConversation(conversationId) {
+    const sid = normalizeId(conversationId);
+    if (!sid) return false;
+    const result = db.prepare(`UPDATE conversations SET archived = 1, updated_at = ? WHERE id = ? AND status != 'deleted'`).run(new Date().toISOString(), sid);
+    return Number(result?.changes || 0) > 0;
+  }
+
+  function fullWipeCache() {
+    const now = new Date().toISOString();
+    const conversationIds = activity.conversationRows.all().map((row) => normalizeId(row?.id)).filter(Boolean);
+    const manualTitleConversations = db.prepare(`
+      SELECT id
+      FROM conversations
+      WHERE status != 'deleted'
+        AND title_source = 'manual'
+    `).all().map((row) => normalizeId(row?.id)).filter(Boolean);
+    const manualTitleConversationSet = new Set(manualTitleConversations);
+    const uploadHashes = [];
+    for (const conversationId of conversationIds) {
+      for (const hash of collectOrphanedUploadsFromConversation(conversationId)) {
+        if (!uploadHashes.includes(hash)) uploadHashes.push(hash);
+      }
+    }
+
+    db.transaction(() => {
+      db.prepare(`DELETE FROM relay_questions`).run();
+      db.prepare(`DELETE FROM relay_boards`).run();
+      db.prepare(`DELETE FROM relay_activity`).run();
+      db.prepare(`DELETE FROM relay_stream_events`).run();
+      db.prepare(`DELETE FROM relay_thought`).run();
+      db.prepare(`DELETE FROM queue`).run();
+      db.prepare(`DELETE FROM messages`).run();
+      db.prepare(`DELETE FROM runtime_sessions`).run();
+      db.prepare(`DELETE FROM conversations WHERE status = 'deleted' OR title_source != 'manual'`).run();
+      for (const conversationId of manualTitleConversations) {
+        db.prepare(`
+          UPDATE conversations
+          SET archived = 0,
+              status = 'active',
+              compacted_into = NULL,
+              compacted_from = NULL,
+              summary_seed = NULL,
+              seed_pending = 0,
+              updated_at = ?
+          WHERE id = ?
+        `).run(now, conversationId);
+      }
+      db.prepare(`DELETE FROM deleted_sdk_sessions`).run();
+      db.prepare(`DELETE FROM sdk_delete_requests`).run();
+      db.prepare(`DELETE FROM sdk_session_imports`).run();
+      db.prepare(`DELETE FROM upload_refs`).run();
+      db.prepare(`DELETE FROM uploaded_files`).run();
+    })();
+
+    deleteOrphanedUploads(uploadHashes);
+
+    if (uploadsDir && fs?.existsSync?.(uploadsDir)) {
+      try {
+        for (const entry of fs.readdirSync(uploadsDir, { withFileTypes: true })) {
+          const entryPath = path.join(uploadsDir, entry.name);
+          fs.rmSync(entryPath, { recursive: true, force: true });
+        }
+      } catch {}
+      try {
+        fs.mkdirSync(uploadsDir, { recursive: true });
+      } catch {}
+    }
+
+    return {
+      wipedAt: now,
+      conversationsRemoved: conversationIds.length - manualTitleConversations.length,
+      manualTitleConversationsRetained: manualTitleConversationSet.size,
+      uploadsRemoved: uploadHashes.length,
+    };
+  }
+
+  function reconcileCache() {
+    const legacyRows = legacyConversationList.all();
+    const summary = {
+      purgedConversationIds: [],
+      archivedConversationIds: [],
+      retainedConversationIds: [],
+      runtimeSessionsBootstrapped: 0,
+      uploadsRemoved: 0,
+    };
+
+    for (const row of legacyRows) {
+      const conversationId = normalizeId(row?.id);
+      if (!conversationId) continue;
+
+      if (isLegacyConversationActive(conversationId)) {
+        if (archiveConversation(conversationId)) {
+          summary.archivedConversationIds.push(conversationId);
+        } else {
+          summary.retainedConversationIds.push(conversationId);
+        }
+        continue;
+      }
+
+      purgeConversation(conversationId);
+      summary.purgedConversationIds.push(conversationId);
+    }
+
+    summary.runtimeSessionsBootstrapped = bootstrapRuntimeSessionBindings();
+    return summary;
+  }
+
+  function rebuildCache({ mode = 'reconcile' } = {}) {
+    const normalizedMode = String(mode || 'reconcile').trim().toLowerCase();
+    if (normalizedMode === 'full' || normalizedMode === 'wipe' || normalizedMode === 'rebuild') {
+      return {
+        mode: 'full',
+        summary: fullWipeCache(),
+      };
+    }
+
+    if (normalizedMode !== 'reconcile') {
+      const error = new Error(`Unsupported cache rebuild mode: ${normalizedMode || 'empty'}`);
+      error.statusCode = 400;
+      throw error;
+    }
+
+    return {
+      mode: 'reconcile',
+      summary: reconcileCache(),
+    };
+  }
+
+  return {
+    rebuildCache,
+    reconcileCache,
+    fullWipeCache,
+    purgeConversation,
+    archiveConversation,
+    isLegacyConversationActive,
+    listLegacyConversations: () => legacyConversationList.all(),
+    listBoundConversations: () => boundConversationList.all(),
+  };
+}