@getforgeai/cli 0.1.0-beta.1

package/dist/vm/session-manager.d.ts

@@ -0,0 +1,130 @@
+/**
+ * High-level session orchestration for Docker containers.
+ *
+ * Unlike the old VM-based approach, the SessionManager now runs
+ * 1 Docker container per session. Each container is a lightweight
+ * isolated environment where we can execute git, compile, and spawn agents.
+ *
+ * Lifecycle:
+ *   1. ensureVmRunning()  — lazy check Docker availability + ensure image
+ *   2. createSession()    — allocate session dir + create + start container
+ *   3. cloneRepo()        — git clone inside container via exec()
+ *   4. prepareWorkspace() — write context/skills/MCP config to host volume
+ *   5. spawnAgent()       — launch agent in container, returns DockerProcessProxy
+ *   6. destroySession()   — kill container + cleanup host files
+ *   7. shutdown()         — cleanup all containers
+ */
+import type { ChildProcess } from "node:child_process";
+import { DockerProcessProxy } from "./docker-process-proxy.js";
+import { type GitCredentials } from "./git-credentials.js";
+export type SessionState = {
+    id: string;
+    taskId: string;
+    sessionIndex: number;
+    sessionDir: string;
+    containerId: string;
+    status: "CREATED" | "SPAWNING" | "RUNNING" | "STOPPED";
+    agentPid?: number;
+    agentProcess?: ChildProcess;
+    /**
+     * Per-session shared secret for the MCP bridge auth handshake.
+     * Generated at session creation, stable across agent resume (--continue),
+     * never logged. Passed to the in-container relay via FORGEAI_MCP_TOKEN.
+     */
+    mcpSecret: string;
+    /**
+     * Git credential for this session's repo, resolved from the host credential
+     * helper at clone time. Kept in memory only (never written to disk or
+     * .git/config) so CLI-driven pushes (branch tracking, autoSaveCode) can
+     * re-supply it out-of-band via an env-var credential helper. Undefined for
+     * ssh/public repos.
+     */
+    gitCredentials?: GitCredentials;
+};
+export declare function getSessionManager(): SessionManager;
+export declare function initSessionManager(): SessionManager;
+export declare class SessionManager {
+    private sessions;
+    private sessionCounter;
+    private dockerReady;
+    private claudeOAuthToken;
+    private tokenLoadedAt;
+    /**
+     * Ensure Docker is available and image is ready.
+     * Idempotent: if already checked, returns immediately.
+     */
+    ensureVmRunning(): Promise<void>;
+    /**
+     * Create a session for a task agent.
+     * Allocates a session index, creates host directories, spins up container.
+     */
+    createSession(taskId: string): Promise<string>;
+    /**
+     * Execute a command inside a session's container.
+     * Used for git clone, initial setup, etc.
+     */
+    exec(taskId: string, cmd: string, args: string[], cwd?: string): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    /**
+     * Clone a git repo into the session workspace inside the container.
+     * Creates the branch if it doesn't exist yet (forking from baseBranch).
+     */
+    cloneRepo(sessionId: string, repoUrl: string | undefined, branch?: string, baseBranch?: string): Promise<void>;
+    /**
+     * Write session files (context, MCP config, skills) to the session directory
+     * on the host. These are accessible in the container via volume mount at /session/.
+     */
+    prepareWorkspace(sessionId: string, files: {
+        contextJson: string;
+        mcpConfigJson: string;
+        skillFiles: Array<{
+            relativePath: string;
+            content: string;
+        }>;
+    }): void;
+    /**
+     * Spawn an agent inside the container.
+     * Returns a DockerProcessProxy that satisfies the AgentProcess interface.
+     */
+    spawnAgent(taskId: string, cmd: string, args: string[], env?: Record<string, string>): Promise<DockerProcessProxy>;
+    /**
+     * Kill an agent process.
+     */
+    killAgent(taskIdOrSessionId: string, signal?: string): Promise<void>;
+    /**
+     * Destroy a session (stop container + cleanup host files).
+     */
+    destroySession(taskId: string): Promise<void>;
+    /**
+     * Graceful shutdown: remove all managed containers and cleanup.
+     */
+    shutdown(): Promise<void>;
+    getSessionByTaskId(taskId: string): SessionState | undefined;
+    getAllSessions(): SessionState[];
+    isVmRunning(): boolean;
+    /**
+     * Reload token from Keychain/file. Called after auth errors to pick up
+     * a refreshed token without restarting the CLI.
+     * Returns true if a new token was loaded.
+     */
+    refreshToken(): Promise<boolean>;
+    /**
+     * Look up a session by taskId (primary key) or by sessionId (fallback).
+     */
+    private getSession;
+    /**
+     * Resolve git credentials for a repo URL from the host's git credential
+     * helper, WITHOUT inlining them into the URL.
+     *
+     * Returns the clean (userinfo-free) URL to clone from, plus the username /
+     * password to supply out-of-band. SSH URLs and repos with no stored
+     * credential resolve to `{ cleanUrl }` with no credentials (the clone then
+     * proceeds unauthenticated — fine for public repos; a private repo will fail
+     * with git's own auth error rather than leaking anything).
+     */
+    private resolveGitCredentials;
+}
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/vm/session-manager.js

