@oar-sh/oar 0.9.0

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

@@ -0,0 +1,236 @@
+// Shared test harness for the Claude session runner suites
+// (claude-session-process.test.mjs and
+// claude-session-process.routes-integration.test.mjs): the scripted SDK
+// stand-ins, SDK message builders, api stub, and runner factory they both use.
+// Not a *.test.mjs file on purpose — the node --test glob must not pick it up.
+
+import { createClaudeSessionRunner } from './claude-session-process.mjs';
+
+// Keeps the tests off the real `~/.claude/projects`; transcript relocation has
+// its own suite in claude-transcript-relocator.test.mjs.
+export const noopRelocate = () => ({ status: 'skipped' });
+
+export const tick = (ms = 5) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function waitFor(predicate, { timeoutMs = 3000, label = 'condition' } = {}) {
+  const start = Date.now();
+  for (;;) {
+    const value = predicate();
+    if (value) return value;
+    if (Date.now() - start > timeoutMs) throw new Error(`waitFor timed out: ${label}`);
+    await tick();
+  }
+}
+
+export function makeApiStub({ failRoutes = new Set(), continuationIds = [] } = {}) {
+  const calls = [];
+  let continuationCounter = 0;
+  return {
+    calls,
+    api: async (method, routePath, body) => {
+      calls.push({ method, routePath, body });
+      if (failRoutes.has(routePath)) throw new Error(`stubbed failure for ${routePath}`);
+      if (routePath === '/api/continuation-turn') {
+        continuationCounter += 1;
+        return { messageId: continuationIds[continuationCounter - 1] || `cont-${continuationCounter}` };
+      }
+      return { ok: true };
+    },
+  };
+}
+
+/**
+ * A scriptable stand-in for the SDK Query: the test emits SDK messages when it
+ * chooses, the stream only ends on endInput/close (like the real CLI), and
+ * pushed user turns are recorded (and optionally echoed back as replays).
+ * NOTE: the real CLI replays a pushed message when it DEQUEUES it — between
+ * turns for queued-behind messages, or mid-turn when it absorbs the push as
+ * steering — never at push time. echoPushes replays at push time, so it only
+ * models pushes made while no turn is active; scripts that queue a message
+ * behind a running turn must emit the replay manually at the dequeue point.
+ */
+export function scriptedTurn({ echoPushes = false } = {}) {
+  const queued = [];
+  let wake = null;
+  let ended = false;
+  const turn = {
+    pushed: [],
+    endInputCalls: 0,
+    closed: false,
+    interrupts: 0,
+    stoppedTasks: [],
+    pushUserMessage(content) {
+      if (ended) throw new Error('user message stream already ended');
+      turn.pushed.push(content);
+      if (echoPushes) {
+        turn.emit({ type: 'user', parent_tool_use_id: null, message: { role: 'user', content } });
+      }
+    },
+    endInput() {
+      turn.endInputCalls += 1;
+      ended = true;
+      wake?.();
+    },
+    close() {
+      turn.closed = true;
+      ended = true;
+      wake?.();
+    },
+    async interrupt() {
+      turn.interrupts += 1;
+    },
+    async stopTask(taskId) {
+      turn.stoppedTasks.push(taskId);
+    },
+    emit(message) {
+      queued.push(message);
+      wake?.();
+    },
+    fail(error) {
+      queued.push({ __throw: error });
+      wake?.();
+    },
+    async* [Symbol.asyncIterator]() {
+      for (;;) {
+        while (queued.length) {
+          const next = queued.shift();
+          if (next?.__throw) throw next.__throw;
+          yield next;
+        }
+        if (ended) return;
+        await new Promise((resolve) => { wake = resolve; });
+        wake = null;
+      }
+    },
+  };
+  return turn;
+}
+
+/** Emits the given messages, then the stream ends by itself. */
+export function fakeTurn(messages) {
+  return {
+    pushUserMessage() {},
+    endInput() {},
+    async* [Symbol.asyncIterator]() {
+      for (const message of messages) yield message;
+    },
+  };
+}
+
+export function initMessage(sessionId) {
+  return { type: 'system', subtype: 'init', session_id: sessionId, model: 'claude-sonnet-5' };
+}
+
+export function resultMessage(text, sessionId) {
+  return {
+    type: 'result', subtype: 'success', is_error: false, result: text, session_id: sessionId, num_turns: 1, duration_api_ms: 100,
+  };
+}
+
+export function phantomResultMessage(sessionId) {
+  return {
+    type: 'result', subtype: 'success', is_error: false, result: '', session_id: sessionId, num_turns: 0, duration_api_ms: 0,
+  };
+}
+
+export function backgroundTasksMessage(tasks) {
+  return { type: 'system', subtype: 'background_tasks_changed', tasks };
+}
+
+export function taskNotificationMessage(taskId, status = 'completed', { skipTranscript = false } = {}) {
+  return {
+    type: 'system',
+    subtype: 'task_notification',
+    task_id: taskId,
+    status,
+    summary: 'settled',
+    skip_transcript: skipTranscript,
+  };
+}
+
+/**
+ * The live wire shape: snake_case under `compact_metadata`, and `post_tokens`
+ * absent on every auto-compact payload observed (conv 563e252e, 2026-08-20).
+ */
+export function compactBoundaryMessage({ preTokens = 614117, postTokens = null, trigger = 'auto' } = {}) {
+  return {
+    type: 'system',
+    subtype: 'compact_boundary',
+    compact_metadata: {
+      trigger,
+      pre_tokens: preTokens,
+      ...(postTokens === null ? {} : { post_tokens: postTokens }),
+    },
+  };
+}
+
+/**
+ * The CLI's compaction announcement. Emitted ONCE, when compaction starts: the
+ * bundle's 30 s re-emit is gated on the remote-control client's activity
+ * callback, which the plain SDK `query()` this worker uses never registers.
+ */
+export function compactingStatusMessage(status = 'compacting') {
+  return { type: 'system', subtype: 'status', status };
+}
+
+/**
+ * The INFERRED shape of what re-opens the turn after an auto-compaction: the
+ * CLI's own summary message, which matches no delivered entry's text. Read off
+ * the on-disk transcript (`isCompactSummary: true`) plus the runner's observed
+ * behaviour in conv 563e252e — not captured from the SDK stream. What the
+ * tests actually pin is the runner's response to ANY turn-opening user message
+ * that follows a compaction and matches nothing pending.
+ */
+export function compactSummaryReplay() {
+  return userReplay('This session is being continued from a previous conversation that ran out of context.\n\nSummary:\n1. Primary Request…');
+}
+
+export function userReplay(text) {
+  return { type: 'user', parent_tool_use_id: null, message: { role: 'user', content: [{ type: 'text', text }] } };
+}
+
+/**
+ * A settled task's continuation as the SDK actually stamps it: `origin.kind`
+ * carries the provenance (SDKMessageOrigin) and `content` is a plain string,
+ * not a block array. Deliberately WITHOUT the `<task-notification>` tag in the
+ * text, so anything that passes only by tag-sniffing fails here.
+ */
+export function taskNotificationReplay(text = 'The background agent has finished its work.') {
+  return {
+    type: 'user',
+    parent_tool_use_id: null,
+    origin: { kind: 'task-notification' },
+    message: { role: 'user', content: text },
+  };
+}
+
+export function assistantText(text) {
+  return { type: 'assistant', parent_tool_use_id: null, message: { content: [{ type: 'text', text }] } };
+}
+
+// Frozen: tests derive per-test messages via spread ({ ...baseMessage, ... }),
+// never by mutating this object.
+export const baseMessage = Object.freeze({
+  id: 'q-1',
+  conversationId: 'conv-1',
+  relayMode: 'agent',
+  text: 'hello',
+  model: 'claude-sonnet-5',
+  attachments: [],
+});
+
+export function makeRunner({ stub, startImpl, ...overrides }) {
+  return createClaudeSessionRunner({
+    api: stub.api,
+    sdkSessionId: 'conv-1',
+    cwd: '/tmp',
+    relocateTranscriptImpl: noopRelocate,
+    startClaudeSessionImpl: startImpl,
+    continuationRetryDelayMs: 10,
+    ...overrides,
+  });
+}
+
+export async function settled(runner) {
+  await waitFor(() => !runner._getProcess(), { label: 'process teardown' });
+}

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

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+// Claude session worker: a per-conversation Node process that speaks the same
+// relay contracts as the Copilot CLI workers (worker WebSocket, heartbeat,
+// control polling, activity channels) but executes turns through the Claude
+// Agent SDK using the host machine's logged-in Claude credentials.
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import {
+  loadTokenFromConfig,
+  resolveRelayServerUrl,
+} from '../../.github/extensions/web-relay/runtime/config-loader.mjs';
+import { createApiClient } from '../../.github/extensions/web-relay/runtime/api-client.mjs';
+import { createWorkerWebSocketLink } from '../../.github/extensions/web-relay/runtime/worker-websocket-link.mjs';
+import { createHeartbeatController } from '../../.github/extensions/web-relay/polling/heartbeat.mjs';
+import { createControlPoller } from '../../shared/control-poller.mjs';
+import { resolveDeliveredAutoCompactWindow } from '../../shared/auto-compact-window.mjs';
+import { resolveDeliveredThinking } from '../../shared/claude-thinking.mjs';
+import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
+import { createClaudeSessionRunner } from './claude-session-process.mjs';
+
+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-worker ${timestamp}]`, ...parts);
+}
+
+async function main() {
+  const sdkSessionId = parseSessionIdArg();
+  if (!sdkSessionId) {
+    console.error('claude-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 cwd = String(process.env.COPILOT_WORKSPACE_ROOT || '').trim() || process.cwd();
+  const defaultModel = String(process.env.CLAUDE_RELAY_MODEL || '').trim();
+  const pathToClaudeCodeExecutable = String(process.env.CLAUDE_CODE_EXECUTABLE || '').trim();
+  // How long background tasks alone may keep the CLI process alive (0 = no
+  // limit). Seeded from the environment; refreshed from every delivery payload
+  // so the settings slider applies without a worker restart.
+  let backgroundTaskTimeoutMs = Number(process.env.CLAUDE_RELAY_BACKGROUND_TASK_TIMEOUT_MS) || 0;
+  // Per-conversation auto-compact window (token count, null = Auto); arrives
+  // piggybacked on each queue delivery, like the timeouts above.
+  let autoCompactWindow = null;
+  // Per-conversation thinking control ({enabled: bool|null, display}); same
+  // piggyback. enabled null = host default; display defaults to 'summarized'
+  // (today's behavior — visible thought bubbles).
+  let thinking = resolveDeliveredThinking(null, null);
+
+  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,
+    }),
+  });
+
+  const controlPoller = createControlPoller({
+    api,
+    sdkSessionId,
+    abortAckNote: 'claude query aborted',
+    // Backgrounded subagents are SDK tasks; their relay run id is the
+    // spawning tool_use id, which maps to a stoppable task id. (Late-bound:
+    // controls only poll while a turn is live, well after turnRunner exists.)
+    onAbortSubagent: (subagentRunId) => turnRunner.stopBackgroundTaskByToolUseId(subagentRunId),
+    dbg,
+  });
+  const turnRunner = createClaudeSessionRunner({
+    api,
+    sdkSessionId,
+    cwd,
+    defaultModel,
+    controlPoller,
+    pathToClaudeCodeExecutable,
+    idleShutdownMs: Number(process.env.CLAUDE_RELAY_IDLE_SHUTDOWN_MS) > 0
+      ? Number(process.env.CLAUDE_RELAY_IDLE_SHUTDOWN_MS)
+      : undefined,
+    // 0 disables the watchdog (matching the background-task timeout's
+    // 0 = no-limit convention); unset/invalid falls back to the default.
+    pendingDeliveredTimeoutMs: (() => {
+      const raw = String(process.env.CLAUDE_RELAY_PENDING_DELIVERED_TIMEOUT_MS || '').trim();
+      const parsed = Number(raw);
+      return raw !== '' && Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+    })(),
+    getBackgroundTaskTimeoutMs: () => backgroundTaskTimeoutMs,
+    getAutoCompactWindow: () => autoCompactWindow,
+    getThinking: () => thinking,
+    dbg,
+  });
+
+  let heartbeatTimer = null;
+  const heartbeat = createHeartbeatController({
+    api,
+    pollMs: HEARTBEAT_MS,
+    getSessionReady: () => true,
+    getHeartbeatTimer: () => heartbeatTimer,
+    setHeartbeatTimer: (timer) => { heartbeatTimer = timer; },
+    getActiveQueueMessageId: () => turnRunner.getActiveQueueMessageId(),
+    getActiveQueueMessageIds: () => turnRunner.getActiveQueueMessageIds(),
+  });
+
+  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'}`);
+      const deliveredTimeout = Number(pending?.settings?.backgroundTaskTimeoutMs);
+      if (Number.isFinite(deliveredTimeout) && deliveredTimeout >= 0) {
+        backgroundTaskTimeoutMs = deliveredTimeout;
+      }
+      // Absent (an older relay) leaves the last known value alone; an explicit
+      // null is the user choosing Auto and must clear the pin.
+      autoCompactWindow = resolveDeliveredAutoCompactWindow(autoCompactWindow, pending?.settings);
+      // Same presence semantics as the window: absent keys (an older relay)
+      // keep the last known state; an explicit null on thinkingEnabled is the
+      // user choosing Host default.
+      thinking = resolveDeliveredThinking(thinking, pending?.settings);
+      try {
+        return await turnRunner.handlePendingPayload(pending);
+      } catch (error) {
+        dbg('turn handling failed', error?.message || String(error));
+        return false;
+      }
+    },
+    onControl: async (control) => {
+      const type = String(control?.type || '').trim();
+      if (type === 'stop_background_task') {
+        const taskId = String(control?.taskId || '').trim();
+        dbg('stop background task control', taskId);
+        await turnRunner.stopBackgroundTask(taskId);
+        return;
+      }
+      dbg('unknown worker control ignored', type || '(none)');
+    },
+  });
+
+  const shutdown = (signal) => {
+    dbg(`shutting down (${signal})`);
+    try { wsLink.stop(); } catch {}
+    try { heartbeat.stopHeartbeat(); } catch {}
+    try { controlPoller.stop(); } catch {}
+    // Hard-close the persistent CLI process; a worker teardown cannot save
+    // its background tasks, and the orphan-notification replay on the next
+    // resume reports whatever they left behind.
+    try { turnRunner.shutdown({ graceful: false }); } catch {}
+    process.exit(0);
+  };
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  installWorkerCrashGuard({
+    api,
+    workerName: 'claude-session-worker',
+    getActiveQueueMessageIds: () => turnRunner.getActiveQueueMessageIds(),
+    onBeforeExit: () => { try { turnRunner.shutdown({ graceful: false }); } catch {} },
+  });
+
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}`);
+  heartbeat.startHeartbeat();
+  wsLink.start();
+}
+
+main().catch((error) => {
+  console.error('claude-session-worker fatal:', error?.stack || error?.message || error);
+  process.exit(1);
+});

package/server/claude-worker/claude-transcript-relocator.mjs

@@ -0,0 +1,189 @@
+import nodeFs from 'node:fs';
+import nodePath from 'node:path';
+import os from 'node:os';
+import { claudeProjectDirSlug, resolveClaudeProjectsRoots } from '../services/claude-session-root-service.mjs';
+
+// Keep a resumable Claude session resumable after its workspace root changes.
+//
+// The CLI stores a session as `<configRoot>/projects/<slug(cwd)>/<id>.jsonl`
+// and looks `resume` up in the project directory derived from the CWD of the
+// *current* process — not in the one that wrote the transcript. So changing a
+// conversation's CWD and relaunching the worker leaves every following turn
+// failing with `No conversation found with session ID: <id>`, permanently: the
+// id stays pinned in `runtime_sessions`, and the transcript stays behind in the
+// old workspace's project directory.
+//
+// Before a resuming turn starts, the transcript (and the sibling `<id>/`
+// directory holding subagent and tool-result files) is therefore moved into the
+// project directory for the current CWD.
+//
+// Moved, not copied: a copy left behind in the old directory is resumed again —
+// with its now-stale history — the moment the conversation switches back, which
+// silently drops every turn taken in between.
+//
+// The slug is built from the *real* path. The CLI resolves symlinks before
+// slugifying, so a symlinked workspace root (`/tmp` on macOS, a linked
+// checkout) otherwise targets a directory the CLI never reads.
+
+const SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const MAX_PROJECT_DIRS_SCANNED = 500;
+
+function isFile(fs, candidate) {
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDirectory(fs, candidate) {
+  try {
+    return fs.statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function modifiedAtMs(fs, candidate) {
+  try {
+    return Number(fs.statSync(candidate).mtimeMs) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Move `source` to `target`, falling back to copy+delete when the two live on
+ * different filesystems (`CLAUDE_CONFIG_DIR` on another mount than `$HOME`).
+ */
+function movePath(fs, source, target, { recursive = false } = {}) {
+  try {
+    fs.renameSync(source, target);
+    return;
+  } catch (error) {
+    if (error?.code !== 'EXDEV') throw error;
+  }
+  if (recursive) {
+    fs.cpSync(source, target, { recursive: true });
+    fs.rmSync(source, { recursive: true, force: true });
+    return;
+  }
+  fs.copyFileSync(source, target);
+  fs.rmSync(source, { force: true });
+}
+
+/**
+ * Move the session's sibling directory, merging into an existing target rather
+ * than replacing it. The source must always end up gone: a leftover `<id>/`
+ * still anchors the session to the old project directory for the relay's
+ * Session-root resolver, which would keep the file explorer pointed at it.
+ */
+function moveSessionDir(fs, source, target) {
+  if (!isDirectory(fs, target)) {
+    movePath(fs, source, target, { recursive: true });
+    return;
+  }
+  // Existing target files win — they belong to the session as it runs now.
+  fs.cpSync(source, target, { recursive: true, force: false, errorOnExist: false });
+  fs.rmSync(source, { recursive: true, force: true });
+}
+
+/**
+ * Find every project directory that currently holds `<nativeSessionId>.jsonl`,
+ * newest first. Bounded and never recursive: one readdir per configured root
+ * plus one stat per project directory.
+ */
+function findTranscriptSources({ fs, path, roots, nativeSessionId, excludeDir }) {
+  const transcriptName = `${nativeSessionId}.jsonl`;
+  const matches = [];
+  for (const root of roots) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    let scanned = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (scanned >= MAX_PROJECT_DIRS_SCANNED) break;
+      scanned += 1;
+      const projectDir = path.join(root, entry.name);
+      if (path.resolve(projectDir) === excludeDir) continue;
+      const transcriptPath = path.join(projectDir, transcriptName);
+      if (!isFile(fs, transcriptPath)) continue;
+      matches.push({ projectDir, transcriptPath, modifiedAtMs: modifiedAtMs(fs, transcriptPath) });
+    }
+  }
+  return matches.sort((a, b) => b.modifiedAtMs - a.modifiedAtMs);
+}
+
+/**
+ * Ensure the session `nativeSessionId` is resumable from `cwd`.
+ *
+ * Never throws: a relocation that cannot be completed leaves the CLI to report
+ * the missing session exactly as it did before, which is strictly better than
+ * failing a turn that might not even have needed the transcript.
+ *
+ * @returns {{ status: 'skipped'|'present'|'moved'|'missing'|'failed', from?: string, to?: string, error?: string }}
+ */
+export function relocateClaudeTranscriptForCwd({
+  nativeSessionId = '',
+  cwd = '',
+  fs = nodeFs,
+  path = nodePath,
+  env = process.env,
+  homedir = os.homedir,
+  dbg = () => {},
+} = {}) {
+  const sessionId = String(nativeSessionId || '').trim();
+  const workspaceRoot = String(cwd || '').trim();
+  // The id is joined into a filesystem path, so it is validated before any
+  // syscall rather than trusted.
+  if (!sessionId || !SESSION_ID_PATTERN.test(sessionId) || !workspaceRoot) return { status: 'skipped' };
+
+  const roots = resolveClaudeProjectsRoots({ env, homedir, path });
+  if (!roots.length) return { status: 'skipped' };
+
+  try {
+    let resolvedRoot = workspaceRoot;
+    try {
+      resolvedRoot = fs.realpathSync(workspaceRoot);
+    } catch {
+      // A workspace root that no longer exists cannot be resolved; the slug of
+      // the literal path is still the best guess.
+    }
+    // The CLI reads `CLAUDE_CONFIG_DIR` first and falls back to `~/.claude`,
+    // which is the order `resolveClaudeProjectsRoots` returns.
+    const targetProjectDir = path.join(roots[0], claudeProjectDirSlug(resolvedRoot));
+    const targetTranscriptPath = path.join(targetProjectDir, `${sessionId}.jsonl`);
+    if (isFile(fs, targetTranscriptPath)) return { status: 'present', to: targetTranscriptPath };
+
+    const sources = findTranscriptSources({
+      fs,
+      path,
+      roots,
+      nativeSessionId: sessionId,
+      excludeDir: path.resolve(targetProjectDir),
+    });
+    if (!sources.length) return { status: 'missing', to: targetTranscriptPath };
+
+    const source = sources[0];
+    fs.mkdirSync(targetProjectDir, { recursive: true });
+    movePath(fs, source.transcriptPath, targetTranscriptPath);
+
+    // The sibling directory is created lazily — only once the session produces
+    // subagent or tool-result files — so its absence is normal.
+    const sourceSessionDir = path.join(source.projectDir, sessionId);
+    if (isDirectory(fs, sourceSessionDir)) {
+      moveSessionDir(fs, sourceSessionDir, path.join(targetProjectDir, sessionId));
+    }
+
+    dbg(`relocated claude transcript ${sessionId} from ${source.projectDir} to ${targetProjectDir}`);
+    return { status: 'moved', from: source.transcriptPath, to: targetTranscriptPath };
+  } catch (error) {
+    const message = error?.message || String(error);
+    dbg(`claude transcript relocation failed for ${sessionId}: ${message}`);
+    return { status: 'failed', error: message };
+  }
+}