nolo-cli 0.1.33 → 0.1.35

package/cli/client/localRuntimeAdapter.ts

@@ -16,6 +16,7 @@ import {
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
   resolvePlatformChatProviderConfig,
+  resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../../agent-runtime";
@@ -169,6 +170,12 @@ async function defaultLoopbackRequest(input: FetchInput, init?: FetchInit) {
       });
     });
     req.on("error", reject);
+    init?.signal?.addEventListener("abort", () => {
+      req.destroy(
+        init.signal?.reason instanceof Error ? init.signal.reason : new Error("request aborted")
+      );
+      reject(init.signal?.reason ?? new Error("request aborted"));
+    }, { once: true });
     if (body) req.write(body);
     req.end();
   });
@@ -191,6 +198,7 @@ async function fetchWithTransientRetry(
       }
       return await fetchImpl(input, init);
     } catch (error) {
+      if (init?.signal?.aborted) throw error;
       if (!isTransientFetchError(error)) throw error;
       lastError = error;
       if (attempt < TRANSIENT_FETCH_MAX_ATTEMPTS) {
@@ -201,6 +209,18 @@ async function fetchWithTransientRetry(
   throw lastError;
 }
 
+function buildRequestTimeoutSignal(timeoutMs?: number) {
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return undefined;
+  }
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+    return AbortSignal.timeout(timeoutMs);
+  }
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
+  return controller.signal;
+}
+
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -428,8 +448,11 @@ export function createCliLocalRuntimeAdapter(
         store: await resolveStore(deps),
         userId,
       });
+      const requestedToolNames = agentConfig
+        ? resolveRequestedRuntimeToolNames({ agentConfig })
+        : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
-        toolNames: agentConfig?.toolNames,
+        toolNames: requestedToolNames,
         env: deps.env,
       });
       await activateAgentWorkspaceSession({ agentRef, agentConfig });
