@oar-sh/oar 0.9.6 → 0.9.8

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

@@ -55,17 +55,6 @@ export function claudeUltracodeFlagSettings(effort) {
   return { ultracode: null, enableWorkflows: null, effortLevel: effort || null };
 }
 
-/**
- * The flag-settings payload that moves a live session onto another auto-compact
- * window. `null` clears the flag layer back to the CLI's model-tuned default,
- * which is exactly what "Auto" means — leaving the previous window pinned would
- * make the setting one-way.
- */
-export function claudeAutoCompactFlagSettings(autoCompactWindow) {
-  const window = normalizeAutoCompactWindow(autoCompactWindow);
-  return { autoCompactWindow: window };
-}
-
 /**
  * The flag-settings payload that pins (or clears) `alwaysThinkingEnabled` on a
  * live session.
@@ -111,7 +100,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 +111,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 +232,7 @@ export function startClaudeSession({
   reasoningEffort = '',
   autoCompactWindow = null,
   thinkingEnabled = null,
+  attribution = null,
   thinkingDisplay = '',
   abortController,
   canUseTool,
@@ -248,7 +253,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'