nolo-cli 0.1.44 → 0.1.46

package/cli/machineCommands.ts

@@ -1,307 +0,0 @@
-import type { MachineHeartbeat } from "../connector-experimental/protocol";
-import { detectMachineInfo } from "../connector-experimental/machineInfo";
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
-import {
-  type HeartbeatLoopOptions,
-  runHeartbeatLoop as defaultRunHeartbeatLoop,
-} from "../connector-experimental/heartbeatLoop";
-import {
-  buildMachinePermissionPromptBlock,
-  resolveMachineRunPermissionPolicy,
-} from "../ai/agent/machineRunPermissions";
-import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
-import {
-  checkConnectorWorkspaceLinks,
-  runMachineDaemonCommand,
-} from "./machineDaemonCommands";
-import { runMachineHeartbeatConnectCommand } from "./machineHeartbeatCommands";
-import { runMachineWatchCommand } from "./machineWatchCommands";
-import {
-  handleConnectorRunMessage,
-  type LocalCliExecutor,
-} from "./machineWsRunDispatch";
-import {
-  defaultConnectWebSocket,
-  runMachineWsSession,
-  type ConnectorWebSocketOptions,
-} from "./machineWsSession";
-export {
-  formatMachineStatus,
-  runMachineStatusCommand,
-  type MachineSummary,
-} from "./machineStatusCommands";
-
-type EnvLike = Record<string, string | undefined>;
-type OutputLike = { write(chunk: string): unknown };
-
-type MachineCommandDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  signal?: AbortSignal;
-  cliEntrypointPath?: string;
-  maxConnectorAttempts?: number;
-  sleep?: (ms: number) => Promise<void>;
-  fetchImpl?: typeof fetch;
-  machineInfo?: () => MachineHeartbeat;
-  runHeartbeatLoop?: (options: HeartbeatLoopOptions) => Promise<void>;
-  connectWebSocket?: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
-  executeCli?: LocalCliExecutor;
-  validateWorkspaceLinks?: (cwd: string) => string[] | Promise<string[]>;
-  spawnDaemon?: (args: {
-    cmd: string[];
-    cwd: string;
-    env: EnvLike;
-    logPath: string;
-  }) => { pid?: number };
-};
-
-function resolveServerUrl(env: EnvLike) {
-  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
-}
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
-}
-
-function writeAuthMissing(output: OutputLike) {
-  output.write(
-    "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
-  );
-}
-
-function hasFlag(args: string[], flag: string) {
-  return args.includes(flag);
-}
-
-function readOption(args: string[], flag: string) {
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === flag) {
-      const next = args[i + 1];
-      if (typeof next === "string" && !next.startsWith("-")) return next;
-      return "";
-    }
-    if (arg.startsWith(flag + "=")) {
-      return arg.slice(flag.length + 1);
-    }
-  }
-  return "";
-}
-
-function resolveConnectServerUrl(args: string[], env: EnvLike) {
-  const fromFlag = readOption(args, "--server-url") || readOption(args, "--server");
-  const raw = fromFlag || env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL;
-  return String(raw).replace(/\/+$|\s+$/g, "").replace(/\/+$/g, "").replace(/\s+$/g, "");
-}
-
-function resolveConnectAuthToken(args: string[], env: EnvLike) {
-  return readOption(args, "--machine-key") || readOption(args, "--token") || resolveAuthToken(env);
-}
-
-const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
-
-async function sleepWithAbort(ms: number, sleep: (ms: number) => Promise<void>, signal?: AbortSignal) {
-  if (!signal) {
-    await sleep(ms);
-    return;
-  }
-  if (signal.aborted) return;
-  await Promise.race([
-    sleep(ms),
-    new Promise<void>((resolve) => {
-      signal.addEventListener("abort", () => resolve(), { once: true });
-    }),
-  ]);
-}
-
-function resolveConnectorReconnectDelayMs(env: EnvLike) {
-  const raw = Number(env.NOLO_CONNECT_RECONNECT_MS ?? "");
-  return Number.isFinite(raw) && raw >= 0 ? raw : 5_000;
-}
-
-async function defaultExecuteCli(
-  provider: string,
-  prompt: string,
-  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean; env?: EnvLike }
-) {
-  const { executeCli } = await import("../ai/agent/cliExecutor");
-  return executeCli(provider as any, prompt, options);
-}
-
-function detectLaunchableMachineInfo() {
-  return detectMachineInfo({ probeLaunchable: true });
-}
-
-function findTaskRowSubjectRef(runtimeContext: any) {
-  const subjectRefs = Array.isArray(runtimeContext?.subjectRefs) ? runtimeContext.subjectRefs : [];
-  for (const ref of subjectRefs) {
-    if (!ref || typeof ref !== "object" || Array.isArray(ref)) continue;
-    if (ref.kind !== "table-row") continue;
-    const id = typeof ref.id === "string" ? ref.id.trim() : "";
-    if (id) return id;
-  }
-  return "";
-}
-
-function buildTaskEvidencePrompt(args: {
-  agentKey: string;
-  agentConfig: any;
-  runtimeContext: any;
-}) {
-  const rowDbKey = findTaskRowSubjectRef(args.runtimeContext);
-  if (!rowDbKey) return "";
-  return [
-    "--- Nolo task evidence context ---",
-    "This CLI runtime does not receive server-side function tools directly.",
-    "Use the task row subjectRef and linked dialog/activity evidence as the durable task context.",
-    "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
-    "Release boundary: after review passes, AI/reviewer/Codex may advance alpha for verification. Do not merge, push, or release main/release unless the human owner explicitly authorizes it in the current task context.",
-    "Handoff context: inspect activityRefs/latestActivityRef, dialog checkpoints, artifacts, commits, and test evidence. Use dialog read/search for exact evidence; do not infer completion from handoff text alone.",
-    `Read task row: bun packages/cli/index.ts table query --table meta-0e95801d90-NOLOTASKBOARD --row ${JSON.stringify(rowDbKey)} --include-activity --output json`,
-    "Then read linked activity dialog ids with: bun packages/cli/index.ts dialog read <dialogId>",
-    "Report progress, blockers, worktree, branch, commit/diff, tests, and unverified items in the dialog.",
-  ].join("\n");
-}
-
-function buildConnectorCliPrompt(agentConfig: any, userInput: string, bridgeArgs?: {
-  agentKey: string;
-  runtimeContext: any;
-}, permissionPolicy?: ReturnType<typeof resolveMachineRunPermissionPolicy>) {
-  const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
-  return [
-    typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
-    bridgeArgs ? buildTaskEvidencePrompt({
-      agentKey: bridgeArgs.agentKey,
-      agentConfig,
-      runtimeContext: bridgeArgs.runtimeContext,
-    }) : "",
-    buildMachinePermissionPromptBlock(policy),
-    `--- User task ---\n${userInput}`,
-  ].filter(Boolean).join("\n\n");
-}
-
-export async function runMachineConnectCommand(
-  args: string[],
-  deps: MachineCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const authToken = resolveConnectAuthToken(args, env);
-  if (!authToken) {
-    writeAuthMissing(output);
-    return 1;
-  }
-
-  const serverUrl = resolveConnectServerUrl(args, env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
-  const sendHeartbeat = async () => {
-    const res = await fetchImpl(`${serverUrl}/api/machines/heartbeat`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(machine),
-    });
-
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`HTTP ${res.status}\n${text}`);
-    }
-  };
-
-  if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
-    return runMachineDaemonCommand({
-      env,
-      output,
-      cliEntrypointPath: deps.cliEntrypointPath,
-      validateWorkspaceLinks: deps.validateWorkspaceLinks,
-      spawnDaemon: deps.spawnDaemon,
-    });
-  }
-
-  if (hasFlag(args, "--ws")) {
-    const validateWorkspaceLinks = deps.validateWorkspaceLinks ?? (() => []);
-    if (!(await checkConnectorWorkspaceLinks(process.cwd(), output, validateWorkspaceLinks))) {
-      return 1;
-    }
-    const maxAttempts = deps.maxConnectorAttempts ?? Infinity;
-    const sleep = deps.sleep ?? defaultSleep;
-    const reconnectDelayMs = resolveConnectorReconnectDelayMs(env);
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      if (deps.signal?.aborted) {
-        return 0;
-      }
-      const runtimeServerUrl =
-        env.NOLO_CONNECT_RUNTIME_SERVER_URL ||
-        env.NOLO_RUNTIME_SERVER_URL ||
-        serverUrl;
-      const sessionResult = await runMachineWsSession({
-        env,
-        output,
-        signal: deps.signal,
-        machine,
-        sendHeartbeat,
-        runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
-        connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
-        serverUrl,
-        authToken,
-        resolveConnectorWebSocketTarget: (options) =>
-          resolveConnectorWebSocketTarget({
-            ...options,
-            fetchImpl,
-          }),
-        onMessage: (message, send) =>
-          handleConnectorRunMessage(
-            message,
-            send,
-            deps.executeCli ?? defaultExecuteCli,
-            {
-              ...env,
-              NOLO_SERVER: runtimeServerUrl,
-              NOLO_SERVER_URL: runtimeServerUrl,
-              BASE_URL: runtimeServerUrl,
-              AUTH_TOKEN: authToken,
-              NOLO_MACHINE_API_KEY: authToken,
-            },
-            fetchImpl,
-            {
-              buildConnectorCliPrompt,
-            }
-          ),
-      });
-      const exitCode = sessionResult.exitCode;
-      if (exitCode === 2) return 1;
-      if (deps.signal?.aborted) {
-        return 0;
-      }
-      if (attempt >= maxAttempts) return exitCode;
-      const retryDelayMs = sessionResult.retryAfterMs ?? reconnectDelayMs;
-      const reconnectContext =
-        sessionResult.reconnectReason === "core_draining" ? " during core draining" : "";
-      output.write(
-        `[nolo] Connector websocket disconnected${reconnectContext}. Reconnecting in ${retryDelayMs}ms.\n`
-      );
-      await sleepWithAbort(retryDelayMs, sleep, deps.signal);
-    }
-    return 0;
-  }
-
-  if (hasFlag(args, "--watch")) {
-    return runMachineWatchCommand({
-      env,
-      output,
-      machine,
-      sendHeartbeat,
-      runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
-    });
-  }
-
-  return runMachineHeartbeatConnectCommand({
-    output,
-    machine,
-    sendHeartbeat,
-  });
-}
-

