youmd 0.10.2 → 0.12.0

package/dist/commands/session.js

@@ -0,0 +1,895 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCodexSessions = scanCodexSessions;
+exports.scanClaudeSessions = scanClaudeSessions;
+exports.sessionListCommand = sessionListCommand;
+exports.sessionPublishCommand = sessionPublishCommand;
+exports.sessionResumeCommand = sessionResumeCommand;
+exports.sessionCloseCommand = sessionCloseCommand;
+exports.sessionCommand = sessionCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../lib/api");
+const config_1 = require("../lib/config");
+const render_1 = require("../lib/render");
+const machine_identity_1 = require("../lib/machine-identity");
+const sessionCheckpoint_1 = require("../lib/sessionCheckpoint");
+const redact_1 = require("../lib/redact");
+const sessionHandoff_1 = require("../lib/sessionHandoff");
+const ACCENT = chalk_1.default.hex("#C46A3A");
+const DIM = chalk_1.default.dim;
+const GREEN = chalk_1.default.hex("#4CAF50");
+// Synced coding-agent sessions (request 176): publish bounded, secret-safe
+// snapshots of the Codex/Claude Code sessions running on THIS machine so any
+// other paired machine can `you session list` and `you session resume` them.
+// Raw transcripts never leave this machine — resume rides on repo sync plus
+// the runtime's own local/session storage; what syncs is the map, not the
+// territory.
+const MAX_LOCAL_SESSIONS = 12;
+const FRESH_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_TAIL_BYTES = 128 * 1024;
+const MAX_TAIL_ROWS = 120;
+function relativeTime(ts) {
+    const s = Math.floor((Date.now() - ts) / 1000);
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+function safeReadFirstJsonLines(filePath, maxLines = 8) {
+    try {
+        const fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(64 * 1024);
+        const bytes = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        fs.closeSync(fd);
+        const rows = [];
+        for (const line of buffer.toString("utf8", 0, bytes).split("\n").slice(0, maxLines)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                rows.push(parsed);
+            }
+            catch {
+                break; // truncated tail of the read window — fine, we have the head
+            }
+        }
+        return rows;
+    }
+    catch {
+        return [];
+    }
+}
+function safeReadLastJsonLines(filePath, maxBytes = MAX_TAIL_BYTES, maxLines = MAX_TAIL_ROWS) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const size = fs.fstatSync(fd).size;
+        const start = Math.max(0, size - maxBytes);
+        const buffer = Buffer.alloc(Math.min(size, maxBytes));
+        const bytes = fs.readSync(fd, buffer, 0, buffer.length, start);
+        let lines = buffer.toString("utf8", 0, bytes).split("\n");
+        // A non-zero offset normally begins halfway through a JSON row.
+        if (start > 0)
+            lines = lines.slice(1);
+        const rows = [];
+        for (const line of lines.slice(-maxLines)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    rows.push(parsed);
+                }
+            }
+            catch {
+                // Concurrently-appended or partial rows are not portable evidence.
+            }
+        }
+        return rows;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // The tail is optional local evidence.
+            }
+        }
+    }
+}
+const CONTEXT_LABELS = [
+    { pattern: "now|current|working\\s+on", bucket: "now" },
+    { pattern: "recent|completed|done|shipped", bucket: "recent" },
+    { pattern: "next|up\\s+next|continue|todo", bucket: "next" },
+    { pattern: "blockers?|blocked", bucket: "blockers" },
+    { pattern: "decisions?|decided", bucket: "decisions" },
+];
+function textParts(content) {
+    if (typeof content === "string")
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((part) => {
+        if (!part || typeof part !== "object")
+            return [];
+        const item = part;
+        // Only human-visible message text is admissible. Tool calls/results,
+        // reasoning, images, and runtime metadata are ignored.
+        if (!["text", "input_text", "output_text"].includes(String(item.type)))
+            return [];
+        return typeof item.text === "string" ? [item.text] : [];
+    });
+}
+function codexPortableTexts(row) {
+    const payload = row.payload && typeof row.payload === "object"
+        ? row.payload
+        : undefined;
+    if (!payload)
+        return [];
+    if (payload.type === "message" && ["user", "assistant"].includes(String(payload.role))) {
+        return textParts(payload.content).map((text) => ({
+            text,
+            summary: false,
+            userAuthored: payload.role === "user",
+        }));
+    }
+    if (row.type === "event_msg"
+        && ["agent_message", "task_summary"].includes(String(payload.type))
+        && typeof payload.message === "string") {
+        return [{
+                text: payload.message,
+                summary: payload.type === "task_summary",
+                userAuthored: false,
+            }];
+    }
+    if (payload.type === "task_summary" && typeof payload.summary === "string") {
+        return [{ text: payload.summary, summary: true, userAuthored: false }];
+    }
+    return [];
+}
+function claudePortableTexts(row) {
+    if (row.isMeta === true)
+        return [];
+    if (row.type === "summary" && typeof row.summary === "string") {
+        return [{ text: row.summary, summary: true, userAuthored: false }];
+    }
+    if (!["user", "assistant"].includes(String(row.type)))
+        return [];
+    const message = row.message && typeof row.message === "object"
+        ? row.message
+        : undefined;
+    if (!message || !["user", "assistant"].includes(String(message.role)))
+        return [];
+    return textParts(message.content).map((text) => ({
+        text,
+        summary: false,
+        userAuthored: message.role === "user",
+    }));
+}
+function safePortableLine(value, nativeSessionId) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return null;
+    try {
+        const parsed = JSON.parse(normalized);
+        if (parsed && typeof parsed === "object")
+            return null;
+    }
+    catch {
+        // Ordinary human-authored text is the expected portable summary.
+    }
+    if (nativeSessionId && normalized.includes(nativeSessionId))
+        return null;
+    if (/(?:^|\s)(?:\/Users\/|\/home\/|\/var\/|\/tmp\/|~\/|[A-Za-z]:\\)/.test(normalized)
+        || /(?:^|\s)\.env(?:\.local)?(?:\s|$)/i.test(normalized)
+        || /\b[A-Z][A-Z0-9_]{2,}\s*=/.test(normalized)) {
+        return null;
+    }
+    const redacted = (0, redact_1.redactText)(normalized);
+    // A whole prompt/line containing a secret-like value is excluded instead
+    // of publishing a partially-redacted continuation with ambiguous meaning.
+    if (redacted.hits > 0)
+        return null;
+    return redacted.text
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi, "[opaque-ref]")
+        .slice(0, 500);
+}
+function extractPortableContext(rows, runtime, nativeSessionId) {
+    const result = {
+        recent: [],
+        next: [],
+        blockers: [],
+        decisions: [],
+    };
+    const texts = rows.flatMap(runtime === "codex" ? codexPortableTexts : claudePortableTexts);
+    let latestSummary;
+    for (const entry of texts) {
+        // A user prompt containing any recognized secret/PII shape is treated as
+        // indivisible and omitted wholesale, even if another line looks harmless.
+        if (entry.userAuthored && (0, redact_1.redactText)(entry.text).hits > 0)
+            continue;
+        if (entry.summary) {
+            const summary = safePortableLine(entry.text, nativeSessionId);
+            if (summary)
+                latestSummary = summary;
+        }
+        for (const rawLine of entry.text.split(/\r?\n/)) {
+            const line = rawLine.replace(/^\s*(?:[-*]\s*|#{1,6}\s*)?/, "");
+            for (const label of CONTEXT_LABELS) {
+                const match = line.match(new RegExp(`^(?:${label.pattern})\\s*:\\s*(.+)$`, "i"));
+                if (!match)
+                    continue;
+                const safe = safePortableLine(match[1], nativeSessionId);
+                if (!safe)
+                    break;
+                if (label.bucket === "now")
+                    result.now = safe;
+                else
+                    result[label.bucket].push(safe);
+                break;
+            }
+        }
+    }
+    if (!result.now && latestSummary)
+        result.now = latestSummary;
+    for (const bucket of ["recent", "next", "blockers", "decisions"]) {
+        result[bucket] = [...new Set(result[bucket])].slice(-8);
+    }
+    return result;
+}
+function gitBranchFor(workspacePath) {
+    if (!workspacePath)
+        return undefined;
+    try {
+        return (0, child_process_1.execSync)("git rev-parse --abbrev-ref HEAD", {
+            cwd: workspacePath,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 3000,
+        })
+            .toString()
+            .trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function gitOutput(workspacePath, args) {
+    try {
+        return (0, child_process_1.execSync)(`git ${args.join(" ")}`, {
+            cwd: workspacePath,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 3000,
+        })
+            .toString()
+            .trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function canonicalRepoRef(remote) {
+    if (!remote)
+        return undefined;
+    const withoutCredentials = remote.replace(/^(https?:\/\/)[^/@]+@/i, "$1");
+    const normalized = withoutCredentials
+        .replace(/^git@([^:]+):/i, "$1/")
+        .replace(/^ssh:\/\/git@/i, "")
+        .replace(/^https?:\/\//i, "")
+        .replace(/\.git$/i, "")
+        .replace(/\/+$/, "");
+    if (!normalized || normalized.startsWith("/"))
+        return undefined;
+    return `repo:${normalized.toLowerCase()}`;
+}
+function inspectGitCheckpoint(workspacePath, machineRef) {
+    if (!workspacePath)
+        return {};
+    const branch = gitBranchFor(workspacePath);
+    const lastCommit = gitOutput(workspacePath, ["rev-parse", "HEAD"]);
+    const status = gitOutput(workspacePath, ["status", "--porcelain=v1"]) ?? "";
+    const dirtyFiles = status ? status.split("\n").filter(Boolean).length : 0;
+    const statusDigest = status ? `sha256:${(0, sessionCheckpoint_1.stableCheckpointHash)(status)}` : undefined;
+    const upstreamCounts = gitOutput(workspacePath, [
+        "rev-list",
+        "--left-right",
+        "--count",
+        "@{upstream}...HEAD",
+    ]);
+    const [behindRaw, aheadRaw] = upstreamCounts?.split(/\s+/) ?? [];
+    const behind = Number.parseInt(behindRaw ?? "", 10);
+    const ahead = Number.parseInt(aheadRaw ?? "", 10);
+    const repoRef = canonicalRepoRef(gitOutput(workspacePath, ["remote", "get-url", "origin"]));
+    const topLevel = gitOutput(workspacePath, ["rev-parse", "--show-toplevel"]);
+    const worktreeRef = topLevel
+        ? `worktree:${(0, sessionCheckpoint_1.stableCheckpointHash)({ machineRef, repoRef, branch, topLevel })}`
+        : undefined;
+    const gitState = {
+        dirtyFiles,
+        ...(Number.isFinite(ahead) ? { ahead } : {}),
+        ...(Number.isFinite(behind) ? { behind } : {}),
+        ...(lastCommit ? { lastCommit } : {}),
+        ...(statusDigest ? { statusDigest } : {}),
+    };
+    return { branch, repoRef, worktreeRef, gitState };
+}
+function hashFile(filePath) {
+    const hash = (0, crypto_1.createHash)("sha256");
+    const fd = fs.openSync(filePath, "r");
+    const buffer = Buffer.alloc(64 * 1024);
+    try {
+        let position = 0;
+        while (true) {
+            const bytes = fs.readSync(fd, buffer, 0, buffer.length, position);
+            if (bytes === 0)
+                break;
+            hash.update(buffer.subarray(0, bytes));
+            position += bytes;
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+function portableMachineRef(hostname, physicalMachineRef) {
+    return physicalMachineRef || `machine:${(0, sessionCheckpoint_1.stableCheckpointHash)(hostname.toLowerCase())}`;
+}
+function portableProjectSlug(cwd) {
+    if (!cwd)
+        return undefined;
+    const slug = path.basename(cwd)
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "")
+        .slice(0, 80)
+        .replace(/[^a-z0-9]+$/g, "");
+    return /^[a-z0-9](?:[a-z0-9._-]{0,78}[a-z0-9])?$/.test(slug)
+        ? slug
+        : undefined;
+}
+function listRecentFiles(dir, suffix, limit) {
+    const out = [];
+    const walk = (current, depth) => {
+        if (depth > 4 || out.length > limit * 8)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                walk(full, depth + 1);
+            }
+            else if (entry.isFile() && entry.name.endsWith(suffix)) {
+                try {
+                    const mtime = fs.statSync(full).mtimeMs;
+                    if (Date.now() - mtime <= FRESH_WINDOW_MS)
+                        out.push({ file: full, mtime });
+                }
+                catch {
+                    /* unreadable file — skip */
+                }
+            }
+        }
+    };
+    walk(dir, 0);
+    return out
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, limit)
+        .map((entry) => entry.file);
+}
+// Codex rollouts: ~/.codex/sessions/YYYY/MM/DD/rollout-...-<uuid>.jsonl
+function scanCodexSessions(hostname, root = path.join(os.homedir(), ".codex", "sessions"), physicalMachineRef, handoffBaseDir) {
+    if (!fs.existsSync(root))
+        return [];
+    const sessions = [];
+    for (const file of listRecentFiles(root, ".jsonl", MAX_LOCAL_SESSIONS)) {
+        const head = safeReadFirstJsonLines(file);
+        const meta = head.find((row) => row.payload && typeof row.payload === "object");
+        const payload = (meta?.payload ?? head[0] ?? {});
+        const id = (typeof payload.id === "string" && payload.id) ||
+            path.basename(file).replace(/\.jsonl$/, "").split("-").slice(-5).join("-");
+        const cwd = typeof payload.cwd === "string" ? payload.cwd : undefined;
+        let mtime = Date.now();
+        let startedAt = mtime;
+        try {
+            const stat = fs.statSync(file);
+            mtime = stat.mtimeMs;
+            startedAt = stat.birthtimeMs > 0 ? stat.birthtimeMs : stat.ctimeMs;
+        }
+        catch {
+            /* fall back to now */
+        }
+        const machineRef = portableMachineRef(hostname, physicalMachineRef);
+        const projectSlug = portableProjectSlug(cwd);
+        const git = inspectGitCheckpoint(cwd, machineRef);
+        const title = cwd ? `codex @ ${path.basename(cwd)}` : "codex session";
+        const resumeHint = `codex resume ${id}`;
+        const context = extractPortableContext(safeReadLastJsonLines(file), "codex", id);
+        const continuity = (0, sessionHandoff_1.consumeSessionHandoffBinding)({
+            runtime: "codex",
+            projectSlug,
+            repoRef: git.repoRef,
+            workspacePath: cwd,
+            localSessionAnchor: id,
+            sessionStartedAt: startedAt,
+            baseDir: handoffBaseDir,
+        });
+        const checkpoint = (0, sessionCheckpoint_1.adaptCodexCheckpoint)({
+            machineRef,
+            localSessionAnchor: id,
+            sessionRef: continuity?.sessionRef,
+            previousCheckpointRef: continuity?.previousCheckpointRef,
+            projectRef: projectSlug ? `project:${projectSlug}` : undefined,
+            projectSlug,
+            sourceRevision: hashFile(file),
+            branch: git.branch,
+            worktreeRef: git.worktreeRef,
+            repoRef: git.repoRef,
+            now: context.now ?? title,
+            recent: context.recent,
+            next: context.next.length > 0
+                ? context.next
+                : ["Continue from the latest portable checkpoint."],
+            blockers: context.blockers,
+            decisions: context.decisions,
+            gitState: git.gitState,
+            eventAt: Math.round(mtime),
+            nativeResumeHint: resumeHint,
+        }).checkpoint;
+        sessions.push({
+            sessionKey: `codex:${hostname}:${id}`,
+            runtime: "codex",
+            nativeSessionId: id,
+            workspacePath: cwd,
+            projectSlug,
+            branch: git.branch,
+            title,
+            resumeHint,
+            lastEventAt: Math.round(mtime),
+            checkpoint,
+        });
+    }
+    return sessions;
+}
+// Claude Code transcripts: ~/.claude/projects/<workspace-slug>/<uuid>.jsonl
+function scanClaudeSessions(hostname, root = path.join(os.homedir(), ".claude", "projects"), physicalMachineRef, handoffBaseDir) {
+    if (!fs.existsSync(root))
+        return [];
+    const sessions = [];
+    for (const file of listRecentFiles(root, ".jsonl", MAX_LOCAL_SESSIONS)) {
+        const id = path.basename(file).replace(/\.jsonl$/, "");
+        const head = safeReadFirstJsonLines(file);
+        const withCwd = head.find((row) => typeof row.cwd === "string");
+        const cwd = withCwd ? withCwd.cwd : undefined;
+        let mtime = Date.now();
+        let startedAt = mtime;
+        try {
+            const stat = fs.statSync(file);
+            mtime = stat.mtimeMs;
+            startedAt = stat.birthtimeMs > 0 ? stat.birthtimeMs : stat.ctimeMs;
+        }
+        catch {
+            /* fall back to now */
+        }
+        const machineRef = portableMachineRef(hostname, physicalMachineRef);
+        const projectSlug = portableProjectSlug(cwd);
+        const git = inspectGitCheckpoint(cwd, machineRef);
+        const title = cwd ? `claude @ ${path.basename(cwd)}` : "claude code session";
+        const resumeHint = `claude --resume ${id}`;
+        const context = extractPortableContext(safeReadLastJsonLines(file), "claude-code", id);
+        const continuity = (0, sessionHandoff_1.consumeSessionHandoffBinding)({
+            runtime: "claude-code",
+            projectSlug,
+            repoRef: git.repoRef,
+            workspacePath: cwd,
+            localSessionAnchor: id,
+            sessionStartedAt: startedAt,
+            baseDir: handoffBaseDir,
+        });
+        const checkpoint = (0, sessionCheckpoint_1.adaptClaudeCheckpoint)({
+            machineRef,
+            localSessionAnchor: id,
+            sessionRef: continuity?.sessionRef,
+            previousCheckpointRef: continuity?.previousCheckpointRef,
+            projectRef: projectSlug ? `project:${projectSlug}` : undefined,
+            projectSlug,
+            sourceRevision: hashFile(file),
+            branch: git.branch,
+            worktreeRef: git.worktreeRef,
+            repoRef: git.repoRef,
+            now: context.now ?? title,
+            recent: context.recent,
+            next: context.next.length > 0
+                ? context.next
+                : ["Continue from the latest portable checkpoint."],
+            blockers: context.blockers,
+            decisions: context.decisions,
+            gitState: git.gitState,
+            eventAt: Math.round(mtime),
+            nativeResumeHint: resumeHint,
+        }).checkpoint;
+        sessions.push({
+            sessionKey: `claude-code:${hostname}:${id}`,
+            runtime: "claude-code",
+            nativeSessionId: id,
+            workspacePath: cwd,
+            projectSlug,
+            branch: git.branch,
+            title,
+            resumeHint,
+            lastEventAt: Math.round(mtime),
+            checkpoint,
+        });
+    }
+    return sessions;
+}
+function requireAuth(json) {
+    if ((0, config_1.isAuthenticated)())
+        return true;
+    if (json) {
+        console.log(JSON.stringify({ ok: false, error: "not_authenticated" }));
+    }
+    else {
+        console.log("");
+        console.log(chalk_1.default.yellow("  not authenticated"));
+        console.log("  run " + chalk_1.default.cyan("you login") + " first -- sessions sync through your identity.");
+        console.log("");
+    }
+    return false;
+}
+function statusBadge(session) {
+    if (session.status === "claimed") {
+        return ACCENT(`claimed by ${session.claimedByHost ?? "?"}`);
+    }
+    if (session.status === "active")
+        return GREEN("active");
+    if (session.status === "checkpointed")
+        return ACCENT("checkpointed");
+    if (session.status === "closed")
+        return DIM("closed");
+    return DIM(session.status);
+}
+function printSession(session, index) {
+    const where = session.projectSlug ?? session.workspacePath ?? "unknown workspace";
+    const branch = session.branch ? DIM(` (${session.branch})`) : "";
+    console.log(`  ${DIM(String(index + 1).padStart(2))}  ${ACCENT(session.runtime.padEnd(11))} ${where}${branch}`);
+    console.log(`      ${DIM("on")} ${session.machineHostname}  ${statusBadge(session)}  ${DIM(relativeTime(session.lastEventAt))}`);
+    if (session.resumeHint) {
+        console.log(`      ${DIM("resume:")} ${chalk_1.default.cyan(session.resumeHint)}`);
+    }
+    console.log(`      ${DIM("key:")} ${DIM(session.sessionKey)}`);
+}
+async function sessionListCommand(options = {}) {
+    if (!requireAuth(options.json))
+        return;
+    const spinner = options.json ? null : new render_1.BrailleSpinner("finding every brain you left running...");
+    spinner?.start();
+    const res = await (0, api_1.listAgentSessions)({
+        status: options.status,
+        machine: options.machine,
+        includeClosed: options.all,
+    });
+    if (!res.ok) {
+        spinner?.fail("could not reach the session ledger");
+        const message = (0, api_1.apiErrorMessage)(res.data) ?? `HTTP ${res.status}`;
+        if (options.json)
+            console.log(JSON.stringify({ ok: false, error: message }));
+        else
+            console.log("  " + chalk_1.default.red(message));
+        return;
+    }
+    const sessions = res.data.sessions;
+    spinner?.stop(`${sessions.length} synced session${sessions.length === 1 ? "" : "s"}`);
+    if (options.json) {
+        console.log(JSON.stringify({ ok: true, sessions }, null, 2));
+        return;
+    }
+    console.log("");
+    if (sessions.length === 0) {
+        console.log("  " + DIM("no synced sessions -- run ") + chalk_1.default.cyan("you session publish") + DIM(" on the machine doing the work"));
+        console.log("");
+        return;
+    }
+    sessions.forEach((session, index) => {
+        printSession(session, index);
+        console.log("");
+    });
+    console.log("  " + DIM("pick one up anywhere: ") + chalk_1.default.cyan("you session resume <key>") + DIM(" -- it claims the session so two machines never fight over it"));
+    console.log("");
+}
+async function sessionPublishCommand(options = {}) {
+    if (!requireAuth(options.json))
+        return;
+    const hostname = os.hostname();
+    const machineRef = (() => {
+        try {
+            return (0, machine_identity_1.readPhysicalMachineKey)() ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const spinner = options.json ? null : new render_1.BrailleSpinner("taking attendance of local coding agents...");
+    spinner?.start();
+    const local = [...scanCodexSessions(hostname, undefined, machineRef), ...scanClaudeSessions(hostname, undefined, machineRef)];
+    const checkpoints = (0, sessionCheckpoint_1.dedupeUnchangedCheckpoints)(local.flatMap((session) => (session.checkpoint ? [session.checkpoint] : [])));
+    const uniqueCheckpointRefs = new Set(checkpoints.map((checkpoint) => checkpoint.checkpointRef));
+    const publishable = local.filter((session) => !session.checkpoint || uniqueCheckpointRefs.delete(session.checkpoint.checkpointRef));
+    if (publishable.length === 0) {
+        spinner?.stop("no fresh local sessions found");
+        if (options.json)
+            console.log(JSON.stringify({ ok: true, published: 0 }));
+        else {
+            console.log("");
+            console.log("  " + DIM("nothing running here in the last 7 days -- codex and claude both quiet"));
+            console.log("");
+        }
+        return;
+    }
+    spinner?.update(`syncing ${publishable.length} session snapshot${publishable.length === 1 ? "" : "s"} to your brain...`);
+    let published = 0;
+    const failures = [];
+    for (const session of publishable) {
+        const res = await (0, api_1.publishAgentSession)({
+            sessionKey: session.checkpoint?.sessionRef ?? session.sessionKey,
+            runtime: session.checkpoint?.runtime ?? session.runtime,
+            machineHostname: hostname,
+            title: session.title,
+            status: "active",
+            checkpoint: session.checkpoint,
+        });
+        if (res.ok)
+            published += 1;
+        else
+            failures.push(`${session.sessionKey}: ${(0, api_1.apiErrorMessage)(res.data) ?? `HTTP ${res.status}`}`);
+    }
+    if (failures.length > 0) {
+        spinner?.fail(`published ${published}/${publishable.length} sessions`);
+    }
+    else {
+        spinner?.stop(`published ${published} session${published === 1 ? "" : "s"} -- resumable from any synced machine`);
+    }
+    if (options.json) {
+        console.log(JSON.stringify({ ok: failures.length === 0, published, failures }, null, 2));
+        return;
+    }
+    for (const failure of failures)
+        console.log("  " + chalk_1.default.red(failure));
+    console.log("");
+}
+async function sessionResumeCommand(sessionKey, options = {}) {
+    if (!requireAuth(options.json))
+        return;
+    if (!sessionKey) {
+        console.log("");
+        console.log("  " + chalk_1.default.yellow("which one?") + DIM(" usage: ") + chalk_1.default.cyan("you session resume <sessionKey>"));
+        console.log("  " + DIM("see keys with ") + chalk_1.default.cyan("you session list"));
+        console.log("");
+        return;
+    }
+    const hostname = os.hostname();
+    const spinner = options.json ? null : new render_1.BrailleSpinner("claiming the session for this machine...");
+    spinner?.start();
+    const res = await (0, api_1.claimAgentSession)({ sessionKey, claimedByHost: hostname });
+    if (!res.ok) {
+        spinner?.fail("claim refused");
+        const message = (0, api_1.apiErrorMessage)(res.data) ?? `HTTP ${res.status}`;
+        if (options.json)
+            console.log(JSON.stringify({ ok: false, error: message }));
+        else
+            console.log("  " + chalk_1.default.red(message));
+        return;
+    }
+    const session = res.data.session;
+    let localMachineRef;
+    try {
+        localMachineRef = (0, machine_identity_1.readPhysicalMachineKey)() ?? undefined;
+    }
+    catch {
+        // Hostname fallback is safe for display routing, never portable identity.
+    }
+    const sameMachine = (0, sessionHandoff_1.isSameMachineSession)({ machineHostname: session.machineHostname, machineRef: session.machineRef }, { hostname, machineRef: localMachineRef });
+    if (sameMachine) {
+        const localSession = [
+            ...scanCodexSessions(hostname, undefined, localMachineRef),
+            ...scanClaudeSessions(hostname, undefined, localMachineRef),
+        ].find((candidate) => candidate.checkpoint?.sessionRef === session.sessionKey
+            || candidate.checkpoint?.checkpointRef === session.checkpoint?.checkpointRef);
+        spinner?.stop("claimed -- this machine owns the resume");
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                local: true,
+                session: {
+                    sessionKey: session.sessionKey,
+                    runtime: session.runtime,
+                    machineHostname: session.machineHostname,
+                    machineRef: session.machineRef,
+                    projectSlug: session.projectSlug,
+                    branch: session.branch,
+                    title: session.title,
+                    contextSummary: session.contextSummary,
+                    status: session.status,
+                    lastEventAt: session.lastEventAt,
+                    checkpoint: session.checkpoint ?? null,
+                    nativeSessionId: null,
+                    workspacePath: null,
+                    resumeHint: null,
+                    secretValuesExposed: false,
+                },
+                localResumeAvailable: Boolean(localSession?.resumeHint),
+                secretValuesExposed: false,
+            }, null, 2));
+            return;
+        }
+        console.log("");
+        console.log("  " + DIM("origin: ") + `${session.machineHostname}`);
+        if (session.branch)
+            console.log("  " + DIM("branch: ") + session.branch);
+        if (session.contextSummary) {
+            console.log("");
+            console.log("  " + DIM("context: ") + session.contextSummary);
+        }
+        console.log("");
+        if (localSession?.resumeHint) {
+            console.log("  " + "next move: " + chalk_1.default.cyan(localSession.resumeHint));
+        }
+        else {
+            console.log("  " + DIM("no local session file matched -- start a fresh agent from the portable checkpoint"));
+        }
+        console.log("");
+        return;
+    }
+    try {
+        if (!session.checkpoint)
+            throw new Error("portable checkpoint is missing");
+        const handoff = (0, sessionHandoff_1.createPortableSessionHandoff)({
+            checkpoint: session.checkpoint,
+            projectDir: process.cwd(),
+        });
+        spinner?.stop("claimed -- portable handoff ready on this machine");
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                local: false,
+                checkpointRef: handoff.checkpointRef,
+                sessionRef: handoff.sessionRef,
+                briefPath: handoff.briefPath,
+                command: handoff.command,
+                expiresAt: handoff.expiresAt,
+                secretValuesExposed: false,
+            }, null, 2));
+            return;
+        }
+        console.log("");
+        console.log("  " + DIM("portable checkpoint: ") + handoff.checkpointRef);
+        console.log("  " + DIM("handoff brief: ") + handoff.briefPath);
+        console.log("");
+        console.log("  " + "start a fresh local session:");
+        console.log("  " + chalk_1.default.cyan(handoff.command));
+        console.log("");
+    }
+    catch (error) {
+        spinner?.fail("claim has no safe portable handoff");
+        const message = error instanceof Error ? error.message : "portable checkpoint is missing or malformed";
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                error: "portable_checkpoint_required",
+                message,
+                secretValuesExposed: false,
+            }));
+        }
+        else {
+            console.log("  " + chalk_1.default.red(message));
+            console.log("  " + DIM("origin-native resume ids are never valid on another machine"));
+            console.log("");
+        }
+    }
+}
+async function sessionCloseCommand(sessionKey, options = {}) {
+    if (!requireAuth(options.json))
+        return;
+    if (!sessionKey) {
+        console.log("");
+        console.log("  " + chalk_1.default.yellow("which one?") + DIM(" usage: ") + chalk_1.default.cyan("you session close <sessionKey>"));
+        console.log("");
+        return;
+    }
+    const spinner = options.json ? null : new render_1.BrailleSpinner("closing the session everywhere...");
+    spinner?.start();
+    const res = await (0, api_1.claimAgentSession)({ sessionKey, close: true });
+    if (!res.ok) {
+        spinner?.fail("close refused");
+        const message = (0, api_1.apiErrorMessage)(res.data) ?? `HTTP ${res.status}`;
+        if (options.json)
+            console.log(JSON.stringify({ ok: false, error: message }));
+        else
+            console.log("  " + chalk_1.default.red(message));
+        return;
+    }
+    spinner?.stop("closed -- off every machine's list");
+    if (options.json)
+        console.log(JSON.stringify({ ok: true, session: res.data.session }, null, 2));
+    console.log("");
+}
+async function sessionCommand(subcommand, args = [], options = {}) {
+    switch (subcommand) {
+        case undefined:
+        case "list":
+            return sessionListCommand(options);
+        case "publish":
+        case "sync":
+            return sessionPublishCommand(options);
+        case "resume":
+        case "claim":
+            return sessionResumeCommand(args[0], options);
+        case "close":
+            return sessionCloseCommand(args[0], options);
+        default:
+            console.log("");
+            console.log("  " + chalk_1.default.yellow(`unknown subcommand: ${subcommand}`));
+            console.log("  " + DIM("try: ") + chalk_1.default.cyan("you session list | publish | resume <key> | close <key>"));
+            console.log("");
+    }
+}
+//# sourceMappingURL=session.js.map