nolo-cli 0.1.34 → 0.1.36

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

package/cli/globalRecordOperations.ts

@@ -0,0 +1,258 @@
+import {
+  deleteDbRecord,
+  queryUserRecords,
+  readDbRecord,
+} from "./agentRecordHelpers";
+import { isTombstoneRecord } from "../database/tombstones";
+import { mergeAndDedupUserData } from "../database/userDataMerge";
+
+export type GlobalRecordFailure = {
+  serverUrl: string;
+  error: string;
+};
+
+export type GlobalDeleteResult = {
+  serverUrl: string;
+  ok: boolean;
+  result?: any;
+  error?: string;
+};
+
+export type GlobalRecordTarget = {
+  serverUrl: string;
+  authToken?: string;
+};
+
+export type DbDeleteOptions = {
+  type?: "single" | "table" | "messages";
+};
+
+export async function listUserRecordsFromServers(args: {
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  limit?: number;
+  serverUrls: string[];
+  summary?: boolean;
+  type: string | string[];
+  userId: string;
+  label?: string;
+}) {
+  const remoteResults: Array<{ data: { data: any[] } }> = [];
+  const failures: GlobalRecordFailure[] = [];
+
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const records = await queryUserRecords({
+        authToken: args.authToken,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        limit: args.limit,
+        serverUrl,
+        summary: args.summary,
+        type: args.type,
+        userId: args.userId,
+      });
+      remoteResults.push({
+        data: {
+          data: records.map((record: any) => ({
+            ...record,
+            serverOrigin:
+              typeof record?.serverOrigin === "string" && record.serverOrigin.trim()
+                ? record.serverOrigin
+                : serverUrl,
+          })),
+        },
+      });
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  if (remoteResults.length === 0 && failures.length > 0) {
+    const label = args.label ?? "record query";
+    throw new Error(
+      `${label} failed on all candidate servers: ${failures
+        .map((failure) => `${failure.serverUrl}: ${failure.error}`)
+        .join("; ")}`
+    );
+  }
+
+  const merged = mergeAndDedupUserData([], remoteResults, { includeDeleted: true });
+  return {
+    records: merged.filter((record) => !isTombstoneRecord(record)),
+    failures,
+  };
+}
+
+export async function readDbRecordFromServers(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  includeDeleted?: boolean;
+  serverUrls: string[];
+  label?: string;
+}) {
+  const failures: GlobalRecordFailure[] = [];
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: args.includeDeleted,
+        serverUrl,
+      });
+      return { record, serverUrl, failures };
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  const label = args.label ?? `record ${args.dbKey}`;
+  throw new Error(
+    `${label} is unreadable on all candidate servers: ${failures
+      .map((failure) => `${failure.serverUrl}: ${failure.error}`)
+      .join("; ")}`
+  );
+}
+
+export async function readDbRecordVersionsFromServers(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}) {
+  const records: any[] = [];
+  const failures: GlobalRecordFailure[] = [];
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        serverUrl,
+      });
+      records.push({
+        ...record,
+        dbKey: typeof record?.dbKey === "string" && record.dbKey.trim()
+          ? record.dbKey
+          : args.dbKey,
+        serverOrigin:
+          typeof record?.serverOrigin === "string" && record.serverOrigin.trim()
+            ? record.serverOrigin
+            : serverUrl,
+      });
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return { records, failures };
+}
+
+export async function readLiveDbRecordAfterTombstoneMerge(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+  label?: string;
+}) {
+  const result = await readDbRecordVersionsFromServers(args);
+  const merged = mergeAndDedupUserData(
+    [],
+    [{ data: { data: result.records } }],
+    { includeDeleted: true }
+  );
+  const record = merged.find((item) => item?.dbKey === args.dbKey);
+  if (record && !isTombstoneRecord(record)) {
+    return {
+      record,
+      serverUrl: typeof record.serverOrigin === "string" ? record.serverOrigin : "",
+      failures: result.failures,
+    };
+  }
+
+  const label = args.label ?? `record ${args.dbKey}`;
+  const failureText = result.failures.length
+    ? ` Failures: ${result.failures
+        .map((failure) => `${failure.serverUrl}: ${failure.error}`)
+        .join("; ")}`
+    : "";
+  throw new Error(`${label} is deleted or unreadable after global tombstone merge.${failureText}`);
+}
+
+export async function recordExistsAfterTombstoneMerge(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}) {
+  try {
+    await readLiveDbRecordAfterTombstoneMerge(args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function deleteDbRecordOnServers(args: {
+  authToken: string;
+  dbKey: string;
+  deleteOptions?: DbDeleteOptions;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}): Promise<GlobalDeleteResult[]> {
+  return deleteDbRecordOnTargets({
+    ...args,
+    targets: args.serverUrls.map((serverUrl) => ({ serverUrl })),
+  });
+}
+
+export async function deleteDbRecordOnTargets(args: {
+  authToken: string;
+  dbKey: string;
+  deleteOptions?: DbDeleteOptions;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  targets: GlobalRecordTarget[];
+}): Promise<GlobalDeleteResult[]> {
+  const results: GlobalDeleteResult[] = [];
+  for (const target of args.targets) {
+    try {
+      const result = await deleteDbRecord({
+        authToken: target.authToken ?? args.authToken,
+        dbKey: args.dbKey,
+        deleteOptions: args.deleteOptions,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl: target.serverUrl,
+      });
+      results.push({ serverUrl: target.serverUrl, ok: true, result });
+    } catch (error) {
+      results.push({
+        serverUrl: target.serverUrl,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return results;
+}