nolo-cli 0.1.34 → 0.1.35

package/cli/agentRecordHelpers.ts

@@ -125,10 +125,12 @@ export async function readDbRecord(args: {
   authToken: string;
   fallbackFetchImpl?: typeof fetch;
   fetchImpl: typeof fetch;
+  includeDeleted?: boolean;
   serverUrl: string;
 }) {
+  const query = args.includeDeleted ? "?includeDeleted=true" : "";
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}${query}`,
     {
       method: "GET",
       headers: { Authorization: `Bearer ${args.authToken}` },
@@ -146,19 +148,29 @@ export async function queryUserRecords(args: {
   authToken: string;
   fallbackFetchImpl?: typeof fetch;
   fetchImpl: typeof fetch;
+  limit?: number;
   serverUrl: string;
+  summary?: boolean;
+  includeDeleted?: boolean;
   userId: string;
-  type: "agent" | "cybot";
-}) {
+  type: string | string[];
+}): Promise<any[]> {
+  const query = typeof args.limit === "number" && args.limit > 0
+    ? `?limit=${Math.floor(args.limit)}`
+    : "";
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}`,
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${query}`,
     {
       method: "POST",
       headers: {
         Authorization: `Bearer ${args.authToken}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({ type: args.type }),
+      body: JSON.stringify({
+        type: args.type,
+        ...(args.includeDeleted ? { includeDeleted: true } : {}),
+        ...(args.summary ? { summary: true } : {}),
+      }),
     },
     args
   );
@@ -173,6 +185,34 @@ export async function queryUserRecords(args: {
       : [];
 }
 
+export async function deleteDbRecord(args: {
+  dbKey: string;
+  deleteOptions?: { type?: "single" | "table" | "messages" };
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const type = args.deleteOptions?.type;
+  const query =
+    type && type !== "single"
+      ? `?type=${encodeURIComponent(type)}`
+      : "";
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}${query}`,
+    {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${args.authToken}` },
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data;
+}
+
 export async function writeAgentRecord(args: {
   agentKey: string;
   authToken: string;

package/cli/cliSpaceHelpers.ts

@@ -0,0 +1,39 @@
+export function normalizeSpaceIdInput(rawInput: string) {
+  const raw = rawInput.trim();
+  if (!raw) return "";
+
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(/^\/space\/([^/?#]+)/);
+    if (match?.[1]) return decodeURIComponent(match[1]);
+  }
+
+  return raw.startsWith("space-") ? raw.slice("space-".length) : raw;
+}
+
+export function buildSpaceLookup(rawInput: string) {
+  const spaceId = normalizeSpaceIdInput(rawInput);
+  return {
+    spaceId,
+    spaceKey: spaceId.startsWith("space-") ? spaceId : `space-${spaceId}`,
+  };
+}
+
+export function getSpaceContentKeys(spaceRecord: any): Set<string> {
+  const keys = new Set<string>();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+
+  for (const [entryKey, value] of Object.entries(contents)) {
+    if (typeof entryKey === "string" && entryKey.trim()) {
+      keys.add(entryKey.trim());
+    }
+    if (value && typeof value === "object") {
+      const contentKey = (value as any).contentKey;
+      if (typeof contentKey === "string" && contentKey.trim()) {
+        keys.add(contentKey.trim());
+      }
+    }
+  }
+  return keys;
+}

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),
+  ];
+}