memax-cli 0.1.0-alpha.28 → 0.1.0-alpha.29

package/dist/commands/agent-sessions.js

@@ -0,0 +1,761 @@
+import chalk from "chalk";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { homedir } from "node:os";
+import { getAuthHeaders, getClient } from "../lib/client.js";
+import { getProjectScope, resolveClaudeProjectFolder, resolveProjectScope, normalizeFilePath, } from "../lib/project-context.js";
+import { getOrCreateDeviceID, loadConfig } from "../lib/config.js";
+import { ask, confirmDefault } from "../lib/prompt.js";
+export async function syncAgentSessionsCommand(options = {}) {
+    console.log(chalk.bold("\n  Memax Session Sync\n"));
+    const cwd = process.cwd();
+    const home = homedir();
+    const deviceID = getOrCreateDeviceID();
+    const projectScopeResolution = resolveProjectScope(cwd);
+    const currentProjectScope = projectScopeResolution.scope;
+    const locations = discoverAgentSessions();
+    const localSessions = locations
+        .filter((loc) => existsSync(loc.path))
+        .map((loc) => {
+        const content = readFileSync(loc.path);
+        return {
+            loc,
+            content,
+            hash: createHash("sha256").update(content).digest("hex"),
+            size: statSync(loc.path).size,
+        };
+    });
+    const manifest = localSessions.map((session) => ({
+        agent: session.loc.agent,
+        file_path: session.loc.filePath,
+        scope: session.loc.scope,
+        content_hash: session.hash,
+        local_path: session.loc.path,
+    }));
+    let actions;
+    try {
+        const plan = await getClient().agentSessions.sync({
+            device_id: deviceID,
+            sessions: manifest,
+        });
+        actions = plan.actions;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Sync failed: ${err.message}\n`));
+        return;
+    }
+    if (options.push) {
+        actions = actions.map((a) => a.action === "conflict" ? { ...a, action: "push" } : a);
+    }
+    else if (options.pull) {
+        actions = actions.map((a) => a.action === "conflict" ? { ...a, action: "pull" } : a);
+    }
+    actions = actions.filter((action) => {
+        if (!action.scope.startsWith("project:"))
+            return true;
+        if (action.scope === currentProjectScope)
+            return true;
+        if (action.action === "pull" && action.reason === "cloud_only")
+            return false;
+        return true;
+    });
+    const localByKey = new Map();
+    for (const session of localSessions) {
+        localByKey.set(`${session.loc.agent}|${session.loc.filePath}|${session.loc.scope}`, session);
+    }
+    const locationByKey = new Map();
+    for (const location of locations) {
+        locationByKey.set(`${location.agent}|${location.filePath}|${location.scope}`, location);
+    }
+    const resolveWritePath = (agent, filePath, scope) => {
+        const existing = locationByKey.get(`${agent}|${filePath}|${scope}`);
+        if (existing)
+            return existing.path;
+        return resolveAgentSessionWritePath(agent, filePath, scope, {
+            cwd,
+            home,
+            currentProjectScope,
+        });
+    };
+    let pushed = 0;
+    let pulled = 0;
+    let deletedLocal = 0;
+    let unchanged = 0;
+    let skipped = 0;
+    let errors = 0;
+    const ackSessions = [];
+    const byAgent = new Map();
+    for (const action of actions) {
+        const group = byAgent.get(action.agent) ?? [];
+        group.push(action);
+        byAgent.set(action.agent, group);
+    }
+    for (const [agent, agentActions] of byAgent) {
+        console.log(chalk.white(`  ${formatAgentName(agent)}`));
+        for (const action of agentActions) {
+            const key = `${action.agent}|${action.file_path}|${action.scope}`;
+            if (action.action === "unchanged") {
+                const local = localByKey.get(key);
+                console.log(chalk.gray(`    = ${action.file_path}`), chalk.gray("unchanged"));
+                if (local && action.version) {
+                    ackSessions.push({
+                        agent: action.agent,
+                        file_path: action.file_path,
+                        scope: action.scope,
+                        content_hash: local.hash,
+                        version: action.version,
+                        local_path: local.loc.path,
+                    });
+                }
+                unchanged++;
+                continue;
+            }
+            if (action.action === "push") {
+                const local = localByKey.get(key);
+                if (!local) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray("local file not found for push"));
+                    errors++;
+                    continue;
+                }
+                try {
+                    const fileRef = await uploadLocalFile(local.loc.path, local.content, local.hash);
+                    await getClient().agentSessions.upsert({
+                        agent: action.agent,
+                        file_path: action.file_path,
+                        scope: action.scope,
+                        session_type: local.loc.sessionType,
+                        device_id: deviceID,
+                        local_path: local.loc.path,
+                        file_ref: fileRef,
+                    });
+                    console.log(chalk.green(`    ↑ ${action.file_path}`), chalk.gray(action.reason === "local_only"
+                        ? "pushing (new)"
+                        : "pushing (local newer)"));
+                    pushed++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            if (action.action === "pull") {
+                if (!action.session_id) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray("missing session ID from server"));
+                    errors++;
+                    continue;
+                }
+                const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                if (!writePath) {
+                    console.log(chalk.yellow(`    ? ${action.file_path}`), chalk.gray(action.scope !== "global" && action.scope !== currentProjectScope
+                        ? "different project — skipped"
+                        : "no safe restore path on this machine"));
+                    skipped++;
+                    continue;
+                }
+                try {
+                    const isNewLocally = action.reason === "cloud_only" && !existsSync(writePath);
+                    if (isNewLocally && !options.pull) {
+                        console.log(chalk.cyan(`    New file: ${action.file_path}`));
+                        console.log(chalk.gray(`    → ${writePath}`));
+                        const accept = await confirmDefault(`    Download? [Y/n] `);
+                        if (!accept) {
+                            console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                            skipped++;
+                            continue;
+                        }
+                    }
+                    const session = await getClient().agentSessions.get(action.session_id);
+                    const bytes = await downloadAgentSession(action.session_id);
+                    mkdirSync(dirname(writePath), { recursive: true });
+                    writeFileSync(writePath, bytes);
+                    if (action.version) {
+                        ackSessions.push({
+                            agent: action.agent,
+                            file_path: action.file_path,
+                            scope: action.scope,
+                            content_hash: session.content_hash,
+                            version: action.version,
+                            local_path: writePath,
+                        });
+                    }
+                    console.log(chalk.cyan(`    ↓ ${action.file_path}`), chalk.gray(isNewLocally ? "restored" : "pulling (cloud newer)"));
+                    pulled++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            if (action.action === "delete_local") {
+                try {
+                    const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                    if (writePath && existsSync(writePath)) {
+                        rmSync(writePath);
+                    }
+                    if (action.version) {
+                        ackSessions.push({
+                            agent: action.agent,
+                            file_path: action.file_path,
+                            scope: action.scope,
+                            version: action.version,
+                            local_path: writePath ?? undefined,
+                            deleted: true,
+                        });
+                    }
+                    console.log(chalk.yellow(`    - ${action.file_path}`), chalk.gray("deleted locally (cloud removed everywhere)"));
+                    deletedLocal++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            const resolution = await promptSessionConflict(action.file_path);
+            if (resolution === "local") {
+                const local = localByKey.get(key);
+                if (!local) {
+                    skipped++;
+                    continue;
+                }
+                try {
+                    const fileRef = await uploadLocalFile(local.loc.path, local.content, local.hash);
+                    await getClient().agentSessions.upsert({
+                        agent: action.agent,
+                        file_path: action.file_path,
+                        scope: action.scope,
+                        session_type: local.loc.sessionType,
+                        device_id: deviceID,
+                        local_path: local.loc.path,
+                        file_ref: fileRef,
+                    });
+                    console.log(chalk.green(`    ↑ ${action.file_path}`), chalk.gray("kept local"));
+                    pushed++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+            }
+            else if (resolution === "cloud" && action.session_id) {
+                const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                if (!writePath) {
+                    skipped++;
+                    continue;
+                }
+                try {
+                    const session = await getClient().agentSessions.get(action.session_id);
+                    const bytes = await downloadAgentSession(action.session_id);
+                    mkdirSync(dirname(writePath), { recursive: true });
+                    writeFileSync(writePath, bytes);
+                    if (action.version) {
+                        ackSessions.push({
+                            agent: action.agent,
+                            file_path: action.file_path,
+                            scope: action.scope,
+                            content_hash: session.content_hash,
+                            version: action.version,
+                            local_path: writePath,
+                        });
+                    }
+                    console.log(chalk.cyan(`    ↓ ${action.file_path}`), chalk.gray("used cloud"));
+                    pulled++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    ✗ ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+            }
+            else {
+                console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                skipped++;
+            }
+        }
+    }
+    if (ackSessions.length > 0) {
+        try {
+            await getClient().agentSessions.ack({
+                device_id: deviceID,
+                sessions: ackSessions,
+            });
+        }
+        catch (err) {
+            console.log(chalk.yellow("\n  Warning: failed to persist session sync state"), chalk.gray(err.message));
+        }
+    }
+    const parts = [];
+    if (pushed > 0)
+        parts.push(`${pushed} pushed`);
+    if (pulled > 0)
+        parts.push(`${pulled} restored`);
+    if (deletedLocal > 0)
+        parts.push(`${deletedLocal} deleted locally`);
+    if (unchanged > 0)
+        parts.push(`${unchanged} unchanged`);
+    if (skipped > 0)
+        parts.push(`${skipped} skipped`);
+    if (errors > 0)
+        parts.push(`${errors} errors`);
+    if (parts.length === 0) {
+        console.log(chalk.gray("  No session artifacts discovered.\n"));
+        return;
+    }
+    console.log(chalk.bold(`\n  Done: ${parts.join(", ")}`));
+    console.log(chalk.gray("  Session sync preserves raw artifacts. Knowledge extraction remains a separate workflow.\n"));
+}
+export async function listAgentSessionsCommand() {
+    try {
+        const result = await getClient().agentSessions.list();
+        const sessions = result.sessions;
+        if (sessions.length === 0) {
+            console.log(chalk.yellow("  No synced session artifacts.\n"));
+            return;
+        }
+        console.log();
+        for (const session of sessions) {
+            const scopeTag = session.scope === "global"
+                ? chalk.dim("global")
+                : chalk.dim(session.scope.replace(/^project:/, ""));
+            console.log(`  ${chalk.cyan(formatAgentName(session.agent))}  ${session.file_path}  ${scopeTag}  ${chalk.dim(formatBytes(session.size_bytes))}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch session artifacts: ${err.message}\n`));
+    }
+}
+export async function deleteAgentSessionsCommand() {
+    let sessions;
+    try {
+        sessions = (await getClient().agentSessions.list()).sessions;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch session artifacts: ${err.message}\n`));
+        return;
+    }
+    if (sessions.length === 0) {
+        console.log(chalk.yellow("  No synced session artifacts to delete.\n"));
+        return;
+    }
+    sessions.forEach((session, index) => {
+        const scopeTag = session.scope === "global"
+            ? chalk.dim("global")
+            : chalk.dim(session.scope.replace(/^project:/, ""));
+        console.log(`  ${chalk.dim(`${index + 1}.`)} ${chalk.cyan(formatAgentName(session.agent))} ${session.file_path} ${scopeTag}`);
+    });
+    console.log();
+    const answer = await ask("  Select session artifacts to delete (comma-separated numbers, or 'q' to quit): ");
+    if (!answer || answer.trim().toLowerCase() === "q") {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    const indices = answer
+        .split(",")
+        .map((value) => Number.parseInt(value.trim(), 10))
+        .filter((value) => Number.isFinite(value) && value >= 1 && value <= sessions.length);
+    if (indices.length === 0) {
+        console.log(chalk.gray("  No valid selections.\n"));
+        return;
+    }
+    const mode = (await ask("  Delete from [l] this device only, [e] everywhere, or [s] skip? "))
+        .trim()
+        .toLowerCase();
+    if (mode !== "l" && mode !== "e") {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    const deviceID = getOrCreateDeviceID();
+    const cwd = process.cwd();
+    const currentProjectScope = getProjectScope(cwd);
+    for (const index of indices) {
+        const session = sessions[index - 1];
+        const localPath = resolveAgentSessionWritePath(session.agent, session.file_path, session.scope, { cwd, home: homedir(), currentProjectScope });
+        try {
+            if (mode === "l") {
+                await getClient().agentSessions.localDelete({
+                    device_id: deviceID,
+                    agent: session.agent,
+                    file_path: session.file_path,
+                    scope: session.scope,
+                    local_path: localPath ?? undefined,
+                });
+                if (localPath && existsSync(localPath)) {
+                    rmSync(localPath);
+                }
+            }
+            else {
+                await getClient().agentSessions.delete(session.id);
+                if (localPath && existsSync(localPath)) {
+                    rmSync(localPath);
+                }
+                await getClient().agentSessions.ack({
+                    device_id: deviceID,
+                    sessions: [
+                        {
+                            agent: session.agent,
+                            file_path: session.file_path,
+                            scope: session.scope,
+                            version: session.version + 1,
+                            local_path: localPath ?? undefined,
+                            deleted: true,
+                        },
+                    ],
+                });
+            }
+            console.log(chalk.green(`    ✓ ${session.file_path}`), chalk.gray(mode === "e" ? "deleted everywhere" : "removed from this device"));
+        }
+        catch (err) {
+            console.log(chalk.red(`    ✗ ${session.file_path}`), chalk.gray(err.message));
+        }
+    }
+    console.log();
+}
+export async function doctorAgentSessionsCommand() {
+    const cwd = process.cwd();
+    const project = resolveProjectScope(cwd);
+    const deviceID = getOrCreateDeviceID();
+    const locations = discoverAgentSessions();
+    const localByKey = new Map();
+    for (const loc of locations) {
+        if (!existsSync(loc.path))
+            continue;
+        localByKey.set(`${loc.agent}|${loc.filePath}|${loc.scope}`, loc);
+    }
+    console.log(chalk.bold("\n  Memax Agent Session Doctor\n"));
+    console.log(`  Device  ${chalk.bold(deviceID)}`);
+    console.log(`  CWD     ${chalk.gray(cwd)}`);
+    console.log(`  Scope   ${chalk.bold(project.scope)}`);
+    if (project.warning) {
+        console.log(`  Warning ${chalk.yellow(project.warning)}`);
+    }
+    console.log();
+    console.log(chalk.white("  Local Discovery"));
+    if (localByKey.size === 0) {
+        console.log(`    ${chalk.gray("No supported local session artifacts discovered.")}`);
+    }
+    else {
+        for (const loc of localByKey.values()) {
+            console.log(`    ${chalk.cyan(formatAgentName(loc.agent))}  ${loc.filePath}  ${chalk.gray(loc.scope)}  ${chalk.gray(loc.path)}`);
+        }
+    }
+    console.log();
+    try {
+        const cloud = await getClient().agentSessions.list();
+        const placements = cloud.sessions.map((session) => ({
+            session,
+            placement: classifyAgentSessionPlacement(session.agent, session.file_path, session.scope, {
+                cwd,
+                home: homedir(),
+                currentProjectScope: project.scope,
+                localByKey,
+            }),
+        }));
+        printSessionPlacementSection("  Restorable Here", chalk.cyan, placements.filter((item) => item.placement.kind === "restorable"));
+        printSessionPlacementSection("  Different Project", chalk.yellow, placements.filter((item) => item.placement.kind === "different_project"));
+        printSessionPlacementSection("  Unresolved", chalk.magenta, placements.filter((item) => item.placement.kind === "unresolved"));
+        console.log(chalk.gray("  Session sync restores only when placement is safe. Ambiguous session stores are skipped.\n"));
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch cloud session artifacts: ${err.message}\n`));
+    }
+}
+function discoverAgentSessions() {
+    const home = homedir();
+    const config = loadConfig();
+    const locations = [];
+    const add = (agent, path, filePath, scope, sessionType) => {
+        locations.push({
+            agent,
+            path,
+            filePath: normalizeFilePath(filePath),
+            scope,
+            sessionType,
+        });
+    };
+    const claudeProjectsDir = join(home, ".claude", "projects");
+    if (existsSync(claudeProjectsDir)) {
+        for (const project of safeListDir(claudeProjectsDir)) {
+            const repoUrl = resolveClaudeProjectFolder(project);
+            if (!repoUrl)
+                continue;
+            const projectDir = join(claudeProjectsDir, project);
+            for (const file of safeListDir(projectDir)) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                add("claude-code", join(projectDir, file), `sessions/${file}`, `project:${repoUrl}`, "transcript");
+            }
+        }
+    }
+    const codexHistory = join(home, ".codex", "history.jsonl");
+    add("codex", codexHistory, "history.jsonl", "global", "history");
+    const codexSessionsRoot = join(home, ".codex", "sessions");
+    if (existsSync(codexSessionsRoot)) {
+        for (const file of walkFiles(codexSessionsRoot, (entry) => entry.endsWith(".jsonl"))) {
+            add("codex", file, join("sessions", relative(codexSessionsRoot, file)), "global", "transcript");
+        }
+    }
+    const geminiTmpRoot = join(home, ".gemini", "tmp");
+    if (existsSync(geminiTmpRoot)) {
+        for (const projectDirName of safeListDir(geminiTmpRoot)) {
+            const projectDir = join(geminiTmpRoot, projectDirName);
+            const projectRootPath = readProjectRootMarker(join(projectDir, ".project_root"));
+            if (!projectRootPath)
+                continue;
+            const scope = getProjectScope(projectRootPath);
+            if (!scope.startsWith("project:"))
+                continue;
+            const chatsDir = join(projectDir, "chats");
+            if (!existsSync(chatsDir))
+                continue;
+            for (const file of safeListDir(chatsDir)) {
+                if (!file.endsWith(".json"))
+                    continue;
+                add("gemini", join(chatsDir, file), `chats/${file}`, scope, "session");
+            }
+        }
+    }
+    for (const root of config.agent_session_roots ?? []) {
+        const normalizedScope = (root.scope || "").trim();
+        if (normalizedScope === "")
+            continue;
+        const rootPath = root.root_path ? resolveHome(root.root_path) : "";
+        if (!rootPath || !existsSync(rootPath))
+            continue;
+        const includeExtensions = root.include_extensions && root.include_extensions.length > 0
+            ? new Set(root.include_extensions.map((value) => value.toLowerCase()))
+            : new Set([".jsonl", ".json", ".md", ".txt"]);
+        const sessionType = root.session_type?.trim() || "artifact";
+        for (const file of walkFiles(rootPath, (entry) => includeExtensions.has(extension(entry)))) {
+            add(root.agent, file, relative(rootPath, file), normalizedScope, sessionType);
+        }
+    }
+    return locations;
+}
+function findGeminiProjectDir(home, scope) {
+    const geminiTmpRoot = join(home, ".gemini", "tmp");
+    if (!existsSync(geminiTmpRoot))
+        return null;
+    for (const projectDirName of safeListDir(geminiTmpRoot)) {
+        const projectDir = join(geminiTmpRoot, projectDirName);
+        const projectRootPath = readProjectRootMarker(join(projectDir, ".project_root"));
+        if (!projectRootPath)
+            continue;
+        if (getProjectScope(projectRootPath) === scope) {
+            return projectDir;
+        }
+    }
+    return null;
+}
+export function resolveAgentSessionWritePath(agent, filePath, scope, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    const currentProjectScope = options.currentProjectScope ?? getProjectScope(cwd);
+    const normalized = normalizeFilePath(filePath);
+    if (scope === "global") {
+        switch (agent) {
+            case "codex":
+                if (normalized === "history.jsonl") {
+                    return join(home, ".codex", "history.jsonl");
+                }
+                if (normalized.startsWith("sessions/")) {
+                    return join(home, ".codex", normalized);
+                }
+                return null;
+            default:
+                return null;
+        }
+    }
+    if (!scope.startsWith("project:") || scope !== currentProjectScope) {
+        return null;
+    }
+    switch (agent) {
+        case "claude-code": {
+            if (!normalized.startsWith("sessions/"))
+                return null;
+            const claudeProjectsDir = join(home, ".claude", "projects");
+            for (const project of safeListDir(claudeProjectsDir)) {
+                const repoUrl = resolveClaudeProjectFolder(project);
+                if (repoUrl && `project:${repoUrl}` === scope) {
+                    return join(claudeProjectsDir, project, normalized.replace(/^sessions\//, ""));
+                }
+            }
+            return null;
+        }
+        case "gemini": {
+            if (!normalized.startsWith("chats/"))
+                return null;
+            const projectDir = findGeminiProjectDir(home, scope);
+            if (!projectDir)
+                return null;
+            return join(projectDir, normalized);
+        }
+        default:
+            return null;
+    }
+}
+export function classifyAgentSessionPlacement(agent, filePath, scope, options = {}) {
+    const key = `${agent}|${normalizeFilePath(filePath)}|${scope}`;
+    const existing = options.localByKey?.get(key);
+    if (existing) {
+        return { kind: "present", path: existing.path, reason: "present locally" };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const currentProjectScope = options.currentProjectScope ?? getProjectScope(cwd);
+    if (scope.startsWith("project:") && scope !== currentProjectScope) {
+        return {
+            kind: "different_project",
+            reason: `belongs to ${scope.replace(/^project:/, "")}`,
+        };
+    }
+    const path = resolveAgentSessionWritePath(agent, filePath, scope, options);
+    if (path) {
+        return { kind: "restorable", path, reason: "safe restore path available" };
+    }
+    return {
+        kind: "unresolved",
+        reason: "no safe restore path on this machine",
+    };
+}
+async function uploadLocalFile(path, content, sha256) {
+    const stat = statSync(path);
+    const contentType = inferContentType(path);
+    const intent = await getClient().uploads.create({
+        filename: basenameSafe(path),
+        content_type: contentType,
+        size_bytes: stat.size,
+    });
+    await putUpload(intent, content);
+    return {
+        object_key: intent.object_key,
+        filename: basenameSafe(path),
+        content_type: contentType,
+        size_bytes: stat.size,
+        sha256,
+    };
+}
+async function putUpload(intent, content) {
+    const res = await fetch(intent.upload_url, {
+        method: "PUT",
+        headers: intent.headers,
+        body: content,
+    });
+    if (!res.ok) {
+        throw new Error(`upload failed with status ${res.status}`);
+    }
+}
+async function downloadAgentSession(id) {
+    const headers = await getAuthHeaders();
+    const res = await fetch(`${loadConfig().api_url}/v1/agent-sessions/${id}/download`, {
+        headers,
+    });
+    if (!res.ok) {
+        throw new Error(`download failed with status ${res.status}`);
+    }
+    return Buffer.from(await res.arrayBuffer());
+}
+async function promptSessionConflict(filePath) {
+    const answer = await ask(`    Conflict for ${filePath}. Use [l]ocal, [c]loud, or [s]kip? `);
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === "l")
+        return "local";
+    if (normalized === "c")
+        return "cloud";
+    return "skip";
+}
+function readProjectRootMarker(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const value = readFileSync(path, "utf-8").trim();
+        return value || null;
+    }
+    catch {
+        return null;
+    }
+}
+function walkFiles(root, include) {
+    const files = [];
+    const visit = (dir) => {
+        for (const entry of safeListDir(dir)) {
+            const fullPath = join(dir, entry);
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                visit(fullPath);
+                continue;
+            }
+            if (stat.isFile() && include(fullPath)) {
+                files.push(fullPath);
+            }
+        }
+    };
+    visit(root);
+    return files;
+}
+function safeListDir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function printSessionPlacementSection(title, color, items) {
+    if (items.length === 0)
+        return;
+    console.log(chalk.white(title));
+    for (const item of items) {
+        console.log(`    ${color(formatAgentName(item.session.agent))}  ${item.session.file_path}`);
+        console.log(`      ${chalk.gray(item.placement.reason)}`);
+    }
+    console.log();
+}
+function formatAgentName(agent) {
+    const labels = {
+        "claude-code": "Claude Code",
+        codex: "Codex",
+        gemini: "Gemini CLI",
+        openclaw: "OpenClaw",
+        opencode: "OpenCode",
+    };
+    return labels[agent] ?? agent;
+}
+function inferContentType(path) {
+    if (path.endsWith(".jsonl"))
+        return "application/x-ndjson";
+    if (path.endsWith(".json"))
+        return "application/json";
+    if (path.endsWith(".md"))
+        return "text/markdown";
+    return "text/plain";
+}
+function formatBytes(size) {
+    if (size < 1024)
+        return `${size} B`;
+    if (size < 1024 * 1024)
+        return `${(size / 1024).toFixed(1)} KB`;
+    return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+function basenameSafe(path) {
+    return normalizeFilePath(path).split("/").pop() ?? "artifact";
+}
+function resolveHome(path) {
+    if (path.startsWith("~/")) {
+        return join(homedir(), path.slice(2));
+    }
+    return path;
+}
+function extension(path) {
+    const normalized = normalizeFilePath(path).toLowerCase();
+    const dot = normalized.lastIndexOf(".");
+    return dot >= 0 ? normalized.slice(dot) : "";
+}
+//# sourceMappingURL=agent-sessions.js.map