nolo-cli 0.1.32 → 0.1.34

package/agentMachineCommands.ts

@@ -1,19 +1,13 @@
 import type { MachineHeartbeat } from "./connector-experimental/protocol";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
-import {
-  buildCurrentUserPlatformAgentCandidateKeys,
-  resolveCliAgentKeyInput,
-} from "./agentAliases";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 import {
   type AgentCommandDeps,
-  getReadableCliDb,
   type LocalCliExecutor,
   type SmokeWebSocketOptions,
 } from "./agentCommandSupport";
-import { buildConnectorCliPrompt } from "./machineCommandPrompts";
 import {
   readAgentRecord,
-  resolveAgentRecordFromHybridStore,
   writeAgentRecord,
 } from "./agentRecordHelpers";
 import {
@@ -34,26 +28,15 @@ async function defaultExecuteCli(
 }
 
 async function forwardConnectorRunMessage(
-  _machine: MachineHeartbeat,
+  machine: MachineHeartbeat,
   message: string,
   pushMessage: (response: string) => void,
   executeCli: LocalCliExecutor,
   env: EnvLike,
-  fetchImpl: typeof fetch,
-  dispatchDeps?: AgentCommandDeps["connectorRunDispatchDeps"],
+  fetchImpl: typeof fetch
 ) {
-  const { handleConnectorRunMessage } = await import("./machineWsRunDispatch");
-  return handleConnectorRunMessage(
-    message,
-    pushMessage,
-    executeCli,
-    env,
-    fetchImpl,
-    {
-      buildConnectorCliPrompt,
-      ...(dispatchDeps ?? {}),
-    },
-  );
+  const { handleConnectorRunMessage } = await import("./machineCommands");
+  return handleConnectorRunMessage(machine, message, pushMessage, executeCli, env, fetchImpl);
 }
 
 async function detectLaunchableMachineInfo() {
@@ -86,16 +69,9 @@ function shouldRuntimeDoctorPass(args: {
   runtimeClass: string;
   requiredCapability: string;
   hasCapability: boolean;
-  bindingRequired: boolean;
-  isBoundToCurrent: boolean;
-  isBindingOwnerCompatible: boolean;
 }) {
   if (args.runtimeClass !== "cli-machine") return args.runtimeClass !== "unknown";
-  return Boolean(
-    args.requiredCapability &&
-      args.hasCapability &&
-      (!args.bindingRequired || (args.isBoundToCurrent && args.isBindingOwnerCompatible))
-  );
+  return Boolean(args.requiredCapability && args.hasCapability);
 }
 
 function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
@@ -116,46 +92,6 @@ function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
   }
 }
 
