@oar-sh/oar 0.9.1 → 0.9.3

package/server/services/claude-auth-service.mjs

@@ -9,8 +9,10 @@ import { spawn } from 'child_process';
 import {
   CLI_SPAWN_DISABLED_ERROR,
   MAX_CAPTURED_OUTPUT_CHARS,
+  isBatchLauncher,
   joinWrappedLines,
   killTree as killProcessTree,
+  quoteForCmd,
   runToCompletion as runProcessToCompletion,
   scrubSecrets,
   stripTerminalEscapes,
@@ -235,11 +237,15 @@ export function createClaudeAuthService({
   function spawnAuthProcess(args, { pty = true, stdin = 'pipe' } = {}) {
     if (cliSpawnsDisabled()) throw new Error(CLI_SPAWN_DISABLED_ERROR);
     const bin = resolveClaudeAuthBinary(env);
+    // On Windows the npm-installed `claude` is `claude.cmd`, which only spawns
+    // through a shell — shared batch-launcher handling in cli-process-runner.mjs.
+    const batch = isBatchLauncher(bin, platform);
     const child = (!pty || platform === 'win32')
-      ? spawnImpl(bin, args, {
+      ? spawnImpl(batch ? quoteForCmd(bin) : bin, batch ? args.map(quoteForCmd) : args, {
         stdio: [stdin, 'pipe', 'pipe'],
         env: buildSpawnEnv(),
         windowsHide: true,
+        ...(batch ? { shell: true } : {}),
       })
       : spawnImpl('script', ['-qec', [bin, ...args].map(shellQuote).join(' '), '/dev/null'], {
         stdio: [stdin, 'pipe', 'pipe'],

package/server/services/cli-install-service.mjs

@@ -7,7 +7,9 @@ import path from 'path';
 import {
   CLI_SPAWN_DISABLED_ERROR,
   MAX_CAPTURED_OUTPUT_CHARS,
+  isBatchLauncher as isBatchLauncherImpl,
   killTree as killProcessTree,
+  quoteForCmd,
   runToCompletion as runProcessToCompletion,
   stripTerminalEscapes,
   tailOf,
@@ -499,35 +501,14 @@ export function createCliInstallService({
   }
 
   /**
-   * Windows cannot `CreateProcess` a `.cmd`/`.bat` at all, and Node has refused
-   * to pretend otherwise since the CVE-2024-27980 fix — it fails the spawn with
-   * EINVAL unless a shell is asked for explicitly. `candidateNames()` resolves
-   * exactly those extensions through PATHEXT, and npm's shim for `copilot` on a
-   * Windows host *is* `copilot.cmd` — so without this, that row would report
-   * "installed, version unknown" on every probe and any `.cmd`-shimmed
-   * update/migrate would die instantly.
+   * `candidateNames()` resolves `.cmd`/`.bat` through PATHEXT, and npm's shim
+   * for `copilot` on a Windows host *is* `copilot.cmd` — so without the shared
+   * batch-launcher handling (cli-process-runner.mjs, where the EINVAL story is
+   * documented), that row would report "installed, version unknown" on every
+   * probe and any `.cmd`-shimmed update/migrate would die instantly.
    */
   function isBatchLauncher(command) {
-    return platform === 'win32' && /\.(cmd|bat)$/i.test(String(command || ''));
-  }
-
-  /**
-   * `shell: true` makes Node join `[command, ...args]` with spaces into one
-   * string and hand it to `cmd.exe /d /s /c` *without quoting anything itself*,
-   * so every token has to be quoted here — `C:\Program Files\…\copilot.cmd`
-   * would otherwise split on its own space.
-   *
-   * This is belt-and-braces, not the security boundary: the argv is frozen
-   * literals from the descriptor table plus a path this module resolved off the
-   * filesystem, never anything a caller sent (§6). cmd.exe has no escape for a
-   * quote inside a quoted token — doubling it is the closest thing, and a
-   * Windows path cannot contain one anyway. `%VAR%` still expands inside double
-   * quotes; a bin directory named after a *set* environment variable would
-   * mis-resolve, which is the one residual gap and is still better than the
-   * alternative of not running batch launchers at all.
-   */
-  function quoteForCmd(value) {
-    return `"${String(value).replace(/"/g, '""')}"`;
+    return isBatchLauncherImpl(command, platform);
   }
 
   function spawnCliProcess(argv) {

package/server/services/cli-process-runner.mjs

@@ -102,6 +102,36 @@ export function tailOf(text, limit = MAX_ERROR_TAIL_CHARS) {
   return joined.length > limit ? `…${joined.slice(-limit)}` : joined;
 }
 
+/**
+ * Windows cannot `CreateProcess` a `.cmd`/`.bat` at all, and Node has refused
+ * to pretend otherwise since the CVE-2024-27980 fix — it fails the spawn with
+ * EINVAL unless a shell is asked for explicitly. npm ships every global CLI on
+ * Windows as exactly such a shim (`claude.cmd`, `copilot.cmd`), so every
+ * service that spawns a provider CLI needs the same detection; this is the one
+ * copy (lifted out of cli-install-service.mjs, which held it first).
+ */
+export function isBatchLauncher(command, platform = process.platform) {
+  return platform === 'win32' && /\.(cmd|bat)$/i.test(String(command || ''));
+}
+
+/**
+ * `shell: true` makes Node join `[command, ...args]` with spaces into one
+ * string and hand it to `cmd.exe /d /s /c` *without quoting anything itself*,
+ * so every token has to be quoted here — `C:\Program Files\…\claude.cmd`
+ * would otherwise split on its own space.
+ *
+ * This is belt-and-braces, not a security boundary: every caller passes argv
+ * built from frozen literals or a path it resolved off the filesystem, never
+ * anything a request sent. cmd.exe has no escape for a quote inside a quoted
+ * token — doubling it is the closest thing, and a Windows path cannot contain
+ * one anyway. `%VAR%` still expands inside double quotes; a directory named
+ * after a *set* environment variable would mis-resolve, which is the one
+ * residual gap and still better than refusing batch launchers outright.
+ */
+export function quoteForCmd(value) {
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
 /**
  * Signals the child's whole process group where the platform has one, so a
  * `script`/`bash -lc` wrapper cannot leave the real CLI running behind it.

package/server/services/copilot-model-discovery-service.mjs

@@ -0,0 +1,202 @@
+// Server-side Copilot model discovery (Phase 5A of the extension-retirement
+// track).
+//
+// Today the model catalog is only ever POPULATED by a running engine — the
+// extension and the standalone relay POST `/api/models/snapshot` when their
+// session comes up. Once the extension retires, a relay restart leaves the
+// catalog empty until the first SDK worker happens to spawn, and the composer's
+// model picker with it. This service closes that gap from the server side: a
+// short-lived `CopilotClient` (the same installed-CLI runtime the session
+// import service boots) answers `listModels()`, and the result feeds the SAME
+// in-process catalog the snapshot route feeds — no HTTP self-call, and the
+// entries are tagged `server-discovery:<reason>` alongside the existing
+// `web-relay-extension:<reason>` / `standalone-relay:<reason>` sources.
+//
+// Failure policy is log-and-skip throughout: the catalog keeps its previous
+// contents (persisted model-variant rows survive restarts), so a missing CLI,
+// a hung runtime or a refused list costs nothing but this refresh. The client
+// is disposed in `finally` — a discovery must never leave a runtime process
+// behind — and `dispose()` follows the SDK-session-import pattern so a refresh
+// in flight at shutdown cannot hang the exit.
+import { buildModelSnapshotFields, extractModelDescriptors } from '../../shared/model-descriptors.mjs';
+
+/** Same budget the Claude model discovery races `supportedModels()` against. */
+export const DEFAULT_COPILOT_MODEL_DISCOVERY_TIMEOUT_MS = 20_000;
+/**
+ * How long after boot the startup refresh fires. Staggered like the SDK
+ * session importer's startup sweep (which also boots an installed-CLI runtime
+ * from the listen callback) so the two spawns don't compete with serving the
+ * first page loads; nothing awaits it, so it never blocks startup.
+ */
+export const DEFAULT_COPILOT_MODEL_DISCOVERY_BOOT_DELAY_MS = 5_000;
+
+export function createCopilotModelDiscoveryService({
+  // () => Promise<{ client, dispose }> — createInstalledCopilotClient bound to
+  // the relay's config/workspace by the caller.
+  createClient,
+  // Feature detection: throws when no Copilot CLI runtime is resolvable
+  // (resolveInstalledCopilotPaths' contract). A relay without the CLI must not
+  // spawn anything or log an error per refresh — Copilot may simply not be one
+  // of its providers.
+  resolveInstalledPaths,
+  // The in-process catalog feed the snapshot route uses (server-runtime's
+  // updateModelCatalog) — fed directly, no HTTP self-call.
+  updateModelCatalog,
+  timeoutMs = DEFAULT_COPILOT_MODEL_DISCOVERY_TIMEOUT_MS,
+  bootDelayMs = DEFAULT_COPILOT_MODEL_DISCOVERY_BOOT_DELAY_MS,
+  logger = console,
+} = {}) {
+  if (typeof createClient !== 'function' || typeof updateModelCatalog !== 'function') {
+    throw new Error('Copilot model discovery requires a client factory and a catalog feed');
+  }
+  let closing = false;
+  let activeRefresh = null;
+  // The live client handle mid-refresh, so dispose() can tear it down FIRST —
+  // that is what makes a hung listModels() settle promptly at shutdown instead
+  // of holding the refresh (and the exit behind it) for the full timeout.
+  let activeRuntime = null;
+  let startupTimer = null;
+  // Set by the routes layer (which owns the provider-enriched catalog payload
+  // and the socket) so a successful discovery reaches connected clients the
+  // same way a snapshot POST does.
+  let onCatalogUpdated = () => {};
+
+  function raceTimeout(promise, label) {
+    return Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        const timer = setTimeout(
+          () => reject(new Error(`${label} timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+        timer.unref?.();
+      }),
+    ]);
+  }
+
+  function isCliResolvable() {
+    if (typeof resolveInstalledPaths !== 'function') return false;
+    try {
+      resolveInstalledPaths();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function refresh(reason = 'unspecified') {
+    if (closing) return { ok: false, skipped: true, models: [], error: 'Copilot model discovery is shutting down' };
+    // Single-flight: a manual refresh racing the boot refresh shares its run.
+    if (activeRefresh) return activeRefresh;
+    if (!isCliResolvable()) {
+      return { ok: false, skipped: true, models: [], error: 'Copilot CLI runtime is not installed' };
+    }
+    activeRefresh = (async () => {
+      const clientPromise = createClient();
+      let runtime = null;
+      try {
+        runtime = await raceTimeout(clientPromise, 'Copilot client start');
+        activeRuntime = runtime;
+        if (closing) return { ok: false, skipped: true, models: [], error: 'Copilot model discovery is shutting down' };
+        const modelInfos = await raceTimeout(runtime.client.listModels(), 'Copilot model discovery');
+        const descriptors = extractModelDescriptors(modelInfos);
+        if (!descriptors.length) {
+          // Log-and-skip, and deliberately no error write into the catalog:
+          // an empty answer must not degrade whatever a worker snapshot or a
+          // previous run already published.
+          logger.warn?.('[copilot-model-discovery] listModels returned no usable models');
+          return { ok: false, models: [], error: 'Copilot model discovery returned no models' };
+        }
+        // The typed client-level entries and the worker's raw session-level
+        // entries go through the same shared builder, so both publishers
+        // agree on every per-model metadata field.
+        const { models, contextLimitsByModel, modelMetadataByModel } = buildModelSnapshotFields(descriptors);
+        // No currentModel/defaultModel: a session-less listModels cannot know
+        // the active model, and updateModelCatalog keeps its existing pair
+        // when the snapshot omits them.
+        updateModelCatalog({
+          models,
+          contextLimitsByModel,
+          modelMetadataByModel,
+          source: `server-discovery:${reason}`,
+          error: null,
+        });
+        try {
+          onCatalogUpdated();
+        } catch (error) {
+          logger.warn?.(`[copilot-model-discovery] catalog-updated listener failed: ${error?.message || error}`);
+        }
+        return { ok: true, models, error: null };
+      } catch (error) {
+        const detail = String(error?.message || error || 'unknown error');
+        logger.warn?.(`[copilot-model-discovery] refresh (${reason}) failed: ${detail}`);
+        return { ok: false, models: [], error: `Copilot model discovery failed: ${detail}` };
+      } finally {
+        // dispose() may already have taken the handle mid-refresh; only tear
+        // down what this refresh still owns, so the runtime is disposed exactly
+        // once whichever side gets there first.
+        const owned = activeRuntime === runtime ? runtime : null;
+        activeRuntime = null;
+        if (owned) {
+          try {
+            await owned.dispose?.();
+          } catch (error) {
+            logger.warn?.(`[copilot-model-discovery] client dispose failed: ${error?.message || error}`);
+          }
+        } else if (!runtime) {
+          // The timeout won the start race: the spawn may still resolve later
+          // with a live runtime nobody owns — dispose it then (the same trade
+          // refreshGrokProviderModels makes with its late agent handle).
+          clientPromise.then((late) => late?.dispose?.()).catch(() => {});
+        }
+        activeRefresh = null;
+      }
+    })();
+    return activeRefresh;
+  }
+
+  /**
+   * The deferred boot trigger. Unref'd so a relay that exits immediately (a
+   * failed listen, a test) is not held open by a discovery it never wanted.
+   */
+  function scheduleStartupRefresh({ delayMs = bootDelayMs, reason = 'boot' } = {}) {
+    if (closing || startupTimer) return;
+    startupTimer = setTimeout(() => {
+      startupTimer = null;
+      void refresh(reason);
+    }, Math.max(0, Number(delayMs) || 0));
+    startupTimer.unref?.();
+  }
+
+  function setOnCatalogUpdated(listener) {
+    onCatalogUpdated = typeof listener === 'function' ? listener : () => {};
+  }
+
+  async function dispose() {
+    // Flag first, exactly like the session importer: refresh() must refuse new
+    // work before anything is torn down, or a concurrent caller respawns a
+    // runtime while the server is exiting.
+    closing = true;
+    if (startupTimer) {
+      clearTimeout(startupTimer);
+      startupTimer = null;
+    }
+    // Tear the live client down before awaiting the refresh: a hung
+    // listModels() only settles when its transport dies, and waiting the full
+    // discovery timeout here is exactly the shutdown hang this must avoid.
+    const runtime = activeRuntime;
+    activeRuntime = null;
+    if (runtime) {
+      try { await runtime.dispose?.(); } catch { /* best-effort at shutdown */ }
+    }
+    try { await activeRefresh; } catch { /* refresh() never rejects; belt only */ }
+  }
+
+  return {
+    refresh,
+    scheduleStartupRefresh,
+    setOnCatalogUpdated,
+    isCliResolvable,
+    dispose,
+  };
+}

package/server/services/data-dir-resolution.mjs

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Where the relay's database (and lock) live, decided before anything else
+ * touches disk.
+ *
+ * Precedence: the COPILOT_WEB_RELAY_DATA_DIR env var (launchers and the e2e
+ * harness pin it), then a `dataDir` key in config.json, then the server
+ * directory's own `data/`. The config key exists so an instance's identity —
+ * including where its data lives — travels entirely inside config.json: a
+ * dev checkout can point at a release install's data dir (the singleton
+ * guard's lock lives inside the data dir, so two relays sharing one refuse
+ * to run concurrently), and a regenerated autostart launcher only has to pin
+ * the config path to reproduce the whole instance.
+ *
+ * A relative `dataDir` resolves against the config file's directory, not the
+ * process cwd — the same config must mean the same data dir no matter where
+ * the server was launched from.
+ */
+export function resolveDataDir({
+  env = process.env,
+  configPath,
+  serverDir,
+  fsImpl = fs,
+  pathImpl = path,
+} = {}) {
+  const fromEnv = String(env?.COPILOT_WEB_RELAY_DATA_DIR || '').trim();
+  if (fromEnv) return pathImpl.resolve(fromEnv);
+
+  const resolvedConfigPath = String(configPath || '').trim();
+  if (resolvedConfigPath) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(fsImpl.readFileSync(resolvedConfigPath, 'utf8'));
+    } catch {
+      // Unreadable/absent/invalid config falls through to the default; the
+      // runtime reports config problems itself when it loads the file.
+    }
+    const fromConfig = String(parsed?.dataDir || '').trim();
+    if (fromConfig) {
+      return pathImpl.resolve(pathImpl.dirname(resolvedConfigPath), fromConfig);
+    }
+  }
+
+  return pathImpl.join(String(serverDir || ''), 'data');
+}

package/server/services/grok-auth-service.mjs

@@ -8,7 +8,9 @@ import { spawn } from 'child_process';
 import {
   CLI_SPAWN_DISABLED_ERROR,
   MAX_CAPTURED_OUTPUT_CHARS,
+  isBatchLauncher,
   killTree as killProcessTree,
+  quoteForCmd,
   runToCompletion as runProcessToCompletion,
   scrubSecrets,
   stripTerminalEscapes,
@@ -243,7 +245,13 @@ export function createGrokAuthService({
   function spawnGrokProcess(args) {
     if (cliSpawnsDisabled()) throw new Error(CLI_SPAWN_DISABLED_ERROR);
     const bin = resolveGrokAuthBinary(env);
-    return spawnImpl(bin, args, {
+    // A `grok` installed through npm (or any wrapper shipped as a shim) is
+    // `grok.cmd` on Windows, which only spawns through a shell — the shared
+    // batch-launcher handling (cli-process-runner.mjs) covers the EINVAL story
+    // and the quoting rules.
+    const batch = isBatchLauncher(bin, platform);
+    return spawnImpl(batch ? quoteForCmd(bin) : bin, batch ? args.map(quoteForCmd) : args, {
+      ...(batch ? { shell: true } : {}),
       // stdin is never written to, so it is closed outright rather than left as
       // a pipe nothing ever drains.
       stdio: ['ignore', 'pipe', 'pipe'],

package/server/services/live-turn-picker.mjs

@@ -0,0 +1,47 @@
+// Which of a conversation's processing queue rows is the LIVE turn.
+//
+// Mid-turn steering means a conversation can have more than one row in
+// `processing` at once: the running turn plus a message the user steered in,
+// which the CLI folds into that turn and which produces no stream or activity
+// of its own — or, after a replay handoff, the row that just took the turn
+// over while the handed-off row is still settling. The live turn is the row
+// that produced output MOST RECENTLY; with no output to separate them, the
+// oldest processing row (the turn a steered message joins). Kept pure so the
+// tie-break rules are testable without a DB.
+//
+// Recency, not volume: relay_stream_events.seq is only unique within one
+// queue_message_id, so comparing it across rows picked "the row with the most
+// events" — a long handed-off turn kept the live bubble (and Stop) from the
+// row that had actually taken over.
+
+/**
+ * @param {Array<{id:string, lastOutputAtMs?:number, streamDone?:boolean, processingAtMs?:number}>} rows
+ *   Processing rows for one conversation. `lastOutputAtMs` is when the row
+ *   last wrote a stream snapshot or activity line (0 = never); `streamDone`
+ *   marks a row whose main stream snapshot is final — a handed-off row
+ *   settling, whose closing snapshot re-stamps it as the newest write — and
+ *   ranks it below every row still open; `processingAtMs` is when it entered
+ *   processing (final tie-break; smaller = older = wins).
+ * @returns {string} the live turn's row id, or '' when there are no rows.
+ */
+export function pickLiveTurnRowId(rows = []) {
+  const list = Array.isArray(rows) ? rows.filter((row) => row && row.id) : [];
+  if (!list.length) return '';
+  if (list.length === 1) return String(list[0].id);
+  const finite = (value) => (Number.isFinite(Number(value)) ? Number(value) : 0);
+  let best = null;
+  for (const row of list) {
+    if (!best) { best = row; continue; }
+    if (Boolean(row.streamDone) !== Boolean(best.streamDone)) {
+      if (!row.streamDone) best = row;
+      continue;
+    }
+    const output = finite(row.lastOutputAtMs);
+    const bestOutput = finite(best.lastOutputAtMs);
+    if (output > bestOutput
+      || (output === bestOutput && finite(row.processingAtMs) < finite(best.processingAtMs))) {
+      best = row;
+    }
+  }
+  return String(best.id);
+}