@oar-sh/oar 0.9.0

package/server/services/relay-cli-launcher-service.mjs

@@ -0,0 +1,209 @@
+'use strict';
+
+import { execFileSync, spawn } from 'child_process';
+import { createSessionWorkerProcessInspector } from './session-worker-process-service.mjs';
+import { launchSessionCli } from './session-worker-launch-service.mjs';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isoNow(now) {
+  return new Date(now()).toISOString();
+}
+
+function parsePositiveInt(value) {
+  const num = Number.parseInt(String(value || ''), 10);
+  return Number.isInteger(num) && num > 0 ? num : null;
+}
+
+export function createRelayCliLauncherService({
+  platform = process.platform,
+  cwd = process.cwd(),
+  env = process.env,
+  now = () => Date.now(),
+  execFileSyncImpl = execFileSync,
+  spawnImpl = spawn,
+  sleepImpl = sleep,
+  restartDelayMs = 500,
+  killWaitMs = 700,
+  maxKillAttempts = 10,
+  log = () => {},
+} = {}) {
+  let activeJob = null;
+  const processInspector = createSessionWorkerProcessInspector({
+    platform,
+    execFileSyncImpl: typeof execFileSyncImpl === 'function' ? execFileSyncImpl : undefined,
+  });
+
+  function resolveCwd(targetSessionId = null) {
+    if (typeof cwd === 'function') {
+      const next = String(cwd(targetSessionId) || '').trim();
+      return next || process.cwd();
+    }
+    const next = String(cwd || '').trim();
+    return next || process.cwd();
+  }
+
+  function getState() {
+    if (!activeJob) return null;
+    return {
+      transactionId: activeJob.transactionId,
+      targetSessionId: activeJob.targetSessionId,
+      reason: activeJob.reason || null,
+      status: activeJob.status,
+      startedAt: activeJob.startedAt,
+      completedAt: activeJob.completedAt || null,
+      spawnedPid: activeJob.spawnedPid || null,
+      error: activeJob.error || null,
+      killedPids: Array.isArray(activeJob.killedPids) ? [...activeJob.killedPids] : [],
+    };
+  }
+
+  function collectWindowsRetirePids(targetSessionId) {
+    return processInspector.findWindowsProcessesForSession(targetSessionId)
+      .map((proc) => parsePositiveInt(proc?.processId))
+      .filter(Boolean);
+  }
+
+  function stopWindowsPids(pids) {
+    const ids = Array.from(new Set(
+      (Array.isArray(pids) ? pids : [pids])
+        .map((value) => parsePositiveInt(value))
+        .filter(Boolean),
+    ));
+    if (!ids.length) return [];
+    const script = [
+      '$ids = @(' + ids.join(',') + ')',
+      'foreach ($id in $ids) {',
+      '  try { Stop-Process -Id $id -Force -ErrorAction SilentlyContinue } catch {}',
+      '}',
+    ].join('; ');
+    execFileSyncImpl('powershell.exe', ['-NoProfile', '-Command', script], {
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    return ids;
+  }
+
+  async function retireCliProcesses(job) {
+    if (platform !== 'win32') return [];
+    const killed = new Set();
+    const attempts = Math.max(1, Number(maxKillAttempts || 1));
+    const liveTarget = processInspector.findWindowsProcessForSession(job.targetSessionId);
+    if (liveTarget?.processId) {
+      return Array.from(killed);
+    }
+    for (let index = 0; index < attempts; index += 1) {
+      let targetPids = [];
+      try {
+        targetPids = collectWindowsRetirePids(job.targetSessionId);
+      } catch (error) {
+        job.error = error?.message || String(error);
+        throw error;
+      }
+      if (!targetPids.length) return Array.from(killed);
+      for (const pid of stopWindowsPids(targetPids)) killed.add(pid);
+      await sleepImpl(Math.max(0, Number(killWaitMs || 0)));
+    }
+    return Array.from(killed);
+  }
+
+  async function spawnSessionCli(targetSessionId) {
+    const launched = await launchSessionCli({
+      targetSessionId,
+      cwd: resolveCwd(targetSessionId),
+      env,
+      platform,
+      spawnImpl,
+      execFileSyncImpl,
+      processInspector,
+    });
+    return launched;
+  }
+
+  async function runJob(job) {
+    job.status = 'running';
+    if (restartDelayMs > 0) {
+      await sleepImpl(restartDelayMs);
+    }
+    const liveTarget = processInspector.findProcessForSession(job.targetSessionId);
+    if (liveTarget?.processId) {
+      job.killedPids = [];
+      job.spawnedPid = liveTarget.processId;
+      job.status = 'skipped';
+      job.reason = 'target-already-running';
+      job.completedAt = isoNow(now);
+      log(`relay cli launcher: target ${job.targetSessionId} already running on pid ${liveTarget.processId}; skipping restart`);
+      return;
+    }
+    log(`relay cli launcher: retiring cli processes for ${job.targetSessionId} tx=${job.transactionId || 'none'}`);
+    job.killedPids = await retireCliProcesses(job);
+    log(`relay cli launcher: spawning session-bound cli for ${job.targetSessionId}`);
+    const launched = await spawnSessionCli(job.targetSessionId);
+    job.spawnedPid = launched?.pid || null;
+    if (launched?.launchMode === 'tmux' && launched?.tmuxSessionName) {
+      log(`relay cli launcher: worker session ${job.targetSessionId} running in tmux session ${launched.tmuxSessionName}`);
+    }
+    job.status = 'spawned';
+    job.completedAt = isoNow(now);
+  }
+
+  function scheduleRestart({ targetSessionId, transactionId = null, reason = null } = {}) {
+    const target = String(targetSessionId || '').trim();
+    const tx = String(transactionId || '').trim() || null;
+    if (!target) {
+      return { ok: false, error: 'missing-target-session', state: getState() };
+    }
+    const current = activeJob;
+    if (current && !current.completedAt && current.status !== 'failed') {
+      if (current.targetSessionId === target && current.transactionId === tx) {
+        return { ok: true, accepted: true, reused: true, state: getState() };
+      }
+      return { ok: false, error: 'launcher-busy', state: getState() };
+    }
+    const liveTarget = processInspector.findProcessForSession(target);
+    if (liveTarget?.processId) {
+      return {
+        ok: true,
+        accepted: false,
+        reused: true,
+        reason: 'target-already-running',
+        livePid: liveTarget.processId,
+        state: getState(),
+      };
+    }
+
+    const job = {
+      transactionId: tx,
+      targetSessionId: target,
+      reason: String(reason || '').trim() || null,
+      startedAt: isoNow(now),
+      completedAt: null,
+      status: 'scheduled',
+      spawnedPid: null,
+      error: null,
+      killedPids: [],
+      promise: null,
+    };
+    activeJob = job;
+    job.promise = runJob(job).catch((error) => {
+      job.status = 'failed';
+      job.completedAt = isoNow(now);
+      job.error = error?.message || String(error);
+      log(`relay cli launcher failed for ${job.targetSessionId}: ${job.error}`);
+    });
+    return { ok: true, accepted: true, reused: false, state: getState() };
+  }
+
+  async function waitForIdle() {
+    if (activeJob?.promise) {
+      await activeJob.promise;
+    }
+  }
+
+  return {
+    scheduleRestart,
+    waitForIdle,
+    getState,
+  };
+}

package/server/services/relay-prompt-sanitizer.mjs

@@ -0,0 +1,137 @@
+'use strict';
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const DEFAULT_RELAY_TOOL_GUIDANCE = [
+  '# Relay Tool Guidance',
+  'For any user-facing question or clarification, use the ask_user tool so the web relay can render question cards and buttons. Never ask questions in plain assistant text.',
+  'When using ask_user, ALWAYS include a `choices` array with 2-6 answer options so the web relay can render clickable buttons. Only omit choices when the question genuinely requires freeform text input.',
+  'In autopilot, still call ask_user when user input is truly blocking, because the relay bridge can surface the question even when the direct SDK question hook is bypassed.',
+  'For relay restarts in extension-managed mode, require explicit user permission first, then use the authenticated localhost API `POST /api/relay/shutdown`. Do not restart by killing processes or using respawn scripts.',
+  'Note: shutdown is queued and only completes when the current turn finishes, so it is pointless to wait for it to interrupt an active turn.',
+  'Use `restart: true` in the request body when the user wants a real relay restart rather than a plain shutdown. Example request body: `{ "reason": "manual-restart", "requestedBy": "localhost-api", "restart": true }`.',
+].join(' ');
+
+function loadRelayToolGuidance() {
+  try {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const guidancePath = path.resolve(moduleDir, '..', 'relay-tools.md');
+    const content = fs.readFileSync(guidancePath, 'utf8');
+    const parts = String(content || '')
+      .split(/\r?\n/)
+      .map((line) => String(line || '').trim())
+      .filter(Boolean);
+    return parts.length ? parts.join(' ') : DEFAULT_RELAY_TOOL_GUIDANCE;
+  } catch {
+    return DEFAULT_RELAY_TOOL_GUIDANCE;
+  }
+}
+
+const RELAY_TOOL_GUIDANCE = loadRelayToolGuidance();
+
+const MODE_MARKERS = {
+  plan: '[Relay mode: plan]',
+  ask: '[Relay mode: ask]',
+  autopilot: '[Relay mode: autopilot]',
+  agent: '[Relay mode: agent]',
+};
+
+const MODE_INSTRUCTIONS = {
+  plan: [
+    'Draft a concise plan only.',
+    'Use read-only inspection tools (glob, rg, view) only when they materially improve plan quality; otherwise draft from provided context.',
+    'Do not edit repository files or run mutating commands unless the user explicitly asks for implementation.',
+    'If clarification is required, pause and ask through the web relay.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+  ask: [
+    'Prioritize clarification questions before doing any implementation work.',
+    'If the request is ambiguous or underspecified, pause and ask through the web relay before making assumptions.',
+    'Do not make broad assumptions when a question would materially change the result.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+  autopilot: [
+    'Act directly on the request and use tools when needed.',
+    'Keep moving unless user input is truly blocking.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+  agent: [
+    'Proceed as an interactive coding agent and use tools as needed.',
+    'If you need clarification, pause and ask through the web relay instead of stalling silently.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+};
+
+const LEGACY_MODE_INSTRUCTIONS = {
+  plan: [
+    'Draft a concise plan only.',
+    'Do not edit files or run tools unless the user explicitly asks for implementation.',
+    'If clarification is required, pause and ask through the web relay.',
+  ].join(' '),
+  ask: [
+    'Prioritize clarification questions before doing any implementation work.',
+    'If the request is ambiguous or underspecified, pause and ask through the web relay before making assumptions.',
+    'Do not make broad assumptions when a question would materially change the result.',
+  ].join(' '),
+  autopilot: [
+    'Act directly on the request and use tools when needed.',
+    'Keep moving unless user input is truly blocking.',
+  ].join(' '),
+  agent: [
+    'Proceed as an interactive coding agent and use tools as needed.',
+    'If you need clarification, pause and ask through the web relay instead of stalling silently.',
+  ].join(' '),
+};
+
+function escapeRegExp(value) {
+  return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function whitespaceFlexiblePattern(value) {
+  return String(value || '')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((part) => escapeRegExp(part))
+    .join('\\s+');
+}
+
+function buildPromptPrefixPatterns(mode) {
+  const requestedMode = String(mode || '').trim().toLowerCase();
+  const modes = requestedMode && MODE_MARKERS[requestedMode]
+    ? [requestedMode]
+    : Object.keys(MODE_MARKERS);
+  return modes.flatMap((key) => {
+    const marker = MODE_MARKERS[key];
+    const currentFullPrefix = `${marker} ${MODE_INSTRUCTIONS[key]} ${RELAY_TOOL_GUIDANCE}`;
+    const legacyFullPrefix = `${marker} ${LEGACY_MODE_INSTRUCTIONS[key]} ${RELAY_TOOL_GUIDANCE}`;
+    return [
+      new RegExp(`^${whitespaceFlexiblePattern(currentFullPrefix)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(legacyFullPrefix)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(marker)}\\s*`, 'i'),
+    ];
+  });
+}
+
+function stripAttachmentPromptArtifacts(text) {
+  return String(text || '')
+    .replace(/<current_datetime>[\s\S]*?<\/current_datetime>/gi, '')
+    .replace(/<system_reminder>[\s\S]*?<\/system_reminder>/gi, '')
+    .replace(/\[Attached file references\][\s\S]*?\[\/Attached file references\]/gi, '')
+    .replace(/\[Attached image(?:s)?\s*:[\s\S]*?\]/gi, '')
+    .replace(/\[Attached file\s*:[\s\S]*?\]/gi, '')
+    .trim();
+}
+
+export function stripRelayPromptContext(text, relayMode = '', attachments = []) {
+  const value = stripAttachmentPromptArtifacts(text);
+  if (!value) return '';
+  const patterns = buildPromptPrefixPatterns(relayMode);
+  for (const pattern of patterns) {
+    const stripped = value.replace(pattern, '').trim();
+    if (stripped && stripped !== value) return stripped;
+  }
+  return value;
+}

package/server/services/relay-queue-gate-service.mjs

@@ -0,0 +1,38 @@
+'use strict';
+
+export function shouldParkForRestart(state) {
+  const value = String(state?.state || '').trim();
+  return value === 'draining' || value === 'restarting' || value === 'awaiting_rebind';
+}
+
+export function parkPendingQueueForRestart({ stmts, state, parkedAt = null } = {}) {
+  if (!stmts || !shouldParkForRestart(state)) return 0;
+  const result = stmts.parkPendingQueueForRestart.run({
+    parkedAt: parkedAt || new Date().toISOString(),
+    targetSessionId: state?.targetSessionId || null,
+    transactionId: state?.transactionId || null,
+    reason: state?.lastError || null,
+  });
+  return Number(result?.changes || 0);
+}
+
+export function releaseParkedQueueForReadyState({ db, stmts, state } = {}) {
+  const value = String(state?.state || '').trim();
+  const terminalIdle = value === 'idle' && String(state?.terminalOutcomeCode || '').trim();
+  if (!db || !stmts || (value !== 'ready' && !terminalIdle)) return [];
+  const rows = terminalIdle
+    ? stmts.listAllParkedQueueForRelease.all()
+    : stmts.listParkedQueueForRelease.all(
+      state?.transactionId || null,
+      state?.targetSessionId || null,
+    );
+  if (!rows.length) return [];
+  const tx = db.transaction(() => {
+    for (const row of rows) {
+      stmts.releaseParkedQueueByIds.run(row.id);
+    }
+  });
+  tx();
+  return rows;
+}
+