package/cli/machineDaemonCommands.ts

@@ -1,185 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync, realpathSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-
-type EnvLike = Record<string, string | undefined>;
-type OutputLike = { write(chunk: string): unknown };
-
-type PackageJson = {
-  name?: string;
-  workspaces?: string[] | { packages?: string[] };
-};
-
-const CONNECTOR_RUNTIME_WORKSPACE_PACKAGES = new Set([
-  "connector-experimental",
-  "ai",
-]);
-
-function readJsonFile<T>(path: string): T | null {
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as T;
-  } catch {
-    return null;
-  }
-}
-
-function getWorkspacePatterns(packageJson: PackageJson) {
-  if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
-  return packageJson.workspaces?.packages ?? [];
-}
-
-function normalizePath(path: string) {
-  const resolved = resolve(path);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-
-function isInsideOrSame(path: string, parent: string) {
-  const relativePath = relative(parent, path);
-  return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
-}
-
-function findWorkspaceRoot(startPath: string) {
-  let current = resolve(startPath);
-  while (true) {
-    const packageJsonPath = join(current, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const packageJson = readJsonFile<PackageJson>(packageJsonPath);
-      if (packageJson && getWorkspacePatterns(packageJson).length > 0) {
-        return current;
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-function validateConnectorWorkspaceLinks(cwd: string) {
-  const repoRoot = findWorkspaceRoot(cwd);
-  if (!repoRoot) return [];
-
-  const rootPackageJson = readJsonFile<PackageJson>(join(repoRoot, "package.json"));
-  if (!rootPackageJson) return [];
-
-  const normalizedRepoRoot = normalizePath(realpathSync(repoRoot));
-  const errors: string[] = [];
-
-  for (const pattern of getWorkspacePatterns(rootPackageJson)) {
-    if (!pattern.endsWith("/*")) continue;
-    const workspaceParent = join(repoRoot, pattern.slice(0, -2));
-    if (!existsSync(workspaceParent)) continue;
-
-    for (const entry of Array.from(new Bun.Glob("*/package.json").scanSync({ cwd: workspaceParent }))) {
-      const packageDir = join(workspaceParent, dirname(entry));
-      const packageJson = readJsonFile<PackageJson>(join(workspaceParent, entry));
-      if (!packageJson?.name || !CONNECTOR_RUNTIME_WORKSPACE_PACKAGES.has(packageJson.name)) {
-        continue;
-      }
-
-      const linkPath = join(repoRoot, "node_modules", ...packageJson.name.split("/"));
-      if (!existsSync(linkPath)) {
-        errors.push(`${linkPath} is missing. Run bun install in ${repoRoot}.`);
-        continue;
-      }
-
-      const actualPath = normalizePath(realpathSync(linkPath));
-      const expectedPath = normalizePath(realpathSync(packageDir));
-      if (!isInsideOrSame(actualPath, normalizedRepoRoot)) {
-        errors.push(
-          `${linkPath} points outside this checkout: ${actualPath}. Run bun install in ${repoRoot}.`,
-        );
-        continue;
-      }
-      if (actualPath !== expectedPath) {
-        errors.push(
-          `${linkPath} points at ${actualPath}, expected ${expectedPath}. Run bun install in ${repoRoot}.`,
-        );
-      }
-    }
-  }
-
-  return errors;
-}
-
-export async function checkConnectorWorkspaceLinks(
-  cwd: string,
-  output: OutputLike,
-  validateWorkspaceLinks: (cwd: string) => string[] | Promise<string[]>,
-) {
-  const errors = await validateWorkspaceLinks(cwd);
-  if (errors.length === 0) return true;
-  output.write(
-    [
-      "[nolo] Connector workspace package links are unsafe.",
-      "The connector would import workspace packages from a different checkout, so machine capabilities and runtime behavior may be stale.",
-      ...errors,
-      "",
-    ].join("\n"),
-  );
-  return false;
-}
-
-function resolveDaemonLogPath(env: EnvLike) {
-  return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
-}
-
-function buildDaemonCommand(cliEntrypointPath: string | undefined) {
-  return [process.execPath, cliEntrypointPath || import.meta.path, "connect", "--ws"];
-}
-
-function defaultSpawnDaemon(args: {
-  cmd: string[];
-  cwd: string;
-  env: EnvLike;
-  logPath: string;
-}) {
-  mkdirSync(dirname(args.logPath), { recursive: true });
-  const out = openSync(args.logPath, "a");
-  const env = Object.fromEntries(
-    Object.entries(args.env).filter((entry): entry is [string, string] => typeof entry[1] === "string")
-  );
-  const proc = spawn(args.cmd[0], args.cmd.slice(1), {
-    cwd: args.cwd,
-    env,
-    detached: true,
-    stdio: ["ignore", out, out],
-  });
-  proc.unref();
-  return { pid: proc.pid };
-}
-
-export type MachineDaemonCommandDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  cliEntrypointPath?: string;
-  validateWorkspaceLinks?: (cwd: string) => string[] | Promise<string[]>;
-  spawnDaemon?: (args: {
-    cmd: string[];
-    cwd: string;
-    env: EnvLike;
-    logPath: string;
-  }) => { pid?: number };
-};
-
-export async function runMachineDaemonCommand(
-  deps: MachineDaemonCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const validateWorkspaceLinks = deps.validateWorkspaceLinks ?? validateConnectorWorkspaceLinks;
-
-  if (!(await checkConnectorWorkspaceLinks(process.cwd(), output, validateWorkspaceLinks))) {
-    return 1;
-  }
-
-  const logPath = resolveDaemonLogPath(env);
-  const result = (deps.spawnDaemon ?? defaultSpawnDaemon)({
-    cmd: buildDaemonCommand(deps.cliEntrypointPath),
-    cwd: process.cwd(),
-    env,
-    logPath,
-  });
-  output.write(`Connector daemon started${result.pid ? ` pid=${result.pid}` : ""}. Log: ${logPath}\n`);
-  return 0;
-}

package/cli/machineHeartbeatCommands.ts

@@ -1,30 +0,0 @@
-import type { MachineHeartbeat } from "../connector-experimental/protocol";
-
-type OutputLike = { write(chunk: string): unknown };
-
-export type MachineHeartbeatConnectDeps = {
-  output?: OutputLike;
-  machine: MachineHeartbeat;
-  sendHeartbeat: () => Promise<void>;
-};
-
-export async function runMachineHeartbeatConnectCommand(
-  deps: MachineHeartbeatConnectDeps
-) {
-  const output = deps.output ?? process.stdout;
-  const machine = deps.machine;
-
-  try {
-    await deps.sendHeartbeat();
-  } catch (error) {
-    output.write(
-      `[nolo] Machine connect failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-
-  output.write(`Connected machine: ${machine.name} (${machine.platform}/${machine.arch})\n`);
-  return 0;
-}

package/cli/machineStatusCommands.ts

@@ -1,95 +0,0 @@
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
-
-type EnvLike = Record<string, string | undefined>;
-type OutputLike = { write(chunk: string): unknown };
-
-export type MachineSummary = {
-  machineId: string;
-  name: string;
-  platform: string;
-  arch: string;
-  connectorVersion: string | null;
-  capabilities: string[];
-  connectorStatus?: "connected" | "disconnected";
-  status: "online" | "offline";
-  lastSeenAt: number;
-};
-
-export type MachineStatusCommandDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  fetchImpl?: typeof fetch;
-};
-
-function resolveServerUrl(env: EnvLike) {
-  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
-}
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
-}
-
-function writeAuthMissing(output: OutputLike) {
-  output.write(
-    "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
-  );
-}
-
-export function formatMachineStatus(machines: MachineSummary[]) {
-  if (machines.length === 0) {
-    return "No connected machines.\nRun `nolo connect` on this computer to register it once.\n";
-  }
-
-  return [
-    "Connected machines:",
-    ...machines.map((machine) => {
-      const caps = machine.capabilities.length ? machine.capabilities.join(", ") : "no capabilities";
-      const connector = machine.connectorStatus ? `  ws:${machine.connectorStatus}` : "";
-      return `- ${machine.name}  ${machine.status}${connector}  ${machine.platform}/${machine.arch}  ${caps}`;
-    }),
-    "",
-  ].join("\n");
-}
-
-export async function runMachineStatusCommand(
-  _args: string[],
-  deps: MachineStatusCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const authToken = resolveAuthToken(env);
-  if (!authToken) {
-    writeAuthMissing(output);
-    return 1;
-  }
-
-  const serverUrl = resolveServerUrl(env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  let res: Response;
-  try {
-    res = await fetchImpl(`${serverUrl}/api/machines`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${authToken}`,
-      },
-    });
-  } catch (error) {
-    output.write(
-      `[nolo] Machine status failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    output.write(`[nolo] Machine status failed: HTTP ${res.status}\n${text}\n`);
-    return 1;
-  }
-
-  const data = await res.json().catch(() => ({ machines: [] }));
-  const machines = Array.isArray(data?.machines) ? data.machines : [];
-  output.write(formatMachineStatus(machines));
-  return 0;
-}

package/cli/machineWatchCommands.ts

@@ -1,41 +0,0 @@
-import type { MachineHeartbeat } from "../connector-experimental/protocol";
-import type { HeartbeatLoopOptions } from "../connector-experimental/heartbeatLoop";
-
-type EnvLike = Record<string, string | undefined>;
-type OutputLike = { write(chunk: string): unknown };
-
-function resolveHeartbeatIntervalMs(env: EnvLike) {
-  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
-  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
-}
-
-export type MachineWatchCommandDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  machine: MachineHeartbeat;
-  sendHeartbeat: () => Promise<void>;
-  runHeartbeatLoop: (options: HeartbeatLoopOptions) => Promise<void>;
-};
-
-export async function runMachineWatchCommand(
-  deps: MachineWatchCommandDeps
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const machine = deps.machine;
-  output.write(`Connecting machine heartbeat loop: ${machine.name} (${machine.platform}/${machine.arch})\n`);
-  try {
-    await deps.runHeartbeatLoop({
-      intervalMs: resolveHeartbeatIntervalMs(env),
-      sendHeartbeat: deps.sendHeartbeat,
-    });
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] Machine heartbeat loop failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}