theclawbay 0.5.1 → 0.6.2

package/dist/lib/codex-history-migration.js

@@ -3,12 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConversationScope = buildConversationScope;
 exports.migrateSessionProviders = migrateSessionProviders;
 exports.migrateStateDbProviders = migrateStateDbProviders;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
+// Rough IO model for the "~time" labels. Each session is read and, when it
+// carries a provider tag we neutralize, rewritten — so budget ~1.4x its bytes,
+// plus a small per-file syscall overhead. Deliberately conservative.
+const MIGRATION_BYTES_PER_SEC = 45 * 1024 * 1024;
+const MIGRATION_PER_FILE_SECONDS = 0.004;
+function estimateMigrationSeconds(count, bytes) {
+    if (count <= 0)
+        return 0;
+    return (bytes * 1.4) / MIGRATION_BYTES_PER_SEC + count * MIGRATION_PER_FILE_SECONDS;
+}
 function resolvePythonCommand() {
     const candidates = [
         { command: "python3", args: ["-c", "import sqlite3"] },
@@ -26,16 +37,6 @@ function resolvePythonCommand() {
     }
     return null;
 }
-function renderProgressBar(current, total) {
-    if (total <= 0)
-        return "";
-    const width = 24;
-    const ratio = Math.max(0, Math.min(1, current / total));
-    const filled = Math.round(width * ratio);
-    return `[${"#".repeat(filled)}${"-".repeat(width - filled)}] ${Math.round(ratio * 100)
-        .toString()
-        .padStart(3, " ")}%`;
-}
 function inferRolloutUpdatedAt(source) {
     const lines = source.split(/\r?\n/);
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -84,6 +85,51 @@ async function listSessionRollouts(root) {
     await walk(root);
     return results;
 }
+// Newest-first rollout paths. Codex names sessions
+// `rollout-<ISO timestamp>-<uuid>.jsonl` inside sessions/YYYY/MM/DD/, so a
+// descending lexicographic sort is chronological without statting every file.
+function sortNewestFirst(paths) {
+    return [...paths].sort((a, b) => (a < b ? 1 : a > b ? -1 : 0));
+}
+async function statCandidates(paths) {
+    const out = [];
+    for (const p of paths) {
+        try {
+            const stats = await promises_1.default.stat(p);
+            out.push({ path: p, size: stats.size, mtimeMs: stats.mtimeMs });
+        }
+        catch {
+            // ignore transient missing file / race
+        }
+    }
+    return out;
+}
+// Inspect the local Codex session store and produce the pickable scope tiers
+// (Last 10 / 30 / 100 / All) with per-tier time estimates. Only a bounded
+// sample is statted so this stays instant even for huge histories.
+async function buildConversationScope(codexHome) {
+    const sessionsRoot = node_path_1.default.join(codexHome, "sessions");
+    const paths = sortNewestFirst(await listSessionRollouts(sessionsRoot));
+    const total = paths.length;
+    const sampleSize = Math.min(total, 100);
+    const sample = await statCandidates(paths.slice(0, sampleSize));
+    const sampledBytes = sample.reduce((sum, candidate) => sum + candidate.size, 0);
+    const avgSize = sample.length > 0 ? sampledBytes / sample.length : 0;
+    const bytesForCount = (count) => {
+        if (count <= sample.length) {
+            return sample.slice(0, count).reduce((sum, candidate) => sum + candidate.size, 0);
+        }
+        return sampledBytes + avgSize * (count - sample.length);
+    };
+    const options = [];
+    for (const limit of [10, 30, 100]) {
+        if (total <= limit)
+            break; // a tier that already covers everything is just "All"
+        options.push({ limit, count: limit, estSeconds: estimateMigrationSeconds(limit, bytesForCount(limit)) });
+    }
+    options.push({ limit: null, count: total, estSeconds: estimateMigrationSeconds(total, bytesForCount(total)) });
+    return { total, paths, options };
+}
 async function readMigrationState(migrationStateFile) {
     try {
         const raw = await promises_1.default.readFile(migrationStateFile, "utf8");
@@ -126,27 +172,45 @@ async function computeSessionSnapshot(files) {
 }
 async function migrateSessionProviders(params) {
     const sessionsRoot = node_path_1.default.join(params.codexHome, "sessions");
-    const files = await listSessionRollouts(sessionsRoot);
-    const snapshot = await computeSessionSnapshot(files);
-    const previousState = await readMigrationState(params.migrationStateFile);
-    if (previousState &&
-        previousState.fileCount === snapshot.fileCount &&
-        previousState.maxMtimeMs === snapshot.maxMtimeMs) {
-        return { scanned: 0, rewritten: 0, skipped: 0, retimed: 0, fastSkipped: true };
+    const scoped = Array.isArray(params.files);
+    const files = scoped ? params.files : await listSessionRollouts(sessionsRoot);
+    // The mtime/count fast-skip only makes sense for a full pass — a bounded
+    // subset should always run so a user who picked "Last 30" isn't told there's
+    // nothing to do just because a prior full pass recorded the snapshot.
+    if (!scoped) {
+        const snapshot = await computeSessionSnapshot(files);
+        const previousState = await readMigrationState(params.migrationStateFile);
+        if (previousState &&
+            previousState.fileCount === snapshot.fileCount &&
+            previousState.maxMtimeMs === snapshot.maxMtimeMs) {
+            return { scanned: 0, rewritten: 0, skipped: 0, retimed: 0, fastSkipped: true };
+        }
     }
     let rewritten = 0;
     let skipped = 0;
     let retimed = 0;
-    const useProgress = process.stdout.isTTY && files.length > 0;
-    const drawProgress = (current) => {
-        if (!useProgress)
+    const startedAt = Date.now();
+    let lastEmit = 0;
+    const emit = (processed, currentFile) => {
+        if (!params.onProgress)
             return;
-        const bar = renderProgressBar(current, files.length);
-        process.stdout.write(`\rMigrating conversations ${current}/${files.length} ${bar}`);
-        if (current >= files.length)
-            process.stdout.write("\n");
+        const now = Date.now();
+        if (processed < files.length && now - lastEmit < 60)
+            return; // throttle repaints
+        lastEmit = now;
+        const elapsedMs = now - startedAt;
+        const perFile = processed > 0 ? elapsedMs / processed : 0;
+        const etaSeconds = perFile > 0 ? (perFile * (files.length - processed)) / 1000 : 0;
+        params.onProgress({
+            processed,
+            total: files.length,
+            rewritten,
+            elapsedMs,
+            etaSeconds,
+            currentFile,
+        });
     };
-    drawProgress(0);
+    emit(0, "");
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         let source = "";
@@ -157,7 +221,7 @@ async function migrateSessionProviders(params) {
         }
         catch {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         const desiredMtime = inferRolloutUpdatedAt(source) ?? originalStats.mtime;
@@ -177,14 +241,14 @@ async function migrateSessionProviders(params) {
         if (!source.trim()) {
             skipped++;
             await maybeRetainMtime();
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         const lines = source.split(/\r?\n/);
         const firstNonEmptyIndex = lines.findIndex((line) => line.trim().length > 0);
         if (firstNonEmptyIndex < 0) {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         let parsed;
@@ -193,29 +257,29 @@ async function migrateSessionProviders(params) {
         }
         catch {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         if ((parsed.type ?? "") !== "session_meta") {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         const payload = parsed.payload;
         if (!payload || typeof payload !== "object") {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         const currentProvider = payload.model_provider;
         if (typeof currentProvider !== "string") {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         if (!params.neutralizeSources.has(currentProvider)) {
             skipped++;
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         // Remove explicit provider tag so the same thread stays visible across provider contexts.
@@ -225,19 +289,24 @@ async function migrateSessionProviders(params) {
         if (next === source) {
             skipped++;
             await maybeRetainMtime();
-            drawProgress(i + 1);
+            emit(i + 1, file);
             continue;
         }
         await promises_1.default.writeFile(file, next, "utf8");
         await maybeRetainMtime();
         rewritten++;
-        drawProgress(i + 1);
+        emit(i + 1, file);
+    }
+    // Only record the fast-skip snapshot after a full pass; a bounded subset
+    // hasn't seen every session, so it must not claim the whole store is done.
+    if (!scoped) {
+        const snapshot = await computeSessionSnapshot(files);
+        await writeMigrationState(params.migrationStateFile, {
+            version: 1,
+            fileCount: snapshot.fileCount,
+            maxMtimeMs: snapshot.maxMtimeMs,
+        });
     }
-    await writeMigrationState(params.migrationStateFile, {
-        version: 1,
-        fileCount: snapshot.fileCount,
-        maxMtimeMs: snapshot.maxMtimeMs,
-    });
     return { scanned: files.length, rewritten, skipped, retimed, fastSkipped: false };
 }
 async function listStateDbFiles(codexHome) {

package/dist/lib/main-menu.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.promptMainMenu = promptMainMenu;
 const prompts_1 = require("./shared/prompts");
+const app_shell_1 = require("./shared/app-shell");
 const tui_1 = require("./shared/tui");
 const ITEMS = [
     { icon: tui_1.glyph.claw, label: "Set up / connect tools", desc: "Point Codex, Claude & others at The Claw Bay", argv: ["setup"] },
@@ -12,6 +13,7 @@ const ITEMS = [
 async function promptMainMenu() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
         return null;
+    app_shell_1.AppShell.printHeaderOnce("Your relay for Codex, Claude & friends");
     let cursor = 0;
     const quitIndex = ITEMS.length;
     const total = ITEMS.length + 1;
@@ -29,7 +31,8 @@ async function promptMainMenu() {
         return [
             "",
             ...(0, tui_1.renderBox)({
-                title: "The Claw Bay",
+                title: "Home",
+                accent: "coral",
                 lines: [
                     tui_1.tint.dim("What would you like to do?"),
                     "",

package/dist/lib/shared/app-shell.d.ts

@@ -0,0 +1,11 @@
+export type ProgressHandle = {
+    update(message: string): void;
+    succeed(message?: string): void;
+    fail(message?: string): void;
+    stop(): void;
+};
+export declare const AppShell: {
+    printHeaderOnce(subtitle: string): void;
+    progress(enabled: boolean): ProgressHandle;
+    commit(lines: string[]): void;
+};

package/dist/lib/shared/app-shell.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppShell = void 0;
+const tui_1 = require("./tui");
+const NOOP_PROGRESS = {
+    update() { },
+    succeed() { },
+    fail() { },
+    stop() { },
+};
+let headerPrinted = false;
+function createSpinnerProgress() {
+    const stdout = process.stdout;
+    let label = "";
+    let frameIndex = 0;
+    let timer = null;
+    let live = false;
+    const frame = () => tui_1.SPINNER_FRAMES[frameIndex % tui_1.SPINNER_FRAMES.length] ?? tui_1.SPINNER_FRAMES[0];
+    const renderLive = () => stdout.write(`\r\x1b[2K ${tui_1.tint.accent(frame())} ${tui_1.tint.foam(label)}`);
+    const startTimer = () => {
+        if (timer)
+            return;
+        timer = setInterval(() => {
+            frameIndex = (frameIndex + 1) % tui_1.SPINNER_FRAMES.length;
+            renderLive();
+        }, 80);
+        if (typeof timer.unref === "function")
+            timer.unref();
+    };
+    const stopTimer = () => {
+        if (!timer)
+            return;
+        clearInterval(timer);
+        timer = null;
+    };
+    // Freeze the active line into permanent scrollback with a final glyph.
+    const commit = (mark, text) => {
+        stopTimer();
+        stdout.write(`\r\x1b[2K ${mark} ${text}\n`);
+        live = false;
+    };
+    return {
+        update(message) {
+            if (live)
+                commit(tui_1.tint.green(tui_1.glyph.tick), tui_1.tint.foam(label));
+            label = message;
+            live = true;
+            startTimer();
+            renderLive();
+        },
+        succeed(message) {
+            // Finalize the active step under its own name, then add the headline —
+            // never rename the last step to the summary text.
+            if (live)
+                commit(tui_1.tint.green(tui_1.glyph.tick), tui_1.tint.foam(label));
+            if (message)
+                stdout.write(` ${tui_1.tint.green(tui_1.glyph.tick)} ${tui_1.tint.bold(message)}\n`);
+        },
+        fail(message) {
+            // Mark the step that actually failed with its own name.
+            if (live)
+                commit(tui_1.tint.red(tui_1.glyph.cross), tui_1.tint.red(label));
+            if (message)
+                stdout.write(` ${tui_1.tint.red(tui_1.glyph.cross)} ${tui_1.tint.red(message)}\n`);
+        },
+        stop() {
+            if (live)
+                commit(tui_1.tint.green(tui_1.glyph.tick), tui_1.tint.foam(label));
+        },
+    };
+}
+exports.AppShell = {
+    // Print the brand lockup a single time per process. The menu and every
+    // command call this; only the first one actually paints, so launching setup
+    // from the menu never double-stamps the header.
+    printHeaderOnce(subtitle) {
+        if (headerPrinted)
+            return;
+        headerPrinted = true;
+        if (!process.stdout.isTTY)
+            return;
+        process.stdout.write(`\n${(0, tui_1.banner)(subtitle)}\n\n`);
+    },
+    // A growing, persistent checklist backed by a single animated line.
+    progress(enabled) {
+        if (!enabled || !process.stdout.isTTY)
+            return NOOP_PROGRESS;
+        return createSpinnerProgress();
+    },
+    // Commit standalone lines straight into scrollback (used by summaries and
+    // one-off notices) so they share the shell's left-gutter rhythm.
+    commit(lines) {
+        for (const line of lines)
+            process.stdout.write(`${line}\n`);
+    },
+};

package/dist/lib/shared/prompts.d.ts

@@ -1,5 +1,13 @@
 import { SetupClient, SetupClientId } from "./client-registry";
 import { ConfiguredModelSelection, ModelResolution } from "./models";
+import { ConversationScopeOption } from "../codex-history-migration";
+export type ConversationScopeChoice = {
+    limit: number | null;
+} | null;
+export declare function promptConversationScope(scope: {
+    total: number;
+    options: ConversationScopeOption[];
+}): Promise<ConversationScopeChoice>;
 export type SetupAuthMethod = "device-session" | "api-key";
 export declare function promptAuthMethod(): Promise<SetupAuthMethod>;
 export declare function promptApiKey(): Promise<string>;

package/dist/lib/shared/prompts.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptConversationScope = promptConversationScope;
 exports.promptAuthMethod = promptAuthMethod;
 exports.promptApiKey = promptApiKey;
 exports.formatSetupClientLabel = formatSetupClientLabel;
@@ -17,6 +18,80 @@ const promises_1 = require("node:readline/promises");
 const fsx_1 = require("./fsx");
 const models_1 = require("./models");
 const tui_1 = require("./tui");
+// Ask how much Codex history to convert. Every tier shows a count and a time
+// estimate up front, so nobody unknowingly kicks off an hours-long full pass —
+// the runaway that used to look like a hang. "Skip" is always first, and the
+// smallest bounded tier is preselected as the safe default.
+async function promptConversationScope(scope) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || scope.total === 0)
+        return null;
+    const items = [
+        { limit: 0, label: "Skip for now", hint: "Leave existing Codex history untouched", recommended: false },
+    ];
+    // Preselect the first bounded tier (e.g. "Last 10/30") — fast and safe.
+    const firstBounded = scope.options.find((option) => option.limit !== null)?.limit ?? null;
+    for (const option of scope.options) {
+        const isAll = option.limit === null;
+        const label = isAll ? `All ${(0, tui_1.formatCount)(option.count)} conversations` : `Last ${option.limit} conversations`;
+        const est = `~${(0, tui_1.formatEta)(option.estSeconds)}`;
+        const hint = isAll
+            ? `${(0, tui_1.formatCount)(option.count)} total · ${est}${option.estSeconds > 120 ? " — this can take a while" : ""}`
+            : `${est} to convert`;
+        items.push({ limit: option.limit, label, hint, recommended: option.limit === firstBounded });
+    }
+    let cursor = Math.max(0, items.findIndex((item) => item.recommended));
+    if (cursor < 0)
+        cursor = 0;
+    const render = () => {
+        const rows = items.map((item, index) => {
+            const active = index === cursor;
+            const pointer = active ? tui_1.tint.accentBold(tui_1.glyph.pointer) : " ";
+            const mark = active ? tui_1.tint.accent(tui_1.glyph.radioOn) : tui_1.tint.gray(tui_1.glyph.radioOff);
+            const label = active ? tui_1.tint.accentBold(item.label) : tui_1.tint.foam(item.label);
+            const badge = item.recommended ? `  ${tui_1.tint.sea("recommended")}` : "";
+            const body = `${pointer} ${mark} ${label}${badge}`;
+            const detail = tui_1.tint.dim(`— ${item.hint}`);
+            const width = (0, tui_1.terminalColumns)() - 6;
+            const pad = Math.max(1, width - (0, tui_1.visibleWidth)(body) - (0, tui_1.visibleWidth)(detail));
+            return `${body}${" ".repeat(pad)}${detail}`;
+        });
+        return [
+            "",
+            ...(0, tui_1.renderBox)({
+                title: "Convert old Codex conversations?",
+                accent: "coral",
+                lines: [
+                    tui_1.tint.dim("Keeps past threads visible under The Claw Bay. Newest conversations are converted first."),
+                    "",
+                    ...rows,
+                ],
+                footer: (0, tui_1.keyHints)([
+                    ["↑↓", "move"],
+                    ["enter", "select"],
+                ]),
+            }),
+        ];
+    };
+    return runKeyLoop({
+        render,
+        onKey: (key, finish, repaint) => {
+            if (key.name === "up" || key.name === "k") {
+                cursor = (cursor - 1 + items.length) % items.length;
+                repaint();
+                return;
+            }
+            if (key.name === "down" || key.name === "j") {
+                cursor = (cursor + 1) % items.length;
+                repaint();
+                return;
+            }
+            if (key.name === "return" || key.name === "enter") {
+                const chosen = items[cursor];
+                finish(chosen.limit === 0 ? null : { limit: chosen.limit });
+            }
+        },
+    });
+}
 // Ask how the user wants to authenticate this machine. Browser sign-in is the
 // recommended default; an API key is offered for people who prefer to paste one.
 async function promptAuthMethod() {

package/dist/lib/shared/tui.d.ts

@@ -1,9 +1,14 @@
 export declare const tint: {
     accent: (text: string) => string;
     accentBold: (text: string) => string;
+    sea: (text: string) => string;
+    seaBold: (text: string) => string;
+    ink: (text: string) => string;
+    foam: (text: string) => string;
     bold: (text: string) => string;
     dim: (text: string) => string;
     gray: (text: string) => string;
+    line: (text: string) => string;
     green: (text: string) => string;
     yellow: (text: string) => string;
     red: (text: string) => string;
@@ -21,21 +26,49 @@ export declare const glyph: {
     readonly cross: "✗";
     readonly bullet: "·";
     readonly claw: "🦞";
+    readonly wave: "≈";
+    readonly diamond: "◆";
+    readonly diamondOpen: "◇";
+    readonly arrow: "→";
+    readonly barFull: "█";
+    readonly barEmpty: "░";
+    readonly dotActive: "◈";
 };
+export declare const SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 export declare function visibleWidth(text: string): number;
 export declare function terminalColumns(): number;
 export declare function truncateVisible(text: string, maxWidth: number): string;
-export type BoxLine = string;
+export declare function padVisible(text: string, width: number): string;
+export type BoxAccent = "coral" | "sea" | "danger" | "line";
 export declare function renderBox(params: {
     title?: string;
     lines: string[];
     footer?: string;
     width?: number;
+    accent?: BoxAccent;
 }): string[];
+export declare function brandWordmark(text?: string): string;
 export declare function banner(subtitle: string): string;
+export declare function gauge(params: {
+    value: number;
+    max: number;
+    width?: number;
+    color?: (text: string) => string;
+}): string;
+export declare function formatEta(seconds: number): string;
+export declare function formatCount(n: number): string;
+export declare function formatBytes(bytes: number): string;
+export type StepState = "pending" | "active" | "done" | "failed" | "skipped";
+export type RailStep = {
+    label: string;
+    state: StepState;
+    detail?: string;
+};
+export declare function renderStepRail(steps: RailStep[], spinnerFrame: string): string[];
 export declare function createFramePainter(stdout: NodeJS.WriteStream): {
     paint: (lines: string[]) => void;
     clear: () => void;
+    commit: (lines: string[]) => void;
     done: () => void;
 };
 export declare function keyHints(pairs: Array<[string, string]>): string;