nolo-cli 0.1.33 → 0.1.35

package/database/server/levelAuthorityStore.ts

@@ -0,0 +1,95 @@
+import { Level } from "level";
+
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+const safeJsonEncoding = {
+  name: "safe-json",
+  format: "utf8" as const,
+  encode: (data: any) => JSON.stringify(data),
+  decode: (data: string) => {
+    try {
+      return JSON.parse(data);
+    } catch {
+      console.warn("[LevelDB] Corrupted value:", data?.substring?.(0, 60));
+      return null;
+    }
+  },
+};
+
+type LevelBatchWriterLike = {
+  put(key: string, value: unknown): void;
+  del(key: string): void;
+  write(): Promise<void>;
+};
+
+type LevelLike = {
+  readonly location?: string;
+  readonly status?: string;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  get(key: string): Promise<unknown>;
+  put(key: string, value: unknown): Promise<void>;
+  del(key: string): Promise<void>;
+  batch(ops: AuthorityBatchOperation[]): Promise<void>;
+  batch(): LevelBatchWriterLike;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+};
+
+export function createLevelAuthorityStore(
+  source: string | LevelLike
+): AuthorityStore {
+  const levelDb: LevelLike = typeof source === "string"
+    ? new Level<string, any>(source, { valueEncoding: safeJsonEncoding })
+    : source;
+
+  return {
+    get location() {
+      return levelDb.location;
+    },
+    get status() {
+      return (levelDb as any).status;
+    },
+    async open() {
+      await levelDb.open();
+    },
+    async close() {
+      await levelDb.close();
+    },
+    async get<T = any>(key: string) {
+      return levelDb.get(key) as Promise<T>;
+    },
+    async put(key: string, value: unknown) {
+      await levelDb.put(key, value);
+    },
+    async del(key: string) {
+      await levelDb.del(key);
+    },
+    async batchWrite(ops: AuthorityBatchOperation[]) {
+      await levelDb.batch(ops);
+    },
+    createBatch(): AuthorityBatchWriter {
+      const batch = levelDb.batch();
+      return {
+        put(key: string, value: unknown) {
+          batch.put(key, value);
+        },
+        del(key: string) {
+          batch.del(key);
+        },
+        async write() {
+          await batch.write();
+        },
+      };
+    },
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return levelDb.iterator(options) as AsyncIterableIterator<[string, unknown]>;
+    },
+  };
+}

package/database/tombstones.ts

@@ -0,0 +1,52 @@
+export const getRecordTimestamp = (record: any): number => {
+  if (!record || typeof record !== "object") return 0;
+
+  const candidates = [
+    record.updatedAt,
+    record.updated_at,
+    record.createdAt,
+    record.created,
+    record?.meta?.createdAt,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
+      return candidate;
+    }
+    if (typeof candidate === "string" && candidate.trim()) {
+      const timestamp = Date.parse(candidate);
+      if (Number.isFinite(timestamp) && timestamp > 0) {
+        return timestamp;
+      }
+    }
+  }
+
+  return 0;
+};
+
+export const isTombstoneRecord = (record: any): boolean => {
+  if (!record || typeof record !== "object") return false;
+  const deletedAt = record.deletedAt;
+  if (typeof deletedAt === "string") return deletedAt.trim().length > 0;
+  return Boolean(deletedAt);
+};
+
+export const shouldReplaceWithNextRecord = (
+  nextRecord: any,
+  currentRecord: any
+): boolean => {
+  const nextTs = getRecordTimestamp(nextRecord);
+  const currentTs = getRecordTimestamp(currentRecord);
+
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return isTombstoneRecord(nextRecord) && !isTombstoneRecord(currentRecord);
+};
+
+export const buildTombstoneRecord = <T extends Record<string, any>>(
+  record: T,
+  nowIso: string
+): T & { deletedAt: string; updatedAt: string } => ({
+  ...record,
+  deletedAt: nowIso,
+  updatedAt: nowIso,
+});

package/database/userDataMerge.ts

@@ -0,0 +1,95 @@
+import {
+  getRecordTimestamp,
+  isTombstoneRecord,
+  shouldReplaceWithNextRecord,
+} from "./tombstones";
+
+interface MergeableUserDataItem {
+  id?: string;
+  dbKey?: string;
+  contentKey?: string;
+  appKey?: string;
+  appId?: string;
+  [key: string]: any;
+}
+
+export const getUserDataItemTimestamp = (dataItem: MergeableUserDataItem): number =>
+  getRecordTimestamp(dataItem);
+
+const getItemKey = (item: MergeableUserDataItem): string | null => {
+  // dbKey 必须优先于 id：dbKey 是全局唯一的 "type-userId-id" 格式，
+  // 而 id 可能只是 ULID 短串，与本地 tombstone 的 dbKey 不匹配会导致
+  // merge 时 tombstone 无法覆盖远端活记录。
+  const candidates = [
+    typeof item.dbKey === "string" ? item.dbKey : undefined,
+    item.id,
+    typeof item.contentKey === "string" ? item.contentKey : undefined,
+    typeof item.appKey === "string" ? item.appKey : undefined,
+    typeof item.appId === "string" ? item.appId : undefined,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+
+  return null;
+};
+
+export const mergeAndDedupUserData = (
+  localData: MergeableUserDataItem[],
+  remoteResults: any[],
+  options: { includeDeleted?: boolean } = {}
+): MergeableUserDataItem[] => {
+  const uniqueMap = new Map<string, MergeableUserDataItem>();
+
+  const mergeRecordMetadata = (
+    currentItem: MergeableUserDataItem,
+    nextItem: MergeableUserDataItem
+  ): MergeableUserDataItem => {
+    if (
+      typeof currentItem.serverOrigin !== "string" &&
+      typeof nextItem.serverOrigin === "string" &&
+      nextItem.serverOrigin.trim().length > 0
+    ) {
+      return {
+        ...currentItem,
+        serverOrigin: nextItem.serverOrigin,
+      };
+    }
+
+    return currentItem;
+  };
+
+  const addToMap = (item: MergeableUserDataItem) => {
+    const itemKey = getItemKey(item);
+    if (!itemKey) return;
+
+    const existing = uniqueMap.get(itemKey);
+    if (!existing) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+
+    if (shouldReplaceWithNextRecord(item, existing)) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+
+    uniqueMap.set(itemKey, mergeRecordMetadata(existing, item));
+  };
+
+  localData.forEach(addToMap);
+  remoteResults.forEach((result) => {
+    const items = result?.data?.data;
+    if (Array.isArray(items)) {
+      items.forEach(addToMap);
+    }
+  });
+
+  const merged = Array.from(uniqueMap.values());
+  return options.includeDeleted
+    ? merged
+    : merged.filter((item) => !isTombstoneRecord(item));
+};

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