@@ -455,9 +478,12 @@ export function createCliLocalRuntimeAdapter(
         });
         return {
           model: providerConfig.model,
-          complete: async (messages) => {
+          complete: async (messages, options) => {
+            const requestedToolNames = resolveRequestedRuntimeToolNames({
+              agentConfig,
+            });
             const tools = buildOpenAiTools({
-              toolNames: agentConfig.toolNames,
+              toolNames: requestedToolNames,
               env: deps.env,
             });
             const request = buildPlatformChatCompletionRequest({
@@ -465,7 +491,11 @@ export function createCliLocalRuntimeAdapter(
               messages,
               tools,
             });
-            const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+            const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            const res = await fetchWithTransientRetry(fetchImpl, request.url, {
+              ...request.init,
+              ...(signal ? { signal } : {}),
+            }, {
               sleep: deps.sleep,
               loopbackRequest,
             });
@@ -488,9 +518,12 @@ export function createCliLocalRuntimeAdapter(
       });
       return {
         model: providerConfig.model,
-        complete: async (messages) => {
+        complete: async (messages, options) => {
+          const requestedToolNames = resolveRequestedRuntimeToolNames({
+            agentConfig,
+          });
           const tools = buildOpenAiTools({
-            toolNames: agentConfig.toolNames,
+            toolNames: requestedToolNames,
             env: deps.env,
           });
           const request = buildOpenAiCompatibleChatCompletionRequest({
@@ -498,7 +531,11 @@ export function createCliLocalRuntimeAdapter(
             messages,
             tools,
           });
-          const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+          const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          const res = await fetchWithTransientRetry(fetchImpl, request.url, {
+            ...request.init,
+            ...(signal ? { signal } : {}),
+          }, {
             sleep: deps.sleep,
             loopbackRequest,
           });

package/cli/commandRegistry.ts

@@ -49,8 +49,8 @@ export function renderHelpText() {
     "  nolo connect",
     "  nolo connect --watch",
     "  nolo connect --ws",
-    "  nolo connect --ws --server-url https://api.nolo.chat --api-key sk_machine_xxx",
-    "  nolo connect --daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx",
+    "  nolo connect --ws --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
+    "  nolo connect --daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
     "  nolo machine status",
     "  nolo doctor",
     "  nolo doctor runtime",

package/cli/connectorWebSocketTarget.ts

@@ -49,14 +49,21 @@ function parseRetryAfterMs(response: Response, bodyRetryAfterMs?: unknown) {
 export async function resolveConnectorWebSocketTarget(input: {
   serverUrl: string;
   machineId: string;
+  connectorSurface?: string;
   headers: Record<string, string>;
   fetchImpl?: typeof fetch;
 }) {
   const directWsUrl = new URL(input.serverUrl);
   directWsUrl.protocol = directWsUrl.protocol === "https:" ? "wss:" : "ws:";
-  directWsUrl.pathname = "/api/connector/ws";
-  directWsUrl.search = "";
-  directWsUrl.searchParams.set("machineId", input.machineId);
+  directWsUrl.pathname = "/api/connector/ws";
+  directWsUrl.search = "";
+  directWsUrl.searchParams.set("machineId", input.machineId);
+  if (input.connectorSurface?.trim()) {
+    directWsUrl.searchParams.set(
+      "connectorSurface",
+      input.connectorSurface.trim().toLowerCase()
+    );
+  }
 
   const probeUrl = new URL(input.serverUrl);
   probeUrl.pathname = "/api/connector/ws";

package/cli/dialogCommands.ts

@@ -0,0 +1,446 @@
+import type { AgentCommandDeps } from "./agentCommandSupport";
+import { buildSpaceLookup, getSpaceContentKeys } from "./cliSpaceHelpers";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import {
+  deleteDbRecordOnServers,
+  listUserRecordsFromServers,
+  readDbRecordFromServers,
+  readLiveDbRecordAfterTombstoneMerge,
+} from "./globalRecordOperations";
+
+type ListedDialog = {
+  id: string;
+  dbKey: string;
+  title: string;
+  status: string | null;
+  updatedAt: string | number | null;
+  createdAt: string | number | null;
+  spaceId: string | null;
+  triggerType: string | null;
+  primaryAgentKey: string | null;
+  cybots: string[];
+};
+
+const DIALOG_ID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+const DIALOG_PATH_RE = /^\/(?:space\/([^/]+)\/)?dialog-(.+)-([0-9A-HJKMNP-TV-Z]{26})\/?$/i;
+const VALUE_FLAGS = new Set([
+  "--limit",
+  "--server",
+  "--server-url",
+  "--space",
+  "--space-id",
+  "--token",
+]);
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function readFirstPositional(args: string[]) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (VALUE_FLAGS.has(value)) {
+      index += 1;
+      continue;
+    }
+    if (!value.startsWith("-")) return value;
+  }
+  return undefined;
+}
+
+function readLimit(args: string[], fallback: number) {
+  const raw = readOption(args, "--limit");
+  const parsed = raw ? Number(raw) : fallback;
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function getDialogIdFromKey(dbKey: string) {
+  const index = dbKey.lastIndexOf("-");
+  return index >= 0 ? dbKey.slice(index + 1) : dbKey;
+}
+
+function resolveDialogInput(rawInput: string, userId: string) {
+  const raw = rawInput.trim();
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(DIALOG_PATH_RE);
+    if (!match) {
+      throw new Error(`Unsupported dialog URL path: ${url.pathname}`);
+    }
+    const [, spaceId, ownerId, dialogId] = match;
+    return {
+      dbKey: `dialog-${ownerId}-${dialogId}`,
+      dialogId,
+      ownerId,
+      spaceId: spaceId ? decodeURIComponent(spaceId) : null,
+    };
+  }
+
+  if (raw.startsWith("dialog-")) {
+    const dialogId = getDialogIdFromKey(raw);
+    return {
+      dbKey: raw,
+      dialogId,
+      ownerId: raw.slice("dialog-".length, Math.max("dialog-".length, raw.length - dialogId.length - 1)),
+      spaceId: null,
+    };
+  }
+
+  if (!DIALOG_ID_RE.test(raw)) {
+    throw new Error(`Unsupported dialog id: ${raw}`);
+  }
+
+  return {
+    dbKey: `dialog-${userId}-${raw}`,
+    dialogId: raw,
+    ownerId: userId,
+    spaceId: null,
+  };
+}
+
+function normalizeDialogRecord(record: any, fallbackDbKey?: string): ListedDialog | null {
+  const dbKey =
+    typeof record?.dbKey === "string" && record.dbKey.trim()
+      ? record.dbKey.trim()
+      : fallbackDbKey ?? "";
+  const id =
+    typeof record?.id === "string" && record.id.trim()
+      ? record.id.trim()
+      : dbKey
+        ? getDialogIdFromKey(dbKey)
+        : "";
+  if (!dbKey || !id) return null;
+
+  return {
+    id,
+    dbKey,
+    title:
+      typeof record?.title === "string" && record.title.trim()
+        ? record.title.trim()
+        : typeof record?.taskLabel === "string" && record.taskLabel.trim()
+          ? record.taskLabel.trim()
+          : "(untitled)",
+    status: typeof record?.status === "string" ? record.status : null,
+    updatedAt:
+      typeof record?.updatedAt === "string" || typeof record?.updatedAt === "number"
+        ? record.updatedAt
+        : typeof record?.updated_at === "string" || typeof record?.updated_at === "number"
+          ? record.updated_at
+          : null,
+    createdAt:
+      typeof record?.createdAt === "string" || typeof record?.createdAt === "number"
+        ? record.createdAt
+        : typeof record?.created === "string" || typeof record?.created === "number"
+          ? record.created
+          : null,
+    spaceId: typeof record?.spaceId === "string" && record.spaceId.trim() ? record.spaceId : null,
+    triggerType: typeof record?.triggerType === "string" ? record.triggerType : null,
+    primaryAgentKey:
+      typeof record?.primaryAgentKey === "string" && record.primaryAgentKey.trim()
+        ? record.primaryAgentKey
+        : null,
+    cybots: Array.isArray(record?.cybots)
+      ? record.cybots.filter((agent: unknown): agent is string => typeof agent === "string")
+      : [],
+  };
+}
+
+function sortDialogs(dialogs: ListedDialog[]) {
+  return dialogs.sort((a, b) => {
+    const ta = a.updatedAt ?? a.createdAt ?? 0;
+    const tb = b.updatedAt ?? b.createdAt ?? 0;
+    const left = typeof ta === "number" ? ta : Date.parse(String(ta)) || 0;
+    const right = typeof tb === "number" ? tb : Date.parse(String(tb)) || 0;
+    return right - left;
+  });
+}
+
+function isScheduledDialog(record: ListedDialog) {
+  return record.triggerType === "scheduled_run";
+}
+
+function printListUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo dialog list [--space <spaceId|spaceUrl>] [--limit 100] [--json] [--ids-only]
+
+Options:
+  --space <space>       List current user's dialogs attached to one space.
+  --limit <n>           Maximum dialogs to return. Default: 100.
+  --include-scheduled   Include scheduled automation run dialogs.
+  --json                Print machine-readable JSON.
+  --ids-only            Print only dialog ids.
+  --server <url>        Override NOLO_SERVER/BASE_URL.
+  --token <jwt>         Override AUTH_TOKEN.
+
+Lists merge global server candidates and ignore newer tombstones.
+`);
+}
+
+function printDeleteUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo dialog delete <dialogId|dialogKey|dialogUrl> [--yes] [--json]
+
+Options:
+  --yes          Actually delete. Without this, the command is a dry-run.
+  --json         Print machine-readable JSON.
+  --server <url> Prefer this server and include it in global deletion.
+  --token <jwt>  Override AUTH_TOKEN.
+
+Deletes are global across the selected/profile server plus known Nolo cluster peers.
+`);
+}
+
+async function readSpaceDialogRecords(args: {
+  authToken: string;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  serverUrls: string[];
+  spaceInput: string;
+  userId: string;
+}) {
+  const { spaceId, spaceKey } = buildSpaceLookup(args.spaceInput);
+  const spaceRead = await readLiveDbRecordAfterTombstoneMerge({
+    authToken: args.authToken,
+    dbKey: spaceKey,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    label: "space record",
+    serverUrls: args.serverUrls,
+  });
+  const contentKeys = [...getSpaceContentKeys(spaceRead.record)]
+    .filter((key) => key.startsWith(`dialog-${args.userId}-`));
+  const contentKeySet = new Set(contentKeys);
+  const dialogResult = await listUserRecordsFromServers({
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    label: "dialog query",
+    serverUrls: args.serverUrls,
+    type: "dialog",
+    userId: args.userId,
+  });
+  const records = dialogResult.records.filter((record) =>
+    typeof record?.dbKey === "string" && contentKeySet.has(record.dbKey)
+  );
+  const failures = [...spaceRead.failures, ...dialogResult.failures];
+  return { spaceId, records, failures };
+}
+
+export async function runDialogListCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printListUsage(output);
+    return 0;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] dialog list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] dialog list could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(args, env);
+  const serverUrls = resolveServerCandidates(args, env, serverUrl);
+  const limit = readLimit(args, 100);
+  const spaceInput = readOption(args, "--space") ?? readOption(args, "--space-id");
+  const includeScheduled = hasFlag(args, "--include-scheduled");
+
+  try {
+    let source: "user-data" | "space" = "user-data";
+    let resolvedSpaceId: string | null = null;
+    let queryFailures: Array<{ serverUrl: string; error: string }> = [];
+    let records: any[];
+    if (spaceInput) {
+      source = "space";
+      const result = await readSpaceDialogRecords({
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls,
+        spaceInput,
+        userId,
+      });
+      resolvedSpaceId = result.spaceId;
+      records = result.records;
+      queryFailures = result.failures;
+    } else {
+      const result = await listUserRecordsFromServers({
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        label: "dialog query",
+        serverUrls,
+        type: "dialog",
+        userId,
+      });
+      records = result.records;
+      queryFailures = result.failures;
+    }
+
+    const dialogs = sortDialogs(
+      records
+        .map((record) => normalizeDialogRecord(record))
+        .filter((dialog): dialog is ListedDialog => dialog != null)
+        .filter((dialog) => includeScheduled || !isScheduledDialog(dialog))
+    ).slice(0, limit);
+
+    if (hasFlag(args, "--ids-only")) {
+      output.write(`${dialogs.map((dialog) => dialog.id).join("\n")}\n`);
+      return 0;
+    }
+
+    if (hasFlag(args, "--json")) {
+      output.write(JSON.stringify({
+        userId,
+        ...(resolvedSpaceId ? { spaceId: resolvedSpaceId } : {}),
+        source,
+        targetServers: serverUrls,
+        ...(queryFailures.length ? { serverFailures: queryFailures } : {}),
+        total: dialogs.length,
+        dialogs,
+      }, null, 2));
+      output.write("\n");
+      return 0;
+    }
+
+    output.write(`userId: ${userId}\n`);
+    if (resolvedSpaceId) output.write(`spaceId: ${resolvedSpaceId}\n`);
+    output.write(`source: ${source}\n`);
+    output.write(`targetServers: ${serverUrls.join(", ")}\n`);
+    if (queryFailures.length) {
+      output.write(`serverFailures: ${queryFailures.length}\n`);
+    }
+    output.write(`total dialogs: ${dialogs.length}\n`);
+    for (const dialog of dialogs) {
+      output.write(
+        `\n${dialog.title}\nid=${dialog.id}\nstatus=${dialog.status ?? "-"}\nupdatedAt=${dialog.updatedAt ?? "-"}\ndbKey=${dialog.dbKey}\n`
+      );
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] dialog list failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runDialogDeleteCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printDeleteUsage(output);
+    return 0;
+  }
+
+  const rawDialog = readFirstPositional(args);
+  if (!rawDialog) {
+    printDeleteUsage(output);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] dialog delete requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] dialog delete could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(args, env);
+  const serverUrls = resolveServerCandidates(args, env, serverUrl);
+  const resolved = resolveDialogInput(rawDialog, userId);
+  const shouldDelete = hasFlag(args, "--yes");
+
+  try {
+    const readResult = await readDbRecordFromServers({
+      authToken,
+      dbKey: resolved.dbKey,
+      fallbackFetchImpl,
+      fetchImpl,
+      label: "dialog record",
+      serverUrls,
+    });
+    const dialog = normalizeDialogRecord(readResult.record, resolved.dbKey);
+    if (!dialog) {
+      throw new Error(`dialog record is unreadable: ${resolved.dbKey}`);
+    }
+
+    let deleteResults: Awaited<ReturnType<typeof deleteDbRecordOnServers>> = [];
+    if (shouldDelete) {
+      deleteResults = await deleteDbRecordOnServers({
+        authToken,
+        dbKey: resolved.dbKey,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls,
+      });
+    }
+    const failedDeletes = deleteResults.filter((result) => !result.ok);
+
+    const payload = {
+      dbKey: resolved.dbKey,
+      dialogId: resolved.dialogId,
+      title: dialog.title,
+      readServerUrl: readResult.serverUrl,
+      targetServers: serverUrls,
+      dryRun: !shouldDelete,
+      deleted: shouldDelete,
+      ...(readResult.failures.length ? { readFailures: readResult.failures } : {}),
+      ...(shouldDelete ? { deleteResults } : {}),
+    };
+
+    if (hasFlag(args, "--json")) {
+      output.write(JSON.stringify(payload, null, 2));
+      output.write("\n");
+      return failedDeletes.length > 0 ? 1 : 0;
+    }
+
+    output.write(`dialog: ${dialog.title}\n`);
+    output.write(`dbKey: ${resolved.dbKey}\n`);
+    output.write(`readServer: ${readResult.serverUrl}\n`);
+    output.write(`targetServers: ${serverUrls.join(", ")}\n`);
+    output.write(
+      shouldDelete
+        ? failedDeletes.length > 0
+          ? `Deleted dialog on ${deleteResults.length - failedDeletes.length}/${deleteResults.length} servers. Failed: ${failedDeletes.map((result) => `${result.serverUrl} (${result.error})`).join(", ")}\n`
+          : "Deleted dialog on all target servers. Server-side delete cascades dialog messages.\n"
+        : "Dry-run only. Add --yes to delete this dialog and its messages.\n"
+    );
+    return failedDeletes.length > 0 ? 1 : 0;
+  } catch (error) {
+    output.write(
+      `[nolo] dialog delete failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/cli/dialogInternalCommandEntries.ts

@@ -0,0 +1,13 @@
+import type { CommandEntry } from "./cliCommandTypes";
+import { createEnvCommand } from "./cliCommandFactories";
+import {
+  runDialogDeleteCommand,
+  runDialogListCommand,
+} from "./dialogCommands";
+
+export function getDialogInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["dialog", "list"], "List dialogs", runDialogListCommand),
+    createEnvCommand(["dialog", "delete"], "Delete a dialog", runDialogDeleteCommand),
+  ];
+}