nolo-cli 0.1.40 → 0.1.42

package/cli/dialogAttachmentCleanup.ts

@@ -0,0 +1,151 @@
+import { deleteDbRecordOnServers, readDbRecordFromServers, type GlobalDeleteResult } from "./globalRecordOperations";
+import {
+  buildDialogAttachmentPlan,
+  extractFileContentIds,
+  type DialogAttachmentCandidate,
+  type DialogAttachmentPlan,
+} from "../chat/dialog/dialogAttachmentCleanup";
+
+export { buildDialogAttachmentPlan, extractFileContentIds };
+
+export type DialogAttachmentDeleteResult = {
+  fileId: string;
+  fileDbKey: string;
+  deleteResults: GlobalDeleteResult[];
+};
+
+function asText(value: unknown) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+async function readDialogMessages(args: {
+  authToken: string;
+  dialogId: string;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const response = await args.fetchImpl(`${args.serverUrl}/rpc/getConvMsgs`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ dialogId: args.dialogId, limit: 10000 }),
+  });
+  if (!response.ok) {
+    throw new Error(`read dialog messages failed on ${args.serverUrl}: HTTP ${response.status}`);
+  }
+  const payload = await response.json();
+  return Array.isArray(payload) ? payload : [];
+}
+
+export async function planDialogAttachmentCleanup(args: {
+  authToken: string;
+  dialogId: string;
+  ownerId?: string | null;
+  includeUserOwnedReferenced?: boolean;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  serverUrls: string[];
+}): Promise<DialogAttachmentPlan> {
+  const messages = await readDialogMessages({
+    authToken: args.authToken,
+    dialogId: args.dialogId,
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.serverUrl,
+  });
+  const fileIds = [...new Set(messages.flatMap((message) => extractFileContentIds(message)))];
+  const metadataByFileId: Record<string, any> = {};
+  const metadataReadFailures: Array<{ fileId: string; error: string }> = [];
+
+  for (const fileId of fileIds) {
+    try {
+      const result = await readDbRecordFromServers({
+        authToken: args.authToken,
+        dbKey: `file-id-${fileId}`,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrls: args.serverUrls,
+        label: `file metadata index ${fileId}`,
+      });
+      const mainKey = asText(result.record?.mainKey);
+      if (!mainKey) throw new Error(`file-id index missing mainKey`);
+      const metadata = await readDbRecordFromServers({
+        authToken: args.authToken,
+        dbKey: mainKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrls: args.serverUrls,
+        label: `file metadata ${fileId}`,
+      });
+      metadataByFileId[fileId] = {
+        ...metadata.record,
+        dbKey: asText(metadata.record?.dbKey) ?? mainKey,
+      };
+    } catch (error) {
+      const fallbackKey =
+        args.ownerId && !fileId.startsWith("file-")
+          ? `file-${args.ownerId}-${fileId}`
+          : null;
+      if (fallbackKey) {
+        try {
+          const metadata = await readDbRecordFromServers({
+            authToken: args.authToken,
+            dbKey: fallbackKey,
+            fallbackFetchImpl: args.fallbackFetchImpl,
+            fetchImpl: args.fetchImpl,
+            serverUrls: args.serverUrls,
+            label: `file metadata ${fileId}`,
+          });
+          metadataByFileId[fileId] = {
+            ...metadata.record,
+            dbKey: asText(metadata.record?.dbKey) ?? fallbackKey,
+          };
+          continue;
+        } catch {
+          // Keep the original index error; it explains why the preferred path failed.
+        }
+      }
+      metadataReadFailures.push({
+        fileId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return buildDialogAttachmentPlan({
+    dialogId: args.dialogId,
+    ownerId: args.ownerId,
+    includeUserOwnedReferenced: args.includeUserOwnedReferenced,
+    messages,
+    metadataByFileId,
+    metadataReadFailures,
+  });
+}
+
+export async function deleteDialogAttachmentCandidates(args: {
+  authToken: string;
+  candidates: DialogAttachmentCandidate[];
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}): Promise<DialogAttachmentDeleteResult[]> {
+  const results: DialogAttachmentDeleteResult[] = [];
+  for (const candidate of args.candidates) {
+    if (candidate.status !== "delete" || !candidate.fileDbKey) continue;
+    const deleteResults = await deleteDbRecordOnServers({
+      authToken: args.authToken,
+      dbKey: candidate.fileDbKey,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrls: args.serverUrls,
+    });
+    results.push({
+      fileId: candidate.fileId,
+      fileDbKey: candidate.fileDbKey,
+      deleteResults,
+    });
+  }
+  return results;
+}

package/cli/dialogCommands.ts

@@ -13,6 +13,10 @@ import {
   readDbRecordFromServers,
   readLiveDbRecordAfterTombstoneMerge,
 } from "./globalRecordOperations";
+import {
+  deleteDialogAttachmentCandidates,
+  planDialogAttachmentCleanup,
+} from "./dialogAttachmentCleanup";
 
 type ReadSource = "http" | "local-db-fallback";
 
@@ -45,6 +49,7 @@ const VALUE_FLAGS = new Set([
   "--space",
   "--space-id",
   "--token",
+  "--machine-key",
   "--user",
 ]);
 
@@ -64,6 +69,21 @@ function readFirstPositional(args: string[]) {
   return undefined;
 }
 
+function readAllPositional(args: string[]) {
+  const positionals: 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("-")) {
+      positionals.push(value);
+    }
+  }
+  return positionals;
+}
+
 function readLimit(args: string[], fallback: number) {
   const raw = readOption(args, "--limit");
   const parsed = raw ? Number(raw) : fallback;
@@ -194,15 +214,20 @@ 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]
+  nolo dialog delete <dialogId|dialogKey|dialogUrl...> [--yes] [--include-attachments] [--include-referenced-attachments] [--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.
+  --yes                  Actually delete. Without this, the command is a dry-run.
+  --include-attachments  Also delete files explicitly owned by this dialog/messages.
+  --include-referenced-attachments
+                         Also delete same-account user-owned files referenced by this dialog.
+  --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.
+Attachment cleanup is conservative by default. Use --include-referenced-attachments only
+when you intentionally want to remove user-owned files referenced by the dialog too.
 `);
 }
 
@@ -927,8 +952,8 @@ export async function runDialogDeleteCommand(
     return 0;
   }
 
-  const rawDialog = readFirstPositional(args);
-  if (!rawDialog) {
+  const rawDialogs = readAllPositional(args);
+  if (rawDialogs.length === 0) {
     printDeleteUsage(output);
     return 1;
   }
@@ -948,71 +973,148 @@ export async function runDialogDeleteCommand(
   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");
+  const includeReferencedAttachments = hasFlag(args, "--include-referenced-attachments");
+  const includeAttachments = hasFlag(args, "--include-attachments") || includeReferencedAttachments;
 
-  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 hasErrors = false;
+  const payloads: any[] = [];
 
-    let deleteResults: Awaited<ReturnType<typeof deleteDbRecordOnServers>> = [];
-    if (shouldDelete) {
-      deleteResults = await deleteDbRecordOnServers({
+  for (const rawDialog of rawDialogs) {
+    try {
+      const resolved = resolveDialogInput(rawDialog, userId);
+      const readResult = await readDbRecordFromServers({
         authToken,
         dbKey: resolved.dbKey,
         fallbackFetchImpl,
         fetchImpl,
+        label: "dialog record",
         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 } : {}),
-    };
+      const dialog = normalizeDialogRecord(readResult.record, resolved.dbKey);
+      if (!dialog) {
+        throw new Error(`dialog record is unreadable: ${resolved.dbKey}`);
+      }
+
+      const attachmentPlan = includeAttachments
+        ? await planDialogAttachmentCleanup({
+            authToken,
+            dialogId: resolved.dialogId,
+            ownerId: resolved.ownerId,
+            includeUserOwnedReferenced: includeReferencedAttachments,
+            fallbackFetchImpl,
+            fetchImpl,
+            serverUrl: readResult.serverUrl,
+            serverUrls,
+          })
+        : null;
+
+      const attachmentDeleteResults =
+        includeAttachments && shouldDelete && attachmentPlan
+          ? await deleteDialogAttachmentCandidates({
+              authToken,
+              candidates: attachmentPlan.deleteCandidates,
+              fallbackFetchImpl,
+              fetchImpl,
+              serverUrls,
+            })
+          : [];
+
+      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 failedAttachmentDeletes = attachmentDeleteResults.flatMap((result) =>
+        result.deleteResults
+          .filter((deleteResult) => !deleteResult.ok)
+          .map((deleteResult) => ({
+            fileId: result.fileId,
+            fileDbKey: result.fileDbKey,
+            ...deleteResult,
+          }))
+      );
 
-    if (hasFlag(args, "--json")) {
-      output.write(JSON.stringify(payload, null, 2));
-      output.write("\n");
-      return failedDeletes.length > 0 ? 1 : 0;
+      if (failedDeletes.length > 0 || failedAttachmentDeletes.length > 0) {
+        hasErrors = true;
+      }
+
+      const payload = {
+        dbKey: resolved.dbKey,
+        dialogId: resolved.dialogId,
+        title: dialog.title,
+        readServerUrl: readResult.serverUrl,
+        targetServers: serverUrls,
+        dryRun: !shouldDelete,
+        deleted: shouldDelete,
+        includeAttachments,
+        includeReferencedAttachments,
+        ...(attachmentPlan ? { attachmentPlan } : {}),
+        ...(readResult.failures.length ? { readFailures: readResult.failures } : {}),
+        ...(shouldDelete ? { deleteResults } : {}),
+        ...(attachmentDeleteResults.length ? { attachmentDeleteResults } : {}),
+      };
+      payloads.push(payload);
+
+      if (!hasFlag(args, "--json")) {
+        output.write(`dialog: ${dialog.title}\n`);
+        output.write(`dbKey: ${resolved.dbKey}\n`);
+        output.write(`readServer: ${readResult.serverUrl}\n`);
+        output.write(`targetServers: ${serverUrls.join(", ")}\n`);
+        if (attachmentPlan) {
+          output.write(
+            `attachments: ${attachmentPlan.deleteCandidates.length} delete candidates, ${attachmentPlan.retainedCandidates.length} retained, ${attachmentPlan.bytesToDelete} bytes planned\n`
+          );
+          for (const candidate of attachmentPlan.retainedCandidates) {
+            output.write(`retained attachment: ${candidate.fileId} (${candidate.reason})\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"
+            : includeAttachments
+              ? "Dry-run only. Add --yes to delete this dialog, its messages, and delete-candidate attachments.\n"
+              : "Dry-run only. Add --yes to delete this dialog and its messages.\n"
+        );
+        if (failedAttachmentDeletes.length > 0) {
+          output.write(
+            `Attachment delete failures: ${failedAttachmentDeletes.map((result) => `${result.fileDbKey}@${result.serverUrl} (${result.error})`).join(", ")}\n`
+          );
+        }
+        if (rawDialogs.length > 1) {
+          output.write("\n");
+        }
+      }
+    } catch (error) {
+      hasErrors = true;
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (hasFlag(args, "--json")) {
+        payloads.push({
+          rawDialog,
+          error: errorMsg,
+        });
+      } else {
+        output.write(`[nolo] dialog delete failed for ${rawDialog}: ${errorMsg}\n`);
+        if (rawDialogs.length > 1) {
+          output.write("\n");
+        }
+      }
     }
+  }
 
-    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;
+  if (hasFlag(args, "--json")) {
+    const finalPayload = rawDialogs.length === 1 ? payloads[0] : payloads;
+    output.write(JSON.stringify(finalPayload, null, 2));
+    output.write("\n");
   }
+
+  return hasErrors ? 1 : 0;
 }

package/cli/dialogInternalCommandEntries.ts

@@ -10,7 +10,7 @@ import {
 export function getDialogInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvCommand(["dialog", "list"], "List dialogs", runDialogListCommand),
-    createEnvCommand(["dialog", "delete"], "Delete a dialog", runDialogDeleteCommand),
+    createEnvCommand(["dialog", "delete"], "Delete one or more dialogs", runDialogDeleteCommand),
     createEnvCommand(["dialog", "read"], "Read a dialog", runDialogReadCommand),
     createEnvCommand(["dialog", "status"], "Read compact dialog status", runDialogStatusCommand),
   ];