@chibitek/chibi 0.1.172 → 0.1.174

package/dist-server/server/workspace-backup-private.js

@@ -0,0 +1,83 @@
+// Company backups (electron/company-backups.mjs) leave the person's Private
+// Bot out: its record, threads, messages, memory, folders and attachments.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** The Private Bot's ids and thread ids in a data folder, from bots.json. */
+export function privateBotIds(dataDir) {
+    const botIds = new Set();
+    const threadIds = new Set();
+    const path = join(dataDir, "bots.json");
+    if (!existsSync(path))
+        return { botIds, threadIds };
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return { botIds, threadIds };
+    }
+    if (!Array.isArray(value))
+        return { botIds, threadIds };
+    for (const bot of value) {
+        if (!record(bot) || bot.personal !== true || typeof bot.id !== "string")
+            continue;
+        botIds.add(bot.id);
+        if (typeof bot.threadId === "string")
+            threadIds.add(bot.threadId);
+        if (Array.isArray(bot.tasks))
+            for (const task of bot.tasks)
+                if (record(task) && typeof task.threadId === "string")
+                    threadIds.add(task.threadId);
+    }
+    return { botIds, threadIds };
+}
+/** Whether a data-folder path belongs to the Private Bot: a folder or file
+ * named after its id or one of its threads, anywhere below the top level
+ * (workspaces/<id>, task-workspaces/<id>, events/<thread>.jsonl, ...). */
+export function privateBotPath(path, ids) {
+    if (ids.size === 0)
+        return false;
+    const parts = path.split("/");
+    return parts.slice(1).some((part) => {
+        const stem = part.split(".")[0] ?? part;
+        return ids.has(part) || ids.has(stem);
+    });
+}
+/** Remove the Private Bot's rows from a copy of the message database, and
+ * return the attachment names its messages referenced. */
+export function scrubPrivateMessages(dbPath, botIds, threadIds) {
+    const attachments = new Set();
+    if (!existsSync(dbPath) || (botIds.size === 0 && threadIds.size === 0))
+        return attachments;
+    const db = new DatabaseSync(dbPath);
+    try {
+        const threads = [...threadIds];
+        const bots = [...botIds];
+        const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((row) => String(row.name)));
+        const marks = (count) => Array.from({ length: count }, () => "?").join(", ");
+        if (threads.length && tables.has("messages")) {
+            for (const row of db.prepare(`SELECT json FROM messages WHERE thread_id IN (${marks(threads.length)})`).all(...threads)) {
+                for (const match of String(row.json).matchAll(/\/api\/attachments\/([A-Za-z0-9._-]{1,200})/g))
+                    attachments.add(match[1]);
+            }
+            db.prepare(`DELETE FROM messages WHERE thread_id IN (${marks(threads.length)})`).run(...threads);
+        }
+        if (threads.length && tables.has("thread_state"))
+            db.prepare(`DELETE FROM thread_state WHERE thread_id IN (${marks(threads.length)})`).run(...threads);
+        if (tables.has("chat_followups") && (threads.length || bots.length)) {
+            db.prepare(`DELETE FROM chat_followups WHERE thread_id IN (${marks(threads.length || 1)}) OR owner_id IN (${marks(bots.length || 1)})`)
+                .run(...(threads.length ? threads : [""]), ...(bots.length ? bots : [""]));
+        }
+        if (bots.length && tables.has("memory_files"))
+            db.prepare(`DELETE FROM memory_files WHERE bot_id IN (${marks(bots.length)})`).run(...bots);
+        db.exec("VACUUM");
+    }
+    finally {
+        db.close();
+    }
+    return attachments;
+}

package/dist-server/server/workspace-backup-secrets.js