@@ -0,0 +1,494 @@
+/**
+ * High-level session orchestration for Docker containers.
+ *
+ * Unlike the old VM-based approach, the SessionManager now runs
+ * 1 Docker container per session. Each container is a lightweight
+ * isolated environment where we can execute git, compile, and spawn agents.
+ *
+ * Lifecycle:
+ *   1. ensureVmRunning()  — lazy check Docker availability + ensure image
+ *   2. createSession()    — allocate session dir + create + start container
+ *   3. cloneRepo()        — git clone inside container via exec()
+ *   4. prepareWorkspace() — write context/skills/MCP config to host volume
+ *   5. spawnAgent()       — launch agent in container, returns DockerProcessProxy
+ *   6. destroySession()   — kill container + cleanup host files
+ *   7. shutdown()         — cleanup all containers
+ */
+import { copyFileSync, existsSync, mkdirSync, writeFileSync, rmSync, } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { execInContainer, spawnInContainer, createContainer, startContainer, removeContainer, isDockerAvailable, } from "./docker-executor.js";
+import { DockerProcessProxy } from "./docker-process-proxy.js";
+import { gitCredentialConfigArgs, gitCredentialSecretEnv, } from "./git-credentials.js";
+import { ensureImage, FORGEAI_IMAGE } from "./image-manager.js";
+import { vmLog } from "./log.js";
+import { ensureClaudeToken } from "./claude-token-manager.js";
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+const SESSIONS_DIR = join(homedir(), ".forgeai", "docker", "sessions");
+/**
+ * Path to the canonical forge-mcp-relay source shipped with the CLI.
+ * From dist/vm/ (or src/vm/), go up to the cli root, then rootfs/.
+ * The relay is staged into each session dir so the version running in the
+ * container always matches this CLI build — no Docker image rebuild needed.
+ */
+function getRelaySourcePath() {
+    return join(import.meta.dirname, "..", "..", "rootfs", "forge-mcp-relay.mjs");
+}
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+let instance = null;
+export function getSessionManager() {
+    if (!instance)
+        throw new Error("SessionManager not initialized");
+    return instance;
+}
+export function initSessionManager() {
+    instance = new SessionManager();
+    return instance;
+}
+// ---------------------------------------------------------------------------
+// SessionManager
+// ---------------------------------------------------------------------------
+export class SessionManager {
+    sessions = new Map();
+    sessionCounter = 0;
+    dockerReady = false;
+    claudeOAuthToken = "";
+    tokenLoadedAt = 0;
+    // -------------------------------------------------------------------------
+    // VM lifecycle (now Docker)
+    // -------------------------------------------------------------------------
+    /**
+     * Ensure Docker is available and image is ready.
+     * Idempotent: if already checked, returns immediately.
+     */
+    async ensureVmRunning() {
+        // Re-read token from Keychain every hour (catches external refresh via setup-claude)
+        if (this.dockerReady) {
+            const TOKEN_REFRESH_MS = 60 * 60 * 1000; // 1 hour
+            if (Date.now() - this.tokenLoadedAt > TOKEN_REFRESH_MS) {
+                await this.refreshToken();
+            }
+            return;
+        }
+        // Check Docker availability
+        const dockerAvailable = await isDockerAvailable();
+        if (!dockerAvailable) {
+            throw new Error("Docker is not available — install Docker Desktop or docker-ce");
+        }
+        // Ensure ForgeAI image exists (pull or build if needed)
+        await ensureImage();
+        // Create host directories
+        mkdirSync(SESSIONS_DIR, { recursive: true, mode: 0o700 });
+        // Obtain Claude OAuth token for container authentication
+        this.claudeOAuthToken = await ensureClaudeToken();
+        this.tokenLoadedAt = Date.now();
+        this.dockerReady = true;
+        vmLog.cyan("session-manager", "Docker ready");
+    }
+    // -------------------------------------------------------------------------
+    // Session management
+    // -------------------------------------------------------------------------
+    /**
+     * Create a session for a task agent.
+     * Allocates a session index, creates host directories, spins up container.
+     */
+    async createSession(taskId) {
+        if (!this.dockerReady) {
+            throw new Error("Docker not ready — call ensureVmRunning() first");
+        }
+        const sessionIndex = this.sessionCounter++;
+        const sanitizedId = taskId.slice(0, 12).replace(/[^a-zA-Z0-9-]/g, "");
+        const sessionId = `s-${sanitizedId}-${sessionIndex}`;
+        const sessionDir = join(SESSIONS_DIR, sessionId);
+        // Clean up stale session directory from previous failed runs
+        if (existsSync(sessionDir)) {
+            rmSync(sessionDir, { recursive: true, force: true });
+        }
+        mkdirSync(sessionDir, { recursive: true, mode: 0o700 });
+        // Create Docker container
+        const containerId = await createContainer({
+            name: `forgeai-${sessionId}`,
+            image: FORGEAI_IMAGE,
+            volumes: [
+                {
+                    hostPath: sessionDir,
+                    containerPath: "/session",
+                    readOnly: false,
+                },
+            ],
+            sessionId,
+            taskId,
+        });
+        // Start container
+        await startContainer(containerId);
+        const session = {
+            id: sessionId,
+            taskId,
+            sessionIndex,
+            sessionDir,
+            containerId,
+            status: "CREATED",
+            // Crypto-random per-session secret for the MCP bridge auth handshake
+            mcpSecret: randomBytes(32).toString("hex"),
+        };
+        this.sessions.set(taskId, session);
+        vmLog.info("session-manager", `Session created: ${sessionId} (container: ${containerId.slice(0, 12)})`, sessionId);
+        return sessionId;
+    }
+    // -------------------------------------------------------------------------
+    // Command execution inside the container
+    // -------------------------------------------------------------------------
+    /**
+     * Execute a command inside a session's container.
+     * Used for git clone, initial setup, etc.
+     */
+    async exec(taskId, cmd, args, cwd) {
+        const session = this.getSession(taskId);
+        if (!session) {
+            throw new Error(`Session for task ${taskId} not found`);
+        }
+        const result = await execInContainer(session.containerId, [cmd, ...args], {
+            cwd,
+            timeout: 600_000, // 10 minutes
+        });
+        return result;
+    }
+    // -------------------------------------------------------------------------
+    // Git operations
+    // -------------------------------------------------------------------------
+    /**
+     * Clone a git repo into the session workspace inside the container.
+     * Creates the branch if it doesn't exist yet (forking from baseBranch).
+     */
+    async cloneRepo(sessionId, repoUrl, branch, baseBranch) {
+        if (!repoUrl)
+            return;
+        const session = this.getSession(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        const { cleanUrl, credentials } = await this.resolveGitCredentials(repoUrl);
+        // Persist in memory so CLI-driven pushes later in the session (branch
+        // tracking below, autoSaveCode) can re-supply the credential out-of-band.
+        session.gitCredentials = credentials;
+        const workspacePath = "/session/workspace";
+        // Credential injection for network git ops: clean URL + inline helper that
+        // reads the value from FORGE_GIT_* env vars (passed via secretEnv, so the
+        // value is never in argv and never persists in .git/config).
+        const credArgs = credentials ? gitCredentialConfigArgs() : [];
+        const credEnv = credentials
+            ? { secretEnv: gitCredentialSecretEnv(credentials) }
+            : undefined;
+        vmLog.cyan("session-manager", `Cloning ${repoUrl} into ${sessionId}...`, sessionId);
+        const cloneResult = await execInContainer(session.containerId, ["git", ...credArgs, "clone", cleanUrl, workspacePath], credEnv);
+        // Configure git identity for commits (required by autoSaveCode)
+        await execInContainer(session.containerId, [
+            "git",
+            "-C",
+            workspacePath,
+            "config",
+            "user.email",
+            "agent@forgeai.dev",
+        ]);
+        await execInContainer(session.containerId, [
+            "git",
+            "-C",
+            workspacePath,
+            "config",
+            "user.name",
+            "ForgeAI Agent",
+        ]);
+        if (cloneResult.exitCode !== 0) {
+            throw new Error(`Git clone failed (exit ${cloneResult.exitCode}): ${cloneResult.stderr}`);
+        }
+        if (branch) {
+            // Try checking out an existing remote branch first
+            const checkoutResult = await execInContainer(session.containerId, [
+                "git",
+                "-C",
+                workspacePath,
+                "checkout",
+                branch,
+            ]);
+            if (checkoutResult.exitCode !== 0) {
+                // Branch doesn't exist remotely — create it from baseBranch or HEAD
+                const base = baseBranch ? `origin/${baseBranch}` : "HEAD";
+                const createResult = await execInContainer(session.containerId, [
+                    "git",
+                    "-C",
+                    workspacePath,
+                    "checkout",
+                    "-b",
+                    branch,
+                    base,
+                ]);
+                if (createResult.exitCode !== 0) {
+                    throw new Error(`Failed to create branch ${branch}: ${createResult.stderr}`);
+                }
+                // Push the new branch to set up tracking (network op — needs the
+                // credential helper; clean remote URL has no embedded userinfo).
+                await execInContainer(session.containerId, [
+                    "git",
+                    "-C",
+                    workspacePath,
+                    ...credArgs,
+                    "push",
+                    "-u",
+                    "origin",
+                    branch,
+                ], credEnv);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Workspace preparation
+    // -------------------------------------------------------------------------
+    /**
+     * Write session files (context, MCP config, skills) to the session directory
+     * on the host. These are accessible in the container via volume mount at /session/.
+     */
+    prepareWorkspace(sessionId, files) {
+        const session = this.getSession(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        // Write to host session dir (mounted at /session in container)
+        writeFileSync(join(session.sessionDir, "context.json"), files.contextJson, "utf-8");
+        writeFileSync(join(session.sessionDir, "mcp_config.json"), files.mcpConfigJson, "utf-8");
+        // Stage the MCP relay so the container runs the version matching this
+        // CLI build (with the auth handshake) even on a stale Docker image.
+        const relaySource = getRelaySourcePath();
+        if (!existsSync(relaySource)) {
+            throw new Error(`forge-mcp-relay.mjs not found at ${relaySource}`);
+        }
+        copyFileSync(relaySource, join(session.sessionDir, "forge-mcp-relay.mjs"));
+        for (const file of files.skillFiles) {
+            // Guard against path traversal: resolve the full path and verify
+            // it stays within the session directory.
+            const filePath = resolve(session.sessionDir, "skills", file.relativePath);
+            if (!filePath.startsWith(resolve(session.sessionDir))) {
+                throw new Error(`Path traversal detected: ${file.relativePath}`);
+            }
+            const fileDir = join(filePath, "..");
+            mkdirSync(fileDir, { recursive: true });
+            writeFileSync(filePath, file.content, "utf-8");
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Agent spawning
+    // -------------------------------------------------------------------------
+    /**
+     * Spawn an agent inside the container.
+     * Returns a DockerProcessProxy that satisfies the AgentProcess interface.
+     */
+    async spawnAgent(taskId, cmd, args, env = {}) {
+        const session = this.getSession(taskId);
+        if (!session)
+            throw new Error(`Session for task ${taskId} not found`);
+        session.status = "SPAWNING";
+        // Log the full command for debugging
+        const promptArgIdx = args.indexOf("-p");
+        const promptPreview = promptArgIdx >= 0 && args[promptArgIdx + 1]
+            ? `"${args[promptArgIdx + 1].slice(0, 100)}${args[promptArgIdx + 1].length > 100 ? "..." : ""}"`
+            : "(no -p)";
+        const flags = args.filter((a) => a.startsWith("--")).join(" ");
+        vmLog.magenta("session-manager", `${cmd} ${flags} -p ${promptPreview}`, session.id);
+        // Spawn the process in the container
+        const dockerExecProcess = spawnInContainer(session.containerId, [cmd, ...args], {
+            cwd: "/session/workspace",
+            env,
+            // The long-lived Claude token goes through secretEnv (name-only -e) so
+            // it never lands in the host process table / `ps` output.
+            secretEnv: { CLAUDE_CODE_OAUTH_TOKEN: this.claudeOAuthToken },
+            user: "agent",
+        });
+        // Create a kill function that removes the container when the process exits
+        const killFn = async (signal) => {
+            try {
+                dockerExecProcess.kill((signal ?? "SIGTERM"));
+            }
+            catch {
+                /* best effort */
+            }
+        };
+        // Create proxy wrapping the docker exec process
+        const proxy = new DockerProcessProxy(session.id, dockerExecProcess, killFn);
+        session.agentPid = proxy.pid;
+        session.agentProcess = dockerExecProcess;
+        session.status = "RUNNING";
+        vmLog.info("session-manager", `Agent spawned in container ${session.id} (PID: ${proxy.pid})`, session.id);
+        return proxy;
+    }
+    // -------------------------------------------------------------------------
+    // Agent lifecycle
+    // -------------------------------------------------------------------------
+    /**
+     * Kill an agent process.
+     */
+    async killAgent(taskIdOrSessionId, signal = "SIGTERM") {
+        const session = this.getSession(taskIdOrSessionId);
+        if (!session || !session.agentProcess)
+            return;
+        session.agentProcess.kill(signal);
+    }
+    /**
+     * Destroy a session (stop container + cleanup host files).
+     */
+    async destroySession(taskId) {
+        const session = this.sessions.get(taskId);
+        if (!session)
+            return;
+        // Kill agent if still running
+        if (session.status === "RUNNING" && session.agentProcess) {
+            await this.killAgent(taskId);
+        }
+        // Remove Docker container
+        try {
+            await removeContainer(session.containerId, true);
+        }
+        catch {
+            /* container may already be gone */
+        }
+        // Clean up host session directory
+        if (existsSync(session.sessionDir)) {
+            rmSync(session.sessionDir, { recursive: true, force: true });
+        }
+        this.sessions.delete(taskId);
+        vmLog.info("session-manager", `Session destroyed: ${session.id}`, session.id);
+    }
+    // -------------------------------------------------------------------------
+    // Shutdown
+    // -------------------------------------------------------------------------
+    /**
+     * Graceful shutdown: remove all managed containers and cleanup.
+     */
+    async shutdown() {
+        vmLog.cyan("session-manager", "Shutting down...");
+        // Destroy all sessions
+        const taskIds = Array.from(this.sessions.keys());
+        for (const taskId of taskIds) {
+            try {
+                await this.destroySession(taskId);
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        this.sessions.clear();
+        this.dockerReady = false;
+        vmLog.info("session-manager", "Shutdown complete");
+    }
+    // -------------------------------------------------------------------------
+    // Queries
+    // -------------------------------------------------------------------------
+    getSessionByTaskId(taskId) {
+        return this.sessions.get(taskId);
+    }
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    isVmRunning() {
+        return this.dockerReady;
+    }
+    /**
+     * Reload token from Keychain/file. Called after auth errors to pick up
+     * a refreshed token without restarting the CLI.
+     * Returns true if a new token was loaded.
+     */
+    async refreshToken() {
+        const { loadClaudeToken } = await import("./claude-token-manager.js");
+        const fresh = await loadClaudeToken();
+        const preview = (t) => `${t.slice(0, 15)}...${t.slice(-4)}`;
+        if (!fresh) {
+            vmLog.warn("session-manager", "No token found in Keychain");
+            return false;
+        }
+        if (fresh === this.claudeOAuthToken) {
+            vmLog.warn("session-manager", `Token unchanged in Keychain (${preview(fresh)}) — same expired token. Run: forge auth setup-claude`);
+            return false;
+        }
+        vmLog.cyan("session-manager", `Token refreshed: ${preview(this.claudeOAuthToken)} → ${preview(fresh)}`);
+        this.claudeOAuthToken = fresh;
+        this.tokenLoadedAt = Date.now();
+        return true;
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Look up a session by taskId (primary key) or by sessionId (fallback).
+     */
+    getSession(idOrTaskId) {
+        // Try taskId first (Map key)
+        const byTask = this.sessions.get(idOrTaskId);
+        if (byTask)
+            return byTask;
+        // Fallback: search by sessionId
+        for (const session of this.sessions.values()) {
+            if (session.id === idOrTaskId)
+                return session;
+        }
+        return undefined;
+    }
+    /**
+     * Resolve git credentials for a repo URL from the host's git credential
+     * helper, WITHOUT inlining them into the URL.
+     *
+     * Returns the clean (userinfo-free) URL to clone from, plus the username /
+     * password to supply out-of-band. SSH URLs and repos with no stored
+     * credential resolve to `{ cleanUrl }` with no credentials (the clone then
+     * proceeds unauthenticated — fine for public repos; a private repo will fail
+     * with git's own auth error rather than leaking anything).
+     */
+    async resolveGitCredentials(repoUrl) {
+        if (repoUrl.startsWith("git@") || repoUrl.startsWith("ssh://")) {
+            return { cleanUrl: repoUrl };
+        }
+        try {
+            const { spawn: spawnProcess } = await import("node:child_process");
+            const url = new URL(repoUrl);
+            const input = `protocol=${url.protocol.replace(":", "")}\nhost=${url.hostname}\n\n`;
+            const result = await new Promise((resolvePromise, reject) => {
+                const proc = spawnProcess("git", ["credential", "fill"], {
+                    stdio: ["pipe", "pipe", "pipe"],
+                    timeout: 10_000,
+                });
+                let stdout = "";
+                proc.stdout.on("data", (d) => {
+                    stdout += d.toString();
+                });
+                proc.on("close", (code) => {
+                    if (code === 0)
+                        resolvePromise(stdout);
+                    else
+                        reject(new Error(`git credential fill exited ${code}`));
+                });
+                proc.on("error", reject);
+                proc.stdin.write(input);
+                proc.stdin.end();
+            });
+            let username = "";
+            let password = "";
+            for (const line of result.split("\n")) {
+                if (line.startsWith("username="))
+                    username = line.slice(9);
+                if (line.startsWith("password="))
+                    password = line.slice(9);
+            }
+            if (username && password) {
+                // Return the ORIGINAL url untouched (no userinfo) plus the credential
+                // separately — the credential is injected via an env-var credential
+                // helper at git-command time, never in the URL or .git/config.
+                return { cleanUrl: repoUrl, credentials: { username, password } };
+            }
+        }
+        catch {
+            /* No credentials available from git credential helper */
+        }
+        return { cleanUrl: repoUrl };
+    }
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/vm/session-snapshot.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Session snapshot: save and restore Claude Code session files for workflow resume.
+ *
+ * Before destroying a container after idle timeout:
+ *   1. Auto-save code: git add -A && git commit && git push
+ *   2. Tar Claude Code session files (~/.claude/projects/)
+ *   3. Upload encrypted snapshot to Cloud via socket event
+ *
+ * On resume in a new container:
+ *   1. Download snapshot from Cloud
+ *   2. Restore Claude Code session files
+ *   3. Launch `claude --continue` (full context restored)
+ */
+import { type GitCredentials } from "./git-credentials.js";
+import type { SessionState } from "./session-manager.js";
+/**
+ * Auto-save code changes in the container (best-effort git commit + push).
+ * Does not throw — failures are logged and ignored.
+ */
+export declare function autoSaveCode(containerId: string, sessionId?: string, credentials?: GitCredentials): Promise<void>;
+/**
+ * Save Claude Code session files from the container to a base64 tar.gz string.
+ *
+ * Returns the base64-encoded tar.gz, or null if snapshot is unavailable or too large.
+ */
+export declare function createSessionSnapshot(session: SessionState): Promise<string | null>;
+/**
+ * Restore Claude Code session files into a container from a base64 tar.gz string.
+ */
+export declare function restoreSessionSnapshot(session: SessionState, snapshotBase64: string): Promise<boolean>;
+//# sourceMappingURL=session-snapshot.d.ts.map