@tryglen/cli 0.37.1 → 0.38.0

package/dist/commands/takeover/_utils/cursor-store.js

@@ -1,113 +1,292 @@
-import { existsSync } from "node:fs";
-import { copyFile, mkdtemp, readFile, readdir, rm, } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { causeOf, cliErr } from "../../../_utils/cli-error.js";
-import { err, fromPromise, ok } from "../../../_utils/result.js";
-import { runBin } from "../../../_utils/run-bin.js";
-const loadSqlite = async () => {
-    try {
-        const specifier = "node:sqlite";
-        const sqlite = (await import(specifier));
-        return sqlite.DatabaseSync ?? null;
-    }
-    catch {
+import { cliErr } from "../../../core/errors/cli-error.js";
+import { env } from "../../../core/system/env.js";
+import { files } from "../../../core/system/files.js";
+import { field } from "../../../core/json/json-field.js";
+import { parseJson } from "../../../core/json/parse-json.js";
+import { err, ok } from "../../../core/errors/result.js";
+import { runProgram } from "../../../core/system/run-program.js";
+import { sqlite } from "../../../core/system/sqlite.js";
+const SQLITE_MISSING = cliErr("Exec", {
+    code: "cursor.sqlite_unavailable",
+    what: "Cursor takeover needs Node.js 22.5 or newer (node:sqlite)",
+    remedy: "run the takeover with Node.js 22.5+; no database was changed",
+});
+const cursorRoot = () => {
+    const e = env();
+    if (e.GLEN_CURSOR_USER_DATA)
+        return e.GLEN_CURSOR_USER_DATA;
+    if (process.platform === "darwin")
+        return join(homedir(), "Library", "Application Support", "Cursor");
+    if (process.platform === "win32")
+        return join(e.APPDATA ?? "", "Cursor");
+    return join(homedir(), ".config", "Cursor");
+};
+// SQLite in WAL mode keeps recent writes in -wal/-shm beside the db; a copy needs all three.
+const databaseFiles = async (path) => {
+    const candidates = ["", "-wal", "-shm"].map((suffix) => ({
+        path: `${path}${suffix}`,
+        suffix,
+    }));
+    const present = await Promise.all(candidates.map((c) => files.exists(c.path)));
+    return candidates.filter((_, i) => present[i]);
+};
+const copyDatabaseFiles = async (source, destination) => {
+    const copied = await Promise.all((await databaseFiles(source)).map((file) => files.copyFile(file.path, `${destination}${file.suffix}`)));
+    const failed = copied.find((c) => !c.ok);
+    return failed && !failed.ok ? failed : ok(undefined);
+};
+const folderOf = async (directory) => {
+    const raw = await files.readTextIfExists(join(directory, "workspace.json"));
+    if (!raw.ok || raw.value === null)
         return null;
-    }
+    const parsed = parseJson(raw.value);
+    const folder = parsed.ok ? field(parsed.value, "folder") : undefined;
+    return typeof folder === "string" ? folder.replace(/\/$/, "") : null;
 };
-const cursorRoot = () => process.env.GLEN_CURSOR_USER_DATA ??
-    (process.platform === "darwin"
-        ? join(homedir(), "Library", "Application Support", "Cursor")
-        : process.platform === "win32"
-            ? join(process.env.APPDATA ?? "", "Cursor")
-            : join(homedir(), ".config", "Cursor"));
-const databaseFiles = (path) => ["", "-wal", "-shm"]
-    .map((suffix) => ({ path: `${path}${suffix}`, suffix }))
-    .filter((file) => existsSync(file.path));
-const copyDatabaseFiles = (source, destination) => Promise.all(databaseFiles(source).map((file) => copyFile(file.path, `${destination}${file.suffix}`)));
+// Cursor keeps one state db per opened folder under a hashed name; workspace.json says which.
 const workspaceDb = async (workspace) => {
-    if (process.env.GLEN_CURSOR_WORKSPACE_DB)
-        return process.env.GLEN_CURSOR_WORKSPACE_DB;
+    const override = env().GLEN_CURSOR_WORKSPACE_DB;
+    if (override)
+        return override;
     const root = join(cursorRoot(), "User", "workspaceStorage");
-    const directories = await fromPromise(readdir(root, { withFileTypes: true }));
-    if (!directories.ok)
+    const entries = await files.readDirEntries(root);
+    if (!entries.ok)
         return null;
     const expected = pathToFileURL(workspace).href.replace(/\/$/, "");
-    const matches = await Promise.all(directories.value
+    const matches = await Promise.all(entries.value
         .filter((entry) => entry.isDirectory())
-        .map(async (entry) => {
-        const directory = join(root, entry.name);
-        const raw = await fromPromise(readFile(join(directory, "workspace.json"), "utf8"));
-        if (!raw.ok)
-            return null;
-        try {
-            const parsed = JSON.parse(raw.value);
-            return typeof parsed.folder === "string" &&
-                parsed.folder.replace(/\/$/, "") === expected
-                ? join(directory, "state.vscdb")
-                : null;
-        }
-        catch {
-            return null;
-        }
-    }));
+        .map(async (entry) => (await folderOf(join(root, entry.name))) === expected
+        ? join(root, entry.name, "state.vscdb")
+        : null));
     return matches.find((match) => match !== null) ?? null;
 };
 const cursorIsRunning = () => {
-    if (process.env.GLEN_CURSOR_TEST_CLOSED === "1")
+    if (env().GLEN_CURSOR_TEST_CLOSED)
         return false;
     if (process.platform === "win32") {
-        const listed = runBin("tasklist", ["/FI", "IMAGENAME eq Cursor.exe"], {
+        const listed = runProgram("tasklist", ["/FI", "IMAGENAME eq Cursor.exe"], {
             timeoutMs: 3000,
         });
         return listed.ok && /Cursor\.exe/i.test(listed.value.stdout);
     }
-    return runBin("pgrep", ["-f", "Cursor(.app/Contents/MacOS/Cursor)?"], {
+    return runProgram("pgrep", ["-f", "Cursor(.app/Contents/MacOS/Cursor)?"], {
         timeoutMs: 3000,
     }).ok;
 };
-const schemaSupported = (db) => {
-    const tables = new Set(db
-        .prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
-        .all()
-        .map((row) => row.name)
-        .filter((name) => typeof name === "string"));
+const namesOf = (rows) => new Set(rows.ok
+    ? rows.value.map((row) => row.name).filter((n) => typeof n === "string")
+    : []);
+const HEADER_COLUMNS = [
+    "composerId",
+    "workspaceId",
+    "createdAt",
+    "lastUpdatedAt",
+    "isArchived",
+    "isSubagent",
+    "recency",
+    "checkpointAt",
+    "value",
+];
+const schemaSupported = (global, workspace) => {
+    const tables = namesOf(global.all("SELECT name FROM sqlite_master WHERE type = 'table'"));
     if (!tables.has("cursorDiskKV") || !tables.has("composerHeaders"))
         return false;
-    const headerColumns = new Set(db
-        .prepare("PRAGMA table_info(composerHeaders)")
-        .all()
-        .map((row) => row.name)
-        .filter((name) => typeof name === "string"));
-    return [
-        "composerId",
-        "workspaceId",
-        "createdAt",
-        "lastUpdatedAt",
-        "isArchived",
-        "isSubagent",
-        "recency",
-        "checkpointAt",
-        "value",
-    ].every((column) => headerColumns.has(column));
+    const columns = namesOf(global.all("PRAGMA table_info(composerHeaders)"));
+    const itemTable = workspace.get("SELECT name FROM sqlite_master WHERE type='table' AND name='ItemTable'");
+    return (HEADER_COLUMNS.every((column) => columns.has(column)) &&
+        itemTable.ok &&
+        itemTable.value !== null);
 };
-const mutate = (db, input) => {
-    db.prepare("INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)").run(`composerData:${input.sessionId}`, input.composer);
-    const insertBubble = db.prepare("INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)");
-    for (const bubble of input.bubbles)
-        insertBubble.run(bubble.key, bubble.value);
-    db.prepare("INSERT INTO composerHeaders(composerId, workspaceId, createdAt, lastUpdatedAt, isArchived, isSubagent, recency, checkpointAt, value) VALUES (?, ?, ?, ?, 0, 0, ?, NULL, ?)").run(input.sessionId, input.workspaceId, input.now, input.now, input.now, input.header);
-    db.prepare("INSERT OR REPLACE INTO workspace_db.ItemTable(key, value) VALUES (?, ?)").run("composer.composerData", input.workspaceIndex);
+const openDb = async (path, readOnly) => {
+    const db = await sqlite.open(path, { readOnly });
+    if (db.ok)
+        return db;
+    return err(db.error.kind === "unavailable"
+        ? SQLITE_MISSING
+        : cliErr("Fs", {
+            code: "cursor.db_open_failed",
+            what: "could not open a Cursor database",
+            path,
+            cause: db.error.cause,
+            remedy: "confirm Cursor is closed and the databases are readable",
+        }));
 };
+const runAll = (db, statements) => statements.reduce((done, [sql, ...params]) => (done.ok ? db.run(sql, ...params) : done), ok(undefined));
 const attach = (db, path) => db.exec(`ATTACH DATABASE '${path.replaceAll("'", "''")}' AS workspace_db`);
+const insertComposer = (db, input) => runAll(db, [
+    [
+        "INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)",
+        `composerData:${input.sessionId}`,
+        input.composer,
+    ],
+    ...input.bubbles.map((bubble) => [
+        "INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)",
+        bubble.key,
+        bubble.value,
+    ]),
+    [
+        "INSERT INTO composerHeaders(composerId, workspaceId, createdAt, lastUpdatedAt, isArchived, isSubagent, recency, checkpointAt, value) VALUES (?, ?, ?, ?, 0, 0, ?, NULL, ?)",
+        input.sessionId,
+        input.workspaceId,
+        input.now,
+        input.now,
+        input.now,
+        input.header,
+    ],
+    [
+        "INSERT OR REPLACE INTO workspace_db.ItemTable(key, value) VALUES (?, ?)",
+        "composer.composerData",
+        input.workspaceIndex,
+    ],
+]);
+const nextWorkspaceIndex = (db, sessionId) => {
+    const stored = db.get("SELECT value FROM workspace_db.ItemTable WHERE key = 'composer.composerData'");
+    if (!stored.ok)
+        return stored;
+    const raw = stored.value?.value;
+    const parsed = typeof raw === "string" ? parseJson(raw) : null;
+    const index = parsed?.ok && typeof parsed.value === "object" && parsed.value !== null
+        ? parsed.value
+        : {};
+    return ok(JSON.stringify({
+        ...index,
+        selectedComposerIds: [sessionId],
+        lastFocusedComposerIds: [sessionId],
+        hasMigratedComposerData: true,
+        hasMigratedMultipleComposers: true,
+    }));
+};
+const writeStaged = (db, workspaceCopy, input) => {
+    const attached = attach(db, workspaceCopy);
+    if (!attached.ok)
+        return attached;
+    return db.transaction(() => {
+        const index = nextWorkspaceIndex(db, input.sessionId);
+        if (!index.ok)
+            return index;
+        return insertComposer(db, { ...input, workspaceIndex: index.value });
+    });
+};
+const readStagedRows = (stagedGlobal, stagedWorkspace, sessionId) => {
+    const composer = stagedGlobal.get("SELECT value FROM cursorDiskKV WHERE key = ?", `composerData:${sessionId}`);
+    const bubbles = stagedGlobal.all("SELECT key, value FROM cursorDiskKV WHERE key LIKE ?", `bubbleId:${sessionId}:%`);
+    const header = stagedGlobal.get("SELECT * FROM composerHeaders WHERE composerId = ?", sessionId);
+    const index = stagedWorkspace.get("SELECT value FROM ItemTable WHERE key = 'composer.composerData'");
+    if (!composer.ok)
+        return composer;
+    if (!bubbles.ok)
+        return bubbles;
+    if (!header.ok)
+        return header;
+    if (!index.ok)
+        return index;
+    const composerValue = composer.value?.value;
+    const indexValue = index.value?.value;
+    if (typeof composerValue !== "string" ||
+        !header.value ||
+        typeof indexValue !== "string")
+        return err(new Error("staged Cursor rows are incomplete"));
+    return ok({
+        composer: composerValue,
+        bubbles: bubbles.value,
+        header: header.value,
+        workspaceIndex: indexValue,
+    });
+};
+const sortedByKey = (rows) => [...rows].sort((a, b) => String(a.key).localeCompare(String(b.key)));
+// Must run inside the transaction, so the retry-vs-conflict check can't race another takeover.
+const applyRows = (global, sessionId, rows) => {
+    const existing = global.get("SELECT value FROM cursorDiskKV WHERE key = ?", `composerData:${sessionId}`);
+    const existingHeader = global.get("SELECT value FROM composerHeaders WHERE composerId = ?", sessionId);
+    const existingBubbles = global.all("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ORDER BY key", `bubbleId:${sessionId}:%`);
+    if (!existing.ok)
+        return existing;
+    if (!existingHeader.ok)
+        return existingHeader;
+    if (!existingBubbles.ok)
+        return existingBubbles;
+    const indexed = [
+        "INSERT OR REPLACE INTO workspace_db.ItemTable(key, value) VALUES ('composer.composerData', ?)",
+        rows.workspaceIndex,
+    ];
+    if (existing.value !== null) {
+        const matches = existing.value.value === rows.composer &&
+            existingHeader.value?.value === rows.header.value &&
+            JSON.stringify(existingBubbles.value) ===
+                JSON.stringify(sortedByKey(rows.bubbles));
+        return matches
+            ? runAll(global, [indexed])
+            : err(new Error("destination composer already exists with different content"));
+    }
+    const h = rows.header;
+    return runAll(global, [
+        [
+            "INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)",
+            `composerData:${sessionId}`,
+            rows.composer,
+        ],
+        ...rows.bubbles.map((bubble) => [
+            "INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)",
+            bubble.key,
+            bubble.value,
+        ]),
+        [
+            "INSERT INTO composerHeaders(composerId, workspaceId, createdAt, lastUpdatedAt, isArchived, isSubagent, recency, checkpointAt, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            h.composerId,
+            h.workspaceId,
+            h.createdAt,
+            h.lastUpdatedAt,
+            h.isArchived,
+            h.isSubagent,
+            h.recency,
+            h.checkpointAt ?? null,
+            h.value,
+        ],
+        indexed,
+    ]);
+};
+const readStaged = async (stagedDirectory, sessionId) => {
+    const stagedGlobal = await openDb(join(stagedDirectory, "global.vscdb"), true);
+    if (!stagedGlobal.ok)
+        return stagedGlobal;
+    const stagedWorkspace = await openDb(join(stagedDirectory, "workspace.vscdb"), true);
+    if (!stagedWorkspace.ok) {
+        stagedGlobal.value.close();
+        return stagedWorkspace;
+    }
+    const rows = readStagedRows(stagedGlobal.value, stagedWorkspace.value, sessionId);
+    stagedGlobal.value.close();
+    stagedWorkspace.value.close();
+    return rows.ok ? rows : err({ cause: rows.error });
+};
+const applyStaged = async (paths, stagedDirectory, sessionId) => {
+    const rows = await readStaged(stagedDirectory, sessionId);
+    if (!rows.ok)
+        return rows;
+    const global = await openDb(paths.globalDb, false);
+    if (!global.ok)
+        return global;
+    const attached = attach(global.value, paths.workspaceDb);
+    const applied = attached.ok
+        ? global.value.transaction(() => applyRows(global.value, sessionId, rows.value))
+        : attached;
+    global.value.close();
+    return applied.ok ? ok(undefined) : err({ cause: applied.error });
+};
 const cursorStore = {
     async locate(workspace) {
-        const globalDb = process.env.GLEN_CURSOR_GLOBAL_DB ??
+        const globalDb = env().GLEN_CURSOR_GLOBAL_DB ??
             join(cursorRoot(), "User", "globalStorage", "state.vscdb");
         const matched = await workspaceDb(workspace);
-        if (!existsSync(globalDb) || !matched || !existsSync(matched))
-            return err(cliErr({
+        if (!(await files.exists(globalDb)) ||
+            !matched ||
+            !(await files.exists(matched)))
+            return err(cliErr("Usage", {
+                code: "cursor.workspace_not_initialized",
                 what: "Cursor has not initialized this workspace for local chat history",
                 path: matched ?? globalDb,
                 remedy: "open this folder in Cursor once, close Cursor completely, then retry the takeover",
@@ -120,130 +299,51 @@ const cursorStore = {
     },
     async probe(paths) {
         if ((Number(process.versions.node.split(".")[0]) || 0) < 22)
-            return err(cliErr({
-                what: "Cursor takeover needs Node.js 22.5 or newer",
-                remedy: "run the takeover with Node.js 22.5+; no database was changed",
-            }));
+            return err(SQLITE_MISSING);
         if (cursorIsRunning())
-            return err(cliErr({
+            return err(cliErr("Usage", {
+                code: "cursor.running",
                 what: "Cursor is still running",
                 remedy: "quit every Cursor window and wait a moment, then retry; no database was changed",
             }));
-        const DatabaseSync = await loadSqlite();
-        if (!DatabaseSync)
-            return err(cliErr({
-                what: "this Node.js runtime does not provide node:sqlite",
-                remedy: "run the takeover with Node.js 22.5+",
-            }));
-        const checked = (() => {
-            try {
-                const global = new DatabaseSync(paths.globalDb, { readOnly: true });
-                const workspace = new DatabaseSync(paths.workspaceDb, {
-                    readOnly: true,
-                });
-                const supported = schemaSupported(global) &&
-                    workspace
-                        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='ItemTable'")
-                        .get() !== undefined;
-                global.close();
-                workspace.close();
-                return supported;
-            }
-            catch {
-                return false;
-            }
-        })();
-        return checked
+        const global = await openDb(paths.globalDb, true);
+        if (!global.ok)
+            return global;
+        const workspace = await openDb(paths.workspaceDb, true);
+        if (!workspace.ok) {
+            global.value.close();
+            return workspace;
+        }
+        const supported = schemaSupported(global.value, workspace.value);
+        global.value.close();
+        workspace.value.close();
+        return supported
             ? ok(undefined)
-            : err(cliErr({
+            : err(cliErr("Usage", {
+                code: "cursor.schema_unsupported",
                 what: "this Cursor local-history schema is not supported",
                 remedy: "update Glen and Cursor, then retry; no database was changed",
             }));
     },
     async stage(paths, input) {
-        const safe = await this.probe(paths);
+        const safe = await cursorStore.probe(paths);
         if (!safe.ok)
             return safe;
-        const directory = await fromPromise(mkdtemp(join(tmpdir(), "glen-cursor-takeover-")));
-        if (!directory.ok)
-            return err(cliErr({
+        const directory = join(tmpdir(), `glen-cursor-takeover-${randomUUID()}`);
+        const made = await files.ensureDir(directory);
+        if (!made.ok)
+            return err(files.toError(made.error, {
+                code: "cursor.staging_dir_failed",
                 what: "could not create Cursor takeover staging",
-                why: causeOf(directory.error),
                 remedy: "check temporary-directory permissions, then retry",
             }));
-        const globalCopy = join(directory.value, "global.vscdb");
-        const workspaceCopy = join(directory.value, "workspace.vscdb");
-        const copied = await fromPromise(Promise.all([
-            copyDatabaseFiles(paths.globalDb, globalCopy),
-            copyDatabaseFiles(paths.workspaceDb, workspaceCopy),
-        ]));
-        if (!copied.ok) {
-            await rm(directory.value, { recursive: true, force: true });
-            return err(cliErr({
-                what: "could not copy the Cursor databases for staging",
-                why: causeOf(copied.error),
-                remedy: "confirm Cursor is closed and the databases are readable",
-            }));
-        }
-        const DatabaseSync = await loadSqlite();
-        if (!DatabaseSync) {
-            await rm(directory.value, { recursive: true, force: true });
-            return err(cliErr({
-                what: "node:sqlite became unavailable",
-                remedy: "retry with Node.js 22.5+",
-            }));
-        }
-        const written = (() => {
-            try {
-                const global = new DatabaseSync(globalCopy);
-                attach(global, workspaceCopy);
-                global.exec("BEGIN IMMEDIATE");
-                const storedIndex = global
-                    .prepare("SELECT value FROM workspace_db.ItemTable WHERE key = 'composer.composerData'")
-                    .get()?.value;
-                const parsedIndex = (() => {
-                    try {
-                        const value = typeof storedIndex === "string"
-                            ? JSON.parse(storedIndex)
-                            : null;
-                        return value !== null && typeof value === "object"
-                            ? value
-                            : {};
-                    }
-                    catch {
-                        return {};
-                    }
-                })();
-                mutate(global, {
-                    ...input,
-                    workspaceIndex: JSON.stringify({
-                        ...parsedIndex,
-                        selectedComposerIds: [input.sessionId],
-                        lastFocusedComposerIds: [input.sessionId],
-                        hasMigratedComposerData: true,
-                        hasMigratedMultipleComposers: true,
-                    }),
-                });
-                global.exec("COMMIT");
-                global.close();
-                return ok(undefined);
-            }
-            catch (error) {
-                return err(error);
-            }
-        })();
-        if (!written.ok) {
-            await rm(directory.value, { recursive: true, force: true });
-            return err(cliErr({
-                what: "could not stage the Cursor conversation",
-                why: causeOf(written.error),
-                remedy: "update Glen and Cursor, then retry",
-            }));
-        }
-        return ok({ path: directory.value });
+        const staged = await stageInto(directory, paths, input);
+        if (!staged.ok)
+            void (await files.remove(directory, { recursive: true }));
+        return staged.ok ? ok({ path: directory }) : staged;
     },
     async install(paths, stagedDirectory, sessionId) {
-        const safe = await this.probe(paths);
+        const safe = await cursorStore.probe(paths);
         if (!safe.ok)
             return safe;
         const suffix = new Date().toISOString().replace(/[:.]/g, "-");
@@ -251,107 +351,59 @@ const cursorStore = {
             source,
             destination: `${source}.glen-takeover-${suffix}.bak`,
         }));
-        const backups = backupSets.flatMap(({ source, destination }) => databaseFiles(source).map((file) => `${destination}${file.suffix}`));
-        const backedUp = await fromPromise(Promise.all(backupSets.map(({ source, destination }) => copyDatabaseFiles(source, destination))));
-        if (!backedUp.ok)
-            return err(cliErr({
+        const backups = (await Promise.all(backupSets.map(async ({ source, destination }) => (await databaseFiles(source)).map((file) => `${destination}${file.suffix}`)))).flat();
+        const backedUp = await Promise.all(backupSets.map(({ source, destination }) => copyDatabaseFiles(source, destination)));
+        const backupFailed = backedUp.find((b) => !b.ok);
+        if (backupFailed && !backupFailed.ok)
+            return err(files.toError(backupFailed.error, {
+                code: "cursor.backup_failed",
                 what: "could not back up Cursor before takeover",
-                why: causeOf(backedUp.error),
                 remedy: "check disk space and database permissions, then retry",
             }));
-        const DatabaseSync = await loadSqlite();
-        if (!DatabaseSync)
-            return err(cliErr({
-                what: "node:sqlite became unavailable",
-                remedy: "retry with Node.js 22.5+",
-            }));
-        const applied = (() => {
-            try {
-                const stagedGlobal = new DatabaseSync(join(stagedDirectory, "global.vscdb"), { readOnly: true });
-                const stagedWorkspace = new DatabaseSync(join(stagedDirectory, "workspace.vscdb"), { readOnly: true });
-                const composer = stagedGlobal
-                    .prepare("SELECT value FROM cursorDiskKV WHERE key = ?")
-                    .get(`composerData:${sessionId}`)?.value;
-                const bubbles = stagedGlobal
-                    .prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ?")
-                    .all(`bubbleId:${sessionId}:%`);
-                const header = stagedGlobal
-                    .prepare("SELECT * FROM composerHeaders WHERE composerId = ?")
-                    .get(sessionId);
-                const workspaceIndex = stagedWorkspace
-                    .prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'")
-                    .get()?.value;
-                stagedGlobal.close();
-                stagedWorkspace.close();
-                if (typeof composer !== "string" ||
-                    !header ||
-                    typeof workspaceIndex !== "string")
-                    return err(new Error("staged Cursor rows are incomplete"));
-                const global = new DatabaseSync(paths.globalDb);
-                try {
-                    attach(global, paths.workspaceDb);
-                    global.exec("BEGIN IMMEDIATE");
-                    const existing = global
-                        .prepare("SELECT value FROM cursorDiskKV WHERE key = ?")
-                        .get(`composerData:${sessionId}`)?.value;
-                    const existingHeader = global
-                        .prepare("SELECT value FROM composerHeaders WHERE composerId = ?")
-                        .get(sessionId)?.value;
-                    const existingBubbles = global
-                        .prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ORDER BY key")
-                        .all(`bubbleId:${sessionId}:%`);
-                    const expectedBubbles = [...bubbles].sort((first, second) => String(first.key).localeCompare(String(second.key)));
-                    const existingMatches = existing === composer &&
-                        existingHeader === header.value &&
-                        JSON.stringify(existingBubbles) === JSON.stringify(expectedBubbles);
-                    if (existing !== undefined && !existingMatches) {
-                        global.exec("ROLLBACK");
-                        global.close();
-                        return err(new Error("destination composer already exists with different content"));
-                    }
-                    if (existing === undefined) {
-                        global
-                            .prepare("INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)")
-                            .run(`composerData:${sessionId}`, composer);
-                        const insertBubble = global.prepare("INSERT INTO cursorDiskKV(key, value) VALUES (?, ?)");
-                        for (const bubble of bubbles)
-                            insertBubble.run(bubble.key, bubble.value);
-                        global
-                            .prepare("INSERT INTO composerHeaders(composerId, workspaceId, createdAt, lastUpdatedAt, isArchived, isSubagent, recency, checkpointAt, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)")
-                            .run(header.composerId, header.workspaceId, header.createdAt, header.lastUpdatedAt, header.isArchived, header.isSubagent, header.recency, header.checkpointAt ?? null, header.value);
-                    }
-                    global
-                        .prepare("INSERT OR REPLACE INTO workspace_db.ItemTable(key, value) VALUES ('composer.composerData', ?)")
-                        .run(workspaceIndex);
-                    global.exec("COMMIT");
-                    global.close();
-                    return ok(undefined);
-                }
-                catch (error) {
-                    try {
-                        global.exec("ROLLBACK");
-                    }
-                    catch { }
-                    global.close();
-                    return err(error);
-                }
-            }
-            catch (error) {
-                return err(error);
-            }
-        })();
-        return applied.ok
-            ? ok({ backups })
-            : err(cliErr({
-                what: "Cursor takeover rolled back before completion",
-                why: causeOf(applied.error),
-                path: backups.join(" and "),
-                remedy: "keep the backups, confirm Cursor is closed, and retry; no existing conversation was overwritten",
-            }));
+        const applied = await applyStaged(paths, stagedDirectory, sessionId);
+        if (applied.ok)
+            return ok({ backups });
+        if ("code" in applied.error)
+            return err(applied.error);
+        return err(cliErr("Exec", {
+            code: "cursor.install_rolled_back",
+            what: "Cursor takeover rolled back before completion",
+            cause: applied.error.cause,
+            path: backups.join(" and "),
+            remedy: "keep the backups, confirm Cursor is closed, and retry; no existing conversation was overwritten",
+        }));
     },
     async cleanup(path) {
-        await rm(path, { recursive: true, force: true });
+        void (await files.remove(path, { recursive: true }));
     },
 };
+const stageInto = async (directory, paths, input) => {
+    const globalCopy = join(directory, "global.vscdb");
+    const workspaceCopy = join(directory, "workspace.vscdb");
+    const copied = await Promise.all([
+        copyDatabaseFiles(paths.globalDb, globalCopy),
+        copyDatabaseFiles(paths.workspaceDb, workspaceCopy),
+    ]);
+    const copyFailed = copied.find((c) => !c.ok);
+    if (copyFailed && !copyFailed.ok)
+        return err(files.toError(copyFailed.error, {
+            code: "cursor.copy_failed",
+            what: "could not copy the Cursor databases for staging",
+            remedy: "confirm Cursor is closed and the databases are readable",
+        }));
+    const db = await openDb(globalCopy, false);
+    if (!db.ok)
+        return db;
+    const written = writeStaged(db.value, workspaceCopy, input);
+    db.value.close();
+    return written.ok
+        ? ok(undefined)
+        : err(cliErr("Exec", {
+            code: "cursor.stage_failed",
+            what: "could not stage the Cursor conversation",
+            cause: written.error,
+            remedy: "update Glen and Cursor, then retry",
+        }));
+};
 export { cursorStore };
 //# sourceMappingURL=cursor-store.js.map