@@ -0,0 +1,90 @@
+// Secrets in an encrypted workspace backup. Two kinds travel:
+//   - data-folder files that hold credentials (provider login homes, instance
+//     keys, saved runtimes), as ordinary archive entries; and
+//   - the desktop's secure-store entries and native vault key, as one
+//     secrets.json beside the manifest, read from and handed back to the
+//     desktop app over its private port (electron/workspace-restore-secrets.mjs).
+// Neither is ever written into an unencrypted backup.
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+import { WORKSPACE_SECRETS_REQUEST, WORKSPACE_SECRETS_RESULT } from "../electron/workspace-restore-secrets.mjs";
+/** Top-level data-folder entries that only a secrets backup carries. */
+export const SECRET_TOP_LEVEL = new Set(["providers", "workspace-credentials.json", "instance-keys.json", "external-runtimes.json"]);
+/** The native vault's key file is sealed by this computer's keychain and is
+ * unreadable anywhere else; its raw record travels in secrets.json. */
+export function secretWorkspacePath(path) {
+    return SECRET_TOP_LEVEL.has(path.split("/")[0]) && path !== "providers/native-vault/key.bin";
+}
+export function validSecretsBundle(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const bundle = value;
+    const key = bundle.vaultKey;
+    return Object.keys(bundle).every((name) => name === "credentials" || name === "vaultKey") &&
+        !!bundle.credentials && typeof bundle.credentials === "object" && !Array.isArray(bundle.credentials) &&
+        (key === null || (!!key && key.version === 1 && typeof key.ownerId === "string" && typeof key.key === "string" && /^[0-9a-f]{64}$/.test(key.key)));
+}
+let desktop = null;
+/** The desktop's secure store, or null on a headless or development server. */
+export function desktopWorkspaceSecrets() { return desktop; }
+/** Wire the private port, then finish a restore this boot just applied: the
+ * desktop installs the waiting secrets and relaunches the app. The outcome
+ * goes on the restore receipt so Settings can say what needs signing in. */
+export function installWorkspaceSecrets(port, dataDir, restore) {
+    if (!port) {
+        // A server without the desktop app cannot install the credential store.
+        if (restore.restored && restore.id && restore.summary?.secrets)
+            markRestoreSecrets(dataDir, restore, "failed");
+        return;
+    }
+    const waiting = new Map();
+    port.on("message", (event) => {
+        const message = event?.data;
+        if (message?.type !== WORKSPACE_SECRETS_RESULT || typeof message.requestId !== "string")
+            return;
+        waiting.get(message.requestId)?.(message);
+    });
+    const request = (body) => new Promise((resolve, reject) => {
+        const requestId = randomUUID();
+        const timer = setTimeout(() => { waiting.delete(requestId); reject(new Error("The desktop app did not answer. Try again.")); }, 30_000);
+        waiting.set(requestId, (message) => {
+            clearTimeout(timer);
+            waiting.delete(requestId);
+            if (message.ok === true)
+                resolve(message);
+            else
+                reject(new Error(typeof message.error === "string" ? message.error : "The desktop app could not use its secure credential store."));
+        });
+        port.postMessage({ type: WORKSPACE_SECRETS_REQUEST, requestId, ...body });
+    });
+    desktop = {
+        async export() {
+            const { secrets } = await request({ action: "export" });
+            if (!validSecretsBundle(secrets))
+                throw new Error("The desktop app returned unreadable secrets.");
+            return secrets;
+        },
+        async stage(id, secrets) { await request({ action: "stage", id, secrets }); },
+        async apply(id) { return (await request({ action: "apply", id })).applied === true; },
+    };
+    if (restore.restored && restore.id && restore.summary?.secrets) {
+        void desktop.apply(restore.id).then((applied) => markRestoreSecrets(dataDir, restore, applied ? "applied" : "failed"), (error) => {
+            console.error(`[workspace-restore] secrets were not installed: ${error instanceof Error ? error.message : String(error)}`);
+            markRestoreSecrets(dataDir, restore, "failed");
+        });
+    }
+}
+/** Record on the receipt (and this boot's copy of it) whether the saved
+ * credentials went in, so Settings can say what needs signing in again. */
+export function markRestoreSecrets(dataDir, restore, outcome) {
+    restore.secrets = outcome;
+    const path = join(dataDir, ".backups", "last-restore.json");
+    if (!existsSync(path))
+        return;
+    const receipt = JSON.parse(readFileSync(path, "utf8"));
+    if (!receipt || typeof receipt !== "object" || receipt.id !== restore.id)
+        return;
+    writeFileAtomic(path, JSON.stringify({ ...receipt, secrets: outcome }), { mode: 0o600 });
+}