@oar-sh/oar 0.9.6 → 0.9.7

package/server/claude-cloud-worker/claude-cloud-session-worker.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// Claude Cloud session worker: a per-conversation Node process that speaks
+// the same relay contracts as the Claude/Cursor/Grok workers, but runs no
+// agent itself. The agent and its clone live in a Claude Code cloud session;
+// this process sends the user's messages there and follows the session's
+// event stream (claude-cloud-session-process.mjs).
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import {
+  loadTokenFromConfig,
+  resolveRelayServerUrl,
+} from '../../shared/worker-runtime/config-loader.mjs';
+import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
+import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
+import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
+import { createControlPoller } from '../../shared/control-poller.mjs';
+import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
+import { createClaudeCloudCredentials } from '../../shared/claude-cloud/credentials.mjs';
+import { createClaudeCloudClient } from '../../shared/claude-cloud/api-client.mjs';
+import { resolveClaudeCloudBaseUrl } from '../../shared/claude-cloud/base-url.mjs';
+import { createClaudeCloudSessionRunner } from './claude-cloud-session-process.mjs';
+
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const HEARTBEAT_MS = 10_000;
+
+function parseSessionIdArg(argv = process.argv) {
+  const index = argv.indexOf('--session-id');
+  if (index !== -1 && argv[index + 1]) return String(argv[index + 1]).trim();
+  const inline = argv.find((arg) => String(arg || '').startsWith('--session-id='));
+  if (inline) return String(inline.split('=')[1] || '').trim();
+  return String(process.env.SESSION_ID || '').trim();
+}
+
+function dbg(...parts) {
+  const timestamp = new Date().toISOString();
+  console.log(`[claude-cloud-worker ${timestamp}]`, ...parts);
+}
+
+async function main() {
+  const sdkSessionId = parseSessionIdArg();
+  if (!sdkSessionId) {
+    console.error('claude-cloud-session-worker: missing --session-id');
+    process.exit(2);
+  }
+
+  const configPath = String(process.env.COPILOT_WEB_RELAY_CONFIG || '').trim()
+    || path.resolve(__dirname, '..', 'config.json');
+  const serverUrl = resolveRelayServerUrl({ configPath });
+  const token = loadTokenFromConfig(configPath);
+  const defaultModel = String(process.env.CLAUDE_CLOUD_RELAY_MODEL || '').trim();
+
+  const api = createApiClient({
+    serverUrl,
+    token,
+    getHeaders: () => ({
+      'X-Relay-Process-Pid': String(process.pid),
+      'X-Relay-Parent-Pid': String(process.ppid),
+      'X-Relay-Session-Id': sdkSessionId,
+      'X-Relay-Conversation-Id': sdkSessionId,
+    }),
+  });
+
+  // The Claude CLI's login, read by the client's own module (the credentials
+  // file, or CLAUDE_CODE_OAUTH_TOKEN where the relay runs on one): this
+  // process never logs it. A login that has run out is nudged through the
+  // relay, which can run the CLI (`claude auth status` refreshes a login
+  // whose refresh token is still good); the file is read again afterwards.
+  // The base URL is the Anthropic API unless a test names a fake one on this
+  // machine (base-url.mjs takes nothing else).
+  const cloud = createClaudeCloudClient({
+    credentials: createClaudeCloudCredentials({
+      nudge: async () => {
+        const answer = await api('POST', '/api/claude-cloud/login-nudge', {});
+        dbg('login nudge', answer?.nudged ? 'ran' : 'skipped', answer?.expired ? 'still expired' : `expires ${answer?.expiresAt || '?'}`);
+      },
+    }),
+    baseUrl: resolveClaudeCloudBaseUrl(process.env),
+  });
+
+  const controlPoller = createControlPoller({
+    api,
+    sdkSessionId,
+    abortAckNote: 'cloud turn interrupted',
+    dbg,
+  });
+  const runner = createClaudeCloudSessionRunner({
+    api,
+    cloud,
+    sdkSessionId,
+    defaultModel,
+    controlPoller,
+    dbg,
+  });
+
+  let heartbeatTimer = null;
+  const heartbeat = createHeartbeatController({
+    api,
+    pollMs: HEARTBEAT_MS,
+    getSessionReady: () => true,
+    getHeartbeatTimer: () => heartbeatTimer,
+    setHeartbeatTimer: (timer) => { heartbeatTimer = timer; },
+    getActiveQueueMessageId: () => runner.getActiveQueueMessageId(),
+  });
+
+  const wsLink = createWorkerWebSocketLink({
+    serverUrl,
+    token,
+    dbg,
+    getSessionReady: () => true,
+    getSessionId: () => sdkSessionId,
+    getPid: () => process.pid,
+    onDeliver: async (pending, reason) => {
+      dbg('queue.deliver received', `reason=${reason}`, `msgId=${pending?.message?.id || 'none'}`);
+      try {
+        return await runner.handlePendingPayload(pending);
+      } catch (error) {
+        dbg('turn handling failed', error?.message || String(error));
+        return false;
+      }
+    },
+  });
+
+  const shutdown = async (signal) => {
+    dbg(`shutting down (${signal})`);
+    try { wsLink.stop(); } catch {}
+    try { heartbeat.stopHeartbeat(); } catch {}
+    try { controlPoller.stop(); } catch {}
+    // The cloud session is left as it is: a turn in flight keeps running
+    // there, and the next worker finds it through the stored sequence number.
+    try { await runner.dispose(); } catch {}
+    process.exit(0);
+  };
+  process.on('SIGTERM', () => { shutdown('SIGTERM'); });
+  process.on('SIGINT', () => { shutdown('SIGINT'); });
+  installWorkerCrashGuard({
+    api,
+    workerName: 'claude-cloud-session-worker',
+    getActiveQueueMessageIds: () => [runner.getActiveQueueAttempt()],
+  });
+
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} model=${defaultModel || 'default'}`);
+  heartbeat.startHeartbeat();
+  wsLink.start();
+}
+
+main().catch((error) => {
+  console.error('claude-cloud-session-worker fatal:', error?.stack || error?.message || error);
+  process.exit(1);
+});

package/server/claude-worker/claude-remote-relay-tool.mjs

@@ -62,6 +62,8 @@ export const REMOTE_RELAY_TOOL_ZOD_SHAPE = {
   provider: choice('provider', REMOTE_RELAY_PROVIDERS),
   model: text('model'),
   cwd: text('cwd'),
+  repo: text('repo'),
+  branch: text('branch'),
   mode: choice('mode', REMOTE_RELAY_MODES),
   effort: text('effort'),
   title: text('title'),

package/server/claude-worker/claude-sdk-adapter.mjs

@@ -111,7 +111,7 @@ export function normalizeAutoCompactWindow(value) {
  * spreads of `settings` in the options literal would silently clobber each
  * other. Returns null when nothing needs to be set.
  */
-export function claudeSpawnSettings({ ultracode = false, autoCompactWindow = null, thinkingEnabled = null } = {}) {
+export function claudeSpawnSettings({ ultracode = false, autoCompactWindow = null, thinkingEnabled = null, attribution = null } = {}) {
   const window = normalizeAutoCompactWindow(autoCompactWindow);
   const thinking = strictThinkingEnabled(thinkingEnabled);
   const settings = {
@@ -122,10 +122,25 @@ export function claudeSpawnSettings({ ultracode = false, autoCompactWindow = nul
     // present; the omit path exists for direct callers that mean to say
     // nothing.
     ...(thinking !== null ? { alwaysThinkingEnabled: thinking } : {}),
+    // What commits and PRs say (shared/claude-attribution.mjs). null is
+    // vanilla: the key is left out and the CLI uses its own.
+    ...(attribution && typeof attribution === 'object' ? { attribution } : {}),
   };
   return Object.keys(settings).length ? settings : null;
 }
 
+/**
+ * Live twin of the attribution spawn setting, for a value (OAR or off). A
+ * running CLI takes a new text through the flag layer (it arrives as a fresh
+ * system-reminder on the next user turn) but cannot UNSET a value it was
+ * spawned with — `{}`, `null` and `true` all leave the spawn-time text in
+ * force (wire-logged probe, 2026-10-01). Back to vanilla therefore means a
+ * fresh process without the key; the session runner does that.
+ */
+export function claudeAttributionFlagSettings(attribution) {
+  return { attribution: attribution && typeof attribution === 'object' ? attribution : { commit: '', pr: '', sessionUrl: false } };
+}
+
 export function permissionModeForRelayMode(relayMode) {
   const mode = String(relayMode || 'agent').trim().toLowerCase();
   if (mode === 'plan') return 'plan';
@@ -228,6 +243,7 @@ export function startClaudeSession({
   reasoningEffort = '',
   autoCompactWindow = null,
   thinkingEnabled = null,
+  attribution = null,
   thinkingDisplay = '',
   abortController,
   canUseTool,
@@ -248,7 +264,7 @@ export function startClaudeSession({
   // only way to hand a fresh CLI the session-scoped ultracode flag, the
   // auto-compact window and the thinking pin, and all three share one
   // `settings` object.
-  const spawnSettings = claudeSpawnSettings({ ultracode, autoCompactWindow, thinkingEnabled });
+  const spawnSettings = claudeSpawnSettings({ ultracode, autoCompactWindow, thinkingEnabled, attribution });
   // Relay tools need the worker's authenticated API helper; a caller that
   // passes none (tests, probes) gets a session without them.
   const relayMcpServer = typeof api === 'function'

package/server/claude-worker/claude-session-process.mjs

@@ -21,12 +21,14 @@ import {
   normalizeClaudeEffort,
   claudeUltracodeFlagSettings,
   claudeAutoCompactFlagSettings,
+  claudeAttributionFlagSettings,
   claudeThinkingFlagSettings,
   applyThinkingDisplay,
   normalizeAutoCompactWindow,
   permissionModeForRelayMode,
 } from './claude-sdk-adapter.mjs';
 import { parseThinkingDisplay, parseThinkingEnabled } from '../../shared/claude-thinking.mjs';
+import { sameClaudeAttribution } from '../../shared/claude-attribution.mjs';
 import { relocateClaudeTranscriptForCwd } from './claude-transcript-relocator.mjs';
 import {
   attemptFields,
@@ -448,6 +450,10 @@ export function createClaudeSessionRunner({
   // per turn rather than captured, so a slider change picked up on the next
   // delivery reaches a process that is already running.
   getAutoCompactWindow = () => null,
+  // What this session's commits say (shared/claude-attribution.mjs); null
+  // leaves the CLI's own attribution. Piggybacked on deliveries like the
+  // window above.
+  getAttribution = () => null,
   // The per-conversation thinking state ({enabled, display}); read per turn
   // like the window, so a settings change reaches a running process on its
   // next delivery.
@@ -3170,6 +3176,7 @@ export function createClaudeSessionRunner({
     const thinkingState = getThinking() || {};
     const thinkingEnabled = parseThinkingEnabled(thinkingState.enabled);
     const thinkingDisplay = parseThinkingDisplay(thinkingState.display);
+    const attribution = getAttribution() || null;
     const abortController = new AbortController();
     const processRef = {
       turn: null,
@@ -3178,6 +3185,7 @@ export function createClaudeSessionRunner({
       relayMode,
       effort,
       autoCompactWindow,
+      attribution,
       // Seeded from what the process is SPAWNED with, so the adapt diff is
       // against reality rather than against a delivered setting the CLI may
       // never have honored.
@@ -3335,6 +3343,7 @@ export function createClaudeSessionRunner({
       autoCompactWindow,
       thinkingEnabled,
       thinkingDisplay,
+      attribution,
       abortController,
       canUseTool,
       pathToClaudeCodeExecutable,
@@ -3443,6 +3452,30 @@ export function createClaudeSessionRunner({
       });
       proc.autoCompactWindow = autoCompactWindow;
     }
+    // Attribution follows the window's pattern: a changed value (a settings
+    // change, a model switch that renames the trailer) reaches the live CLI
+    // through the flag layer, before the turn that may commit.
+    const attribution = getAttribution() || null;
+    if (!sameClaudeAttribution(attribution, proc.attribution)) {
+      if (attribution === null) {
+        // Back to the CLI's own attribution. A value the process was spawned
+        // with cannot be unset through the flag layer (probe 2026-10-01), so
+        // the honest way is a fresh process without the key — taken when
+        // nothing lives in the old one; a busy process keeps the old text and
+        // the next delivery tries again.
+        if (!hasLiveWork() && !proc.liveTasks.size) {
+          gracefulShutdown('attribution-vanilla');
+          await drainClosingProcess(10_000);
+          return null;
+        }
+      } else {
+        expectSettingsReinit();
+        await Promise.resolve(proc.turn.applyFlagSettings?.(claudeAttributionFlagSettings(attribution))).catch((error) => {
+          dbg('applyFlagSettings attribution failed', error?.message || String(error));
+        });
+        proc.attribution = attribution;
+      }
+    }
     // Thinking is NOT a symmetric copy of the window block: the probe
     // (2026-08-26, docs/plans/claude-thinking-control.md) showed the two
     // directions of the on/off axis are not equally reachable mid-session.

package/server/claude-worker/claude-session-worker.mjs

@@ -17,6 +17,7 @@ import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-fil
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { resolveDeliveredAutoCompactWindow } from '../../shared/auto-compact-window.mjs';
 import { resolveDeliveredThinking } from '../../shared/claude-thinking.mjs';
+import { resolveDeliveredAttribution } from '../../shared/claude-attribution.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createClaudeSessionRunner } from './claude-session-process.mjs';
 import { createRunnerLinkBridge, failSettlingRowsOnShutdown } from './claude-worker-link-wiring.mjs';
@@ -66,6 +67,9 @@ async function main() {
   // piggyback. enabled null = host default; display defaults to 'summarized'
   // (today's behavior — visible thought bubbles).
   let thinking = resolveDeliveredThinking(null, null);
+  // What this session's commits and PRs say; same piggyback. null = the
+  // CLI's own attribution (vanilla).
+  let attribution = null;
 
   const api = createApiClient({
     serverUrl,
@@ -111,6 +115,7 @@ async function main() {
     getBackgroundTaskTimeoutMs: () => backgroundTaskTimeoutMs,
     getAutoCompactWindow: () => autoCompactWindow,
     getThinking: () => thinking,
+    getAttribution: () => attribution,
     // A readiness flip is a hold starting or ending (question card,
     // compaction, a turn-opening delivery): the steering snapshot changed
     // with it, so it goes out now rather than on the next 10 s heartbeat.
@@ -176,6 +181,7 @@ async function main() {
       // keep the last known state; an explicit null on thinkingEnabled is the
       // user choosing Host default.
       thinking = resolveDeliveredThinking(thinking, pending?.settings);
+      attribution = resolveDeliveredAttribution(attribution, pending?.settings);
       try {
         return await turnRunner.handlePendingPayload(pending);
       } catch (error) {

package/server/db-schema.mjs

@@ -11,6 +11,8 @@ import { rebuildRecentWorkspaceRootsTable } from './migrations/0002-recent-works
 import { ensurePushSubscriptionsTable } from './migrations/0003-push-subscriptions.mjs';
 import { migrateSteerSettleMarkers } from './migrations/0004-steer-settle-markers.mjs';
 import { migrateRemoteRelays } from './migrations/0005-remote-relays.mjs';
+import { migrateWorkspaceRootSettings } from './migrations/0006-workspace-root-settings.mjs';
+import { migrateClaudeCloud } from './migrations/0007-claude-cloud.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -717,6 +719,21 @@ try {
 } catch (error) {
   console.warn(`[remote-relays] migration 0005 failed; retrying on next boot: ${error?.message || error}`);
 }
+// Per-folder settings (commit attribution override). Readers tolerate the
+// table's absence, so a failure is logged and retried next boot like 0005.
+try {
+  migrateWorkspaceRootSettings(db);
+} catch (error) {
+  console.warn(`[workspace-root-settings] migration 0006 failed; retrying on next boot: ${error?.message || error}`);
+}
+// Claude Cloud conversations: the cloud session binding and what it clones.
+// Additive columns whose readers tolerate their absence, so a failure is
+// logged and retried next boot like 0006.
+try {
+  migrateClaudeCloud(db);
+} catch (error) {
+  console.warn(`[claude-cloud] migration 0007 failed; retrying on next boot: ${error?.message || error}`);
+}
 
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {

package/server/migrations/0006-workspace-root-settings.mjs

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Migration: per-folder settings (`workspace_root_settings`).
+ *
+ * The first setting a repo folder can carry is the commit attribution mode
+ * of its Claude sessions (shared/claude-attribution.mjs): a repo that forbids
+ * co-author trailers, or wants its own, overrides the provider setting for
+ * every session that runs in it. Keyed like `recent_workspace_roots`
+ * (`normalizeWorkspaceRootKey`), but its own table: the MRU list is pruned.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0006-workspace-root-settings.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateWorkspaceRootSettings(db) {
+  const existed = tableExists(db, 'workspace_root_settings');
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workspace_root_settings (
+      path_key         TEXT PRIMARY KEY,
+      path             TEXT NOT NULL,
+      attribution_mode TEXT,
+      updated_at       TEXT NOT NULL
+    )
+  `);
+  return { applied: !existed, tableCreated: !existed };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateWorkspaceRootSettings(db);
+  } finally {
+    db.close();
+  }
+}
+
+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 0006 on ${dbPath}`);
+    console.log(result.applied ? '  workspace_root_settings table created' : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0006 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0007-claude-cloud.mjs

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * Migration: storage for Claude Cloud conversations (provider `claude-cloud`).
+ *
+ * 1. `runtime_sessions.claude_cloud_session_id` — the cloud session a
+ *    conversation runs in, reported by its worker after the first message
+ *    (the per-provider native id, next to `claude_native_session_id`,
+ *    `cursor_agent_id` and `grok_native_session_id`).
+ * 2. `runtime_sessions.claude_cloud_last_sequence` — the last event sequence
+ *    the worker has handled: where it resumes the event stream after a restart.
+ * 3. `runtime_sessions.claude_cloud_cost_usd` — what the session has cost so
+ *    far, as the cloud reports it.
+ * 4. `conversations.cloud_source_json` — what the session clones and where it
+ *    is shown: `{ repoUrl, branch, environmentId, sessionUrl,
+ *    pushedBranches: [{ branch, at }] }`.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0007-claude-cloud.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+const COLUMNS = Object.freeze([
+  Object.freeze({ table: 'runtime_sessions', name: 'claude_cloud_session_id', type: 'TEXT' }),
+  Object.freeze({ table: 'runtime_sessions', name: 'claude_cloud_last_sequence', type: 'TEXT' }),
+  Object.freeze({ table: 'runtime_sessions', name: 'claude_cloud_cost_usd', type: 'REAL' }),
+  Object.freeze({ table: 'conversations', name: 'cloud_source_json', type: 'TEXT' }),
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => String(column.name)));
+}
+
+export function migrateClaudeCloud(db) {
+  let columnsAdded = 0;
+  for (const column of COLUMNS) {
+    if (!tableExists(db, column.table)) continue;
+    if (columnNames(db, column.table).has(column.name)) continue;
+    db.exec(`ALTER TABLE ${column.table} ADD COLUMN ${column.name} ${column.type}`);
+    columnsAdded += 1;
+  }
+  return { applied: columnsAdded > 0, columnsAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateClaudeCloud(db);
+  } finally {
+    db.close();
+  }
+}
+
+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 0007 on ${dbPath}`);
+    console.log(result.applied ? `  claude cloud columns added: ${result.columnsAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0007 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}