nolo-cli 0.1.26 → 0.1.30

package/agentMachineCommands.ts

@@ -69,9 +69,16 @@ 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);
+  return Boolean(
+    args.requiredCapability &&
+      args.hasCapability &&
+      (!args.bindingRequired || (args.isBoundToCurrent && args.isBindingOwnerCompatible))
+  );
 }
 
 function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
@@ -92,6 +99,46 @@ 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}. Run \`nolo agent bind-current ${args.agent?.dbKey ?? "AGENT_KEY"}\` first or pass --bind to rebind explicitly.`
+    );
+  }
+}
+
 const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
 
 function buildConnectorKeepaliveMessage() {
@@ -178,7 +225,7 @@ export async function runAgentBindCurrentCommand(
     return agentKey ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent bind-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -190,7 +237,7 @@ export async function runAgentBindCurrentCommand(
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(env);
+  const serverUrl = resolveServerUrl(args, env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
@@ -238,13 +285,14 @@ 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\"\n");
+    output.write("Usage: nolo agent smoke-current <agent> [--msg \"hello\"] [--bind]\n");
     return agentInput ? 0 : 1;
   }
   const agentKey = resolveCliAgentKeyInput(agentInput);
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent smoke-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -256,7 +304,7 @@ export async function runAgentSmokeCurrentCommand(
   }
 
   const userInput = readOption(args, "--msg") ?? "Smoke test from nolo connector.";
-  const serverUrl = resolveServerUrl(env);
+  const serverUrl = resolveServerUrl(args, env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
@@ -266,25 +314,33 @@ export async function runAgentSmokeCurrentCommand(
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
     const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     assertSmokeCompatible(existing, machine);
-    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(),
-      },
+    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(),
+        },
+      });
+    }
 
     let runResponse: any = null;
     const wsTarget = await resolveConnectorWebSocketTarget({
@@ -359,13 +415,13 @@ export async function runAgentRuntimeDoctorCommand(
   }
   const agentKey = resolveCliAgentKeyInput(agentInput);
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent runtime-doctor requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(env);
+  const serverUrl = resolveServerUrl(args, env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
@@ -374,10 +430,10 @@ export async function runAgentRuntimeDoctorCommand(
     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, parseUserIdFromAuthToken(authToken));
     output.write(`Agent runtime doctor: ${agent?.name ?? agentKey}\n`);
     if (agentInput !== agentKey) output.write(`Agent input: ${agentInput}\n`);
     output.write(`Agent key: ${agentKey}\n`);
@@ -387,10 +443,28 @@ 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(`Current machine binding: ${runtimeClass === "cli-machine" ? (isBoundToCurrent ? "yes" : "no") : "not required"}\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 has required capability: ${requiredCapability ? (hasCapability ? "yes" : "no") : "not required"}\n`);
 
-    return shouldRuntimeDoctorPass({ runtimeClass, requiredCapability, hasCapability }) ? 0 : 1;
+    return shouldRuntimeDoctorPass({
+      runtimeClass,
+      requiredCapability,
+      hasCapability,
+      bindingRequired: bindingFacts.bindingRequired,
+      isBoundToCurrent: bindingFacts.isBoundToCurrent,
+      isBindingOwnerCompatible: bindingFacts.isBindingOwnerCompatible,
+    }) ? 0 : 1;
   } catch (error) {
     output.write(
       `[nolo] agent runtime-doctor failed: ${

package/agentPullCommand.ts

@@ -1,14 +1,15 @@
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
+import type { OutputLike } from "./cliIoTypes";
 import { resolveCliAgentKeyInput } from "./agentAliases";
+import {
+  readCliOptionValue,
+  resolveAuthToken,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
 
 type EnvLike = Record<string, string | undefined>;
 
-type OutputLike = {
-  write(chunk: string): unknown;
-};
-
 type AgentPullCommandDeps = {
   env?: EnvLike;
   output?: OutputLike;
@@ -21,8 +22,7 @@ export type ParsedAgentPullArgs = {
 };
 
 function readFlagValue(args: string[], flag: string) {
-  const index = args.indexOf(flag);
-  return index >= 0 ? args[index + 1] : undefined;
+  return readCliOptionValue(args, flag) || undefined;
 }
 
 function positionalArgs(args: string[]) {
@@ -44,14 +44,6 @@ export function parseAgentPullArgs(args: string[]): ParsedAgentPullArgs | null {
   return { agentKey: resolveCliAgentKeyInput(agentKey) };
 }
 
-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 || env.BENCHMARK_AUTH_TOKEN || "";
-}
-
 function extractToolNames(record: any) {
   if (Array.isArray(record?.toolNames)) return record.toolNames.filter((tool: unknown) => typeof tool === "string");
   if (!Array.isArray(record?.tools)) return [];
@@ -113,8 +105,8 @@ export async function runAgentPullCommand(args: string[], deps: AgentPullCommand
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(env);
-  const authToken = resolveAuthToken(env);
+  const serverUrl = resolveServerUrl(args, env);
+  const authToken = resolveAuthToken(args, env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const db = deps.db ?? await getDefaultCliLocalRuntimeDb();
 

package/agentRecordCommands.ts

@@ -21,7 +21,7 @@ export async function runAgentReadCommand(
     return agentInput ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -35,6 +35,7 @@ export async function runAgentReadCommand(
   try {
     const result = await resolveAgentRecordFromHybridStore({
       agentInput,
+      cliArgs: args,
       env,
       db,
       fetchImpl,
@@ -79,7 +80,7 @@ export async function runAgentUpdateCommand(
     return args[0] ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent update requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -97,6 +98,7 @@ export async function runAgentUpdateCommand(
 
   try {
     const built = await buildUpdatedAgentRecord({
+      cliArgs: args,
       parsed,
       env,
       db,

package/agentRecordHelpers.ts

@@ -148,10 +148,13 @@ export async function queryUserRecords(args: {
   fetchImpl: typeof fetch;
   serverUrl: string;
   userId: string;
-  type: "agent" | "cybot";
+  type: "agent" | "cybot" | "dialog";
+  limit?: number;
 }) {
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}`,
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${
+      typeof args.limit === "number" && Number.isFinite(args.limit) ? `?limit=${args.limit}` : ""
+    }`,
     {
       method: "POST",
       headers: {
@@ -181,6 +184,26 @@ export async function writeAgentRecord(args: {
   serverUrl: string;
   userId: string;
   record: Record<string, any>;
+}) {
+  return writeDbRecord({
+    authToken: args.authToken,
+    dbKey: args.agentKey,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    record: args.record,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+  });
+}
+
+export async function writeDbRecord(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+  record: Record<string, any>;
 }) {
   const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
     method: "POST",
@@ -189,11 +212,11 @@ export async function writeAgentRecord(args: {
       "Content-Type": "application/json",
     },
     body: JSON.stringify({
-      customKey: args.agentKey,
+      customKey: args.dbKey,
       userId: args.userId,
       data: {
         ...args.record,
-        dbKey: args.agentKey,
+        dbKey: args.dbKey,
       },
     }),
   }, args);
@@ -203,16 +226,51 @@ export async function writeAgentRecord(args: {
   }
 }
 
+export async function deleteDbRecord(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+}) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}?userId=${encodeURIComponent(args.userId)}`,
+    {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+      },
+    },
+    args
+  );
+  const text = await res.text();
+  let data: any = {};
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = {};
+    }
+  }
+  if (res.status === 404) return "missing" as const;
+  if (!res.ok && res.status !== 204) {
+    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return "deleted" as const;
+}
+
 export async function resolveAgentRecordFromHybridStore(args: {
   agentInput: string;
+  cliArgs?: string[];
   env: EnvLike;
   db: CliKvDb;
   fetchImpl: typeof fetch;
   fallbackFetchImpl?: typeof fetch;
 }) {
   const agentKey = resolveCliAgentKeyInput(args.agentInput);
-  const authToken = resolveAuthToken(args.env);
-  const defaultServerUrl = resolveServerUrl(args.env);
+  const authToken = resolveAuthToken(args.cliArgs ?? [], args.env);
+  const defaultServerUrl = resolveServerUrl(args.cliArgs ?? [], args.env);
 
   for (const key of buildLocalAgentLookupKeys({
     agentRef: agentKey,
@@ -232,7 +290,7 @@ export async function resolveAgentRecordFromHybridStore(args: {
     }
 
     if (!shouldReadAgentKeyRemotely(key)) continue;
-    for (const serverUrl of resolveServerCandidates(args.env, defaultServerUrl)) {
+    for (const serverUrl of resolveServerCandidates(args.cliArgs ?? [], args.env, defaultServerUrl)) {
       try {
         const remoteRecord = await readAgentRecord({
           agentKey: key,
@@ -323,6 +381,7 @@ export function parseAgentUpdateArgs(args: string[]) {
 }
 
 export async function buildUpdatedAgentRecord(args: {
+  cliArgs?: string[];
   parsed: NonNullable<ReturnType<typeof parseAgentUpdateArgs>>;
   env: EnvLike;
   db: CliKvDb;
@@ -332,13 +391,14 @@ export async function buildUpdatedAgentRecord(args: {
 }) {
   const cached = await resolveAgentRecordFromHybridStore({
     agentInput: args.parsed.agentInput,
+    cliArgs: args.cliArgs,
     env: args.env,
     db: args.db,
     fetchImpl: args.fetchImpl,
     fallbackFetchImpl: args.fallbackFetchImpl,
   });
   const agentKey = cached?.agentKey ?? resolveCliAgentKeyInput(args.parsed.agentInput);
-  const serverUrl = cached?.record?.serverOrigin ?? resolveServerUrl(args.env);
+  const serverUrl = cached?.record?.serverOrigin ?? resolveServerUrl(args.cliArgs ?? [], args.env);
   const currentRecord = await readAgentRecord({
     agentKey,
     authToken: args.authToken,
@@ -350,6 +410,7 @@ export async function buildUpdatedAgentRecord(args: {
   if (args.parsed.copyProviderFrom) {
     const providerSource = await resolveAgentRecordFromHybridStore({
       agentInput: args.parsed.copyProviderFrom,
+      cliArgs: args.cliArgs,
       env: args.env,
       db: args.db,
       fetchImpl: args.fetchImpl,