-function runtimeBindingFacts(agent: any, machine: MachineHeartbeat, currentUserId?: string) {
-  const runtimeBinding = agent?.runtimeBinding && typeof agent.runtimeBinding === "object"
-    ? agent.runtimeBinding
-    : {};
-  const boundMachineId = typeof runtimeBinding.machineId === "string"
-    ? runtimeBinding.machineId.trim()
-    : "";
-  const boundOwnerUserId = typeof runtimeBinding.ownerUserId === "string"
-    ? runtimeBinding.ownerUserId.trim()
-    : "";
-  const bindingRequired = agent?.apiSource === "cli";
-  return {
-    bindingRequired,
-    boundMachineId,
-    boundOwnerUserId,
-    isBoundToCurrent: Boolean(boundMachineId) && boundMachineId === machine.machineId,
-    isBindingOwnerCompatible: !boundOwnerUserId || !currentUserId || boundOwnerUserId === currentUserId,
-  };
-}
-
-function assertSmokeBindingState(args: {
-  agent: any;
-  machine: MachineHeartbeat;
-  currentUserId: string;
-  allowRebind: boolean;
-}) {
-  const facts = runtimeBindingFacts(args.agent, args.machine, args.currentUserId);
-  if (args.allowRebind || !facts.bindingRequired) return;
-  if (facts.boundMachineId && !facts.isBoundToCurrent) {
-    throw new Error(
-      `Agent ${args.agent?.name ?? args.agent?.dbKey ?? "unknown"} is bound to ${facts.boundMachineId}, not current machine ${args.machine.machineId}. Run \`nolo agent bind-current ${args.agent?.dbKey ?? "AGENT_KEY"}\` first or pass --bind to rebind explicitly.`
-    );
-  }
-  if (facts.boundOwnerUserId && !facts.isBindingOwnerCompatible) {
-    throw new Error(
-      `Agent ${args.agent?.name ?? args.agent?.dbKey ?? "unknown"} is bound for owner ${facts.boundOwnerUserId}, not current user ${args.currentUserId}. \`nolo agent smoke-current\` only validates a connector launched under your current auth token, so it cannot simulate another owner's binding. If you intend to use the existing shared binding, run \`nolo agent run ${args.agent?.dbKey ?? "AGENT_KEY"}\` and make sure owner ${facts.boundOwnerUserId} has a live connector online. If you intend to take ownership of the binding on this account, run \`nolo agent bind-current ${args.agent?.dbKey ?? "AGENT_KEY"}\` first or pass --bind explicitly.`
-    );
-  }
-}
-
 const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
 
 function buildConnectorKeepaliveMessage() {
@@ -230,75 +166,19 @@ async function heartbeatCurrentMachine(args: {
   }
 }
 
-async function resolveMachineAgent(args: {
-  agentInput: string;
-  cliArgs: string[];
-  deps: AgentCommandDeps;
-  env: EnvLike;
-  fetchImpl: typeof fetch;
-  fallbackFetchImpl?: typeof fetch;
-  output: typeof process.stdout | { write: (chunk: string) => void };
-  userId: string;
-}) {
-  const fallbackKey = resolveCliAgentKeyInput(args.agentInput);
-  const candidateKeys = buildCurrentUserPlatformAgentCandidateKeys(args.agentInput, args.userId);
-  if (candidateKeys.length === 0 || candidateKeys[0] === fallbackKey) {
-    return { agentKey: fallbackKey };
-  }
-
-  try {
-    const db = args.deps.db ?? await getReadableCliDb(args.output as any);
-    const resolved = await resolveAgentRecordFromHybridStore({
-      agentInput: args.agentInput,
-      cliArgs: args.cliArgs,
-      env: args.env,
-      db,
-      fetchImpl: args.fetchImpl,
-      fallbackFetchImpl: args.fallbackFetchImpl,
-    });
-    return resolved
-      ? {
-          agentKey: resolved.agentKey,
-          record: resolved.record,
-          source: resolved.source,
-        }
-      : { agentKey: fallbackKey };
-  } catch {
-    return { agentKey: fallbackKey };
-  }
-}
-
-async function readResolvedAgentRecord(args: {
-  authToken: string;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  resolvedAgent: Awaited<ReturnType<typeof resolveMachineAgent>>;
-  serverUrl: string;
-}) {
-  return args.resolvedAgent.source === "remote-cache"
-    ? args.resolvedAgent.record
-    : await readAgentRecord({
-        agentKey: args.resolvedAgent.agentKey,
-        authToken: args.authToken,
-        fallbackFetchImpl: args.fallbackFetchImpl,
-        fetchImpl: args.fetchImpl,
-        serverUrl: args.serverUrl,
-      });
-}
-
 export async function runAgentBindCurrentCommand(
   args: string[],
   deps: AgentCommandDeps = {}
 ) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
+  const agentKey = args[0]?.trim();
+  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
     output.write("Usage: nolo agent bind-current <agentKey>\n");
-    return agentInput ? 0 : 1;
+    return agentKey ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent bind-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -310,28 +190,14 @@ export async function runAgentBindCurrentCommand(
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(args, env);
+  const serverUrl = resolveServerUrl(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
 
   try {
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing =
-      resolvedAgent.source === "remote-cache"
-        ? resolvedAgent.record
-        : await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     const updated = {
       ...existing,
       runtimeBinding: {
@@ -372,13 +238,13 @@ export async function runAgentSmokeCurrentCommand(
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
   const agentInput = args[0]?.trim();
-  const allowRebind = args.includes("--bind");
   if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent smoke-current <agent> [--msg \"hello\"] [--bind]\n");
+    output.write("Usage: nolo agent smoke-current <agent> --msg \"hello\"\n");
     return agentInput ? 0 : 1;
   }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent smoke-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -390,60 +256,35 @@ export async function runAgentSmokeCurrentCommand(
   }
 
   const userInput = readOption(args, "--msg") ?? "Smoke test from nolo connector.";
-  const serverUrl = resolveServerUrl(args, env);
+  const serverUrl = resolveServerUrl(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
   const sentMessages: string[] = [];
 
   try {
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing = await readResolvedAgentRecord({
+    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    assertSmokeCompatible(existing, machine);
+    await writeAgentRecord({
+      agentKey,
       authToken,
       fallbackFetchImpl,
       fetchImpl,
-      resolvedAgent,
       serverUrl,
-    });
-    assertSmokeCompatible(existing, machine);
-    assertSmokeBindingState({
-      agent: existing,
-      machine,
-      currentUserId: userId,
-      allowRebind,
-    });
-    if (allowRebind) {
-      await writeAgentRecord({
-        agentKey,
-        authToken,
-        fallbackFetchImpl,
-        fetchImpl,
-        serverUrl,
-        userId,
-        record: {
-          ...existing,
-          runtimeBinding: {
-            ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
-              ? existing.runtimeBinding
-              : {}),
-            machineId: machine.machineId,
-            ownerUserId: userId,
-          },
-          updatedAt: Date.now(),
+      userId,
+      record: {
+        ...existing,
+        runtimeBinding: {
+          ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
+            ? existing.runtimeBinding
+            : {}),
+          machineId: machine.machineId,
+          ownerUserId: userId,
         },
-      });
-    }
+        updatedAt: Date.now(),
+      },
+    });
 
     let runResponse: any = null;
     const wsTarget = await resolveConnectorWebSocketTarget({
@@ -470,8 +311,7 @@ export async function runAgentSmokeCurrentCommand(
             AUTH_TOKEN: authToken,
             NOLO_MACHINE_API_KEY: authToken,
           },
-          fetchImpl,
-          deps.connectorRunDispatchDeps,
+          fetchImpl
         ),
         onOpen: async () => {
           const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
@@ -506,106 +346,6 @@ export async function runAgentSmokeCurrentCommand(
   }
 }
 
-export async function runAgentSmokeBoundCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent smoke-bound <agent> [--msg \"hello\"]\n");
-    return agentInput ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  if (!authToken) {
-    output.write("[nolo] agent smoke-bound requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-    return 1;
-  }
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    output.write("[nolo] agent smoke-bound could not read userId from AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const userInput = readOption(args, "--msg") ?? "Smoke test existing bound runtime from nolo.";
-  const serverUrl = resolveServerUrl(args, env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
-
-  try {
-    const existing = await readResolvedAgentRecord({
-      authToken,
-      fallbackFetchImpl,
-      fetchImpl,
-      resolvedAgent,
-      serverUrl,
-    });
-    const facts = runtimeBindingFacts(existing, { machineId: "", name: "", platform: "", arch: "", capabilities: [] }, userId);
-    if (!facts.boundMachineId) {
-      throw new Error(
-        `Agent ${existing?.name ?? existing?.dbKey ?? agentKey} is not currently bound to a machine. Run \`nolo agent bind-current ${agentKey}\` first.`
-      );
-    }
-    if (!facts.boundOwnerUserId) {
-      throw new Error(
-        `Agent ${existing?.name ?? existing?.dbKey ?? agentKey} is missing runtimeBinding.ownerUserId for machine ${facts.boundMachineId}.`
-      );
-    }
-
-    const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${authToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        agentKey,
-        userInput,
-        stream: false,
-      }),
-    });
-    const body = await res.json().catch(() => ({}));
-    if (!res.ok) {
-      const errorMessage = typeof body?.error === "string" ? body.error : `HTTP ${res.status}`;
-      const detailMessage = typeof body?.message === "string" ? body.message : "";
-      const reason = typeof body?.reason === "string" ? body.reason : "";
-      throw new Error(
-        [
-          `agent run failed: ${errorMessage}`,
-          detailMessage,
-          reason ? `reason=${reason}` : "",
-        ].filter(Boolean).join("\n")
-      );
-    }
-
-    output.write(
-      `Bound run OK: ${body?.dialogId ?? "no-dialog"}\nAgent key: ${agentKey}\nBound owner: ${facts.boundOwnerUserId}\nBound machine: ${facts.boundMachineId}\n`
-    );
-    if (body?.content) output.write(`${body.content}\n`);
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] agent smoke-bound failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}
-
 export async function runAgentRuntimeDoctorCommand(
   args: string[],
   deps: AgentCommandDeps = {}
@@ -617,45 +357,27 @@ export async function runAgentRuntimeDoctorCommand(
     output.write("Usage: nolo agent runtime-doctor <agentKey>\n");
     return agentInput ? 0 : 1;
   }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent runtime-doctor requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
   }
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    output.write("[nolo] agent runtime-doctor could not read userId from AUTH_TOKEN.\n");
-    return 1;
-  }
 
-  const serverUrl = resolveServerUrl(args, env);
+  const serverUrl = resolveServerUrl(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
 
   try {
-    const agent =
-      resolvedAgent.source === "remote-cache"
-        ? resolvedAgent.record
-        : await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const agent = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     const requiredCapability = requiredCapabilityForAgent(agent);
     const runtimeClass = classifyAgentRuntime(agent);
+    const isBoundToCurrent = agent?.runtimeBinding?.machineId === machine.machineId;
     const hasCapability = requiredCapability
       ? machine.capabilities.includes(requiredCapability)
       : false;
-    const bindingFacts = runtimeBindingFacts(agent, machine, userId);
     output.write(`Agent runtime doctor: ${agent?.name ?? agentKey}\n`);
     if (agentInput !== agentKey) output.write(`Agent input: ${agentInput}\n`);
     output.write(`Agent key: ${agentKey}\n`);
@@ -665,28 +387,10 @@ export async function runAgentRuntimeDoctorCommand(
     output.write(`Required capability: ${requiredCapability || "none"}\n`);
     output.write(`Current machine: ${machine.name} (${machine.machineId})\n`);
     output.write(`Current machine capabilities: ${machine.capabilities.length ? machine.capabilities.join(", ") : "none"}\n`);
-    output.write(`Recorded bound machine: ${bindingFacts.boundMachineId || "none"}\n`);
-    output.write(`Recorded binding owner: ${bindingFacts.boundOwnerUserId || "unknown"}\n`);
-    output.write(`Current machine binding: ${runtimeClass === "cli-machine" ? (bindingFacts.isBoundToCurrent ? "yes" : "no") : "not required"}\n`);
-    output.write(
-      `Binding owner matches current user: ${
-        runtimeClass === "cli-machine"
-          ? (bindingFacts.boundOwnerUserId
-            ? (bindingFacts.isBindingOwnerCompatible ? "yes" : "no")
-            : "unknown")
-          : "not required"
-      }\n`
-    );
+    output.write(`Current machine binding: ${runtimeClass === "cli-machine" ? (isBoundToCurrent ? "yes" : "no") : "not required"}\n`);
     output.write(`Current machine has required capability: ${requiredCapability ? (hasCapability ? "yes" : "no") : "not required"}\n`);
 
-    return shouldRuntimeDoctorPass({
-      runtimeClass,
-      requiredCapability,
-      hasCapability,
-      bindingRequired: bindingFacts.bindingRequired,
-      isBoundToCurrent: bindingFacts.isBoundToCurrent,
-      isBindingOwnerCompatible: bindingFacts.isBindingOwnerCompatible,
-    }) ? 0 : 1;
+    return shouldRuntimeDoctorPass({ runtimeClass, requiredCapability, hasCapability }) ? 0 : 1;
   } catch (error) {
     output.write(
       `[nolo] agent runtime-doctor failed: ${

package/agentPullCommand.ts

@@ -1,20 +1,14 @@
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
-import type { OutputLike } from "./cliIoTypes";
-import {
-  buildCurrentUserPlatformAgentCandidateKeys,
-  resolveCliAgentKeyInput,
-} from "./agentAliases";
-import { resolveAgentRecordFromHybridStore } from "./agentRecordHelpers";
-import {
-  parseUserIdFromAuthToken,
-  readCliOptionValue,
-  resolveAuthToken,
-  resolveServerUrl,
-} from "./cliEnvHelpers";
+import { resolveCliAgentKeyInput } from "./agentAliases";
+import { resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
 
 type EnvLike = Record<string, string | undefined>;
 
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
 type AgentPullCommandDeps = {
   env?: EnvLike;
   output?: OutputLike;
@@ -27,7 +21,8 @@ export type ParsedAgentPullArgs = {
 };
 
 function readFlagValue(args: string[], flag: string) {
-  return readCliOptionValue(args, flag) || undefined;
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
 }
 
 function positionalArgs(args: string[]) {
@@ -111,57 +106,37 @@ export async function runAgentPullCommand(args: string[], deps: AgentPullCommand
   }
 
   const serverUrl = resolveServerUrl(args, env);
-  const authToken = resolveAuthToken(args, env);
-  const currentUserId = parseUserIdFromAuthToken(authToken);
+  const authToken =
+    readFlagValue(args, "--token") ||
+    readFlagValue(args, "--machine-key") ||
+    resolveAuthToken(env, ["BENCHMARK_AUTH_TOKEN"]);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const db = deps.db ?? await getDefaultCliLocalRuntimeDb();
-  const agentInput = readFlagValue(args, "--agent") ?? positionalArgs(args)[0] ?? parsed.agentKey;
-  let agentKey = parsed.agentKey;
-  let resolvedRecord: any;
-
-  const candidateKeys = buildCurrentUserPlatformAgentCandidateKeys(agentInput, currentUserId);
-  if (candidateKeys.length > 0 && candidateKeys[0] !== parsed.agentKey) {
-    const resolved = await resolveAgentRecordFromHybridStore({
-      agentInput,
-      cliArgs: args,
-      env,
-      db,
+
+  let record: any;
+  try {
+    record = await readRemoteAgent({
+      agentKey: parsed.agentKey,
+      serverUrl,
+      authToken,
       fetchImpl,
     });
-    if (resolved?.agentKey) {
-      agentKey = resolved.agentKey;
-      if (resolved.source === "remote-cache") {
-        resolvedRecord = resolved.record;
-      }
-    }
-  }
-
-  let record: any = resolvedRecord;
-  if (!record) {
-    try {
-      record = await readRemoteAgent({
-        agentKey,
-        serverUrl,
-        authToken,
-        fetchImpl,
-      });
-    } catch (error) {
-      output.write(
-        `[nolo] Failed to pull ${agentKey} from ${serverUrl}: ${
-          error instanceof Error ? error.message : String(error)
-        }\n`
-      );
-      return 1;
-    }
+  } catch (error) {
+    output.write(
+      `[nolo] Failed to pull ${parsed.agentKey} from ${serverUrl}: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
   }
 
   if (!record || typeof record !== "object") {
-    output.write(`[nolo] Server returned an empty agent record for ${agentKey}.\n`);
+    output.write(`[nolo] Server returned an empty agent record for ${parsed.agentKey}.\n`);
     return 1;
   }
 
-  const localRecord = normalizeAgentRecord(agentKey, record);
-  await db.put(agentKey, localRecord);
-  output.write(`[nolo] cached ${agentKey} in local LevelDB\n`);
+  const localRecord = normalizeAgentRecord(parsed.agentKey, record);
+  await db.put(parsed.agentKey, localRecord);
+  output.write(`[nolo] cached ${parsed.agentKey} in local LevelDB\n`);
   return 0;
 }