@13rac1/openclaw-plugin-claude-code 1.0.3

package/dist/podman-runner.d.ts

@@ -0,0 +1,108 @@
+export interface PodmanConfig {
+    runtime: string;
+    image: string;
+    startupTimeout: number;
+    idleTimeout: number;
+    memory: string;
+    cpus: string;
+    network: string;
+    apparmorProfile?: string;
+    maxOutputSize: number;
+}
+export type ErrorType = "startup_timeout" | "idle_timeout" | "oom" | "crash" | "spawn_failed";
+export interface ResourceMetrics {
+    memoryUsageMB?: number;
+    memoryLimitMB?: number;
+    memoryPercent?: number;
+    cpuPercent?: number;
+}
+export interface ClaudeCodeResult {
+    content: string;
+    sessionId: string | null;
+    exitCode: number;
+    elapsedSeconds?: number;
+    errorType?: ErrorType;
+    outputTruncated?: boolean;
+    originalSize?: number;
+    metrics?: ResourceMetrics;
+}
+/** Container status returned by getContainerStatus */
+export interface ContainerStatus {
+    running: boolean;
+    exitCode: number | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+/** Container info returned by listContainersByPrefix */
+export interface ContainerInfo {
+    name: string;
+    running: boolean;
+    createdAt: string;
+}
+/** Result of starting a detached container */
+export interface DetachedStartResult {
+    containerName: string;
+    containerId: string;
+}
+export declare class PodmanRunner {
+    private config;
+    constructor(config: PodmanConfig);
+    runClaudeCode(params: {
+        sessionKey: string;
+        prompt: string;
+        claudeDir: string;
+        workspaceDir: string;
+        resumeSessionId?: string;
+        apiKey?: string;
+    }): Promise<ClaudeCodeResult>;
+    private buildArgs;
+    private execute;
+    private parseOutput;
+    checkImage(): Promise<boolean>;
+    killContainer(sessionKey: string): Promise<void>;
+    verifyContainerRunning(containerName: string, retries?: number): Promise<boolean>;
+    /**
+     * Get resource metrics for a running container.
+     * Returns undefined if container is not running or stats unavailable.
+     */
+    getContainerStats(containerName: string): Promise<ResourceMetrics | undefined>;
+    /**
+     * Parse memory string like "123.4MiB" or "1.2GiB" to MB
+     */
+    parseMemoryString(memStr: string | undefined): number | undefined;
+    /**
+     * Start a container in detached mode. Returns immediately with container ID.
+     */
+    startDetached(params: {
+        sessionKey: string;
+        prompt: string;
+        claudeDir: string;
+        workspaceDir: string;
+        resumeSessionId?: string;
+        apiKey?: string;
+    }): Promise<DetachedStartResult>;
+    /**
+     * Get the status of a container by name.
+     */
+    getContainerStatus(containerName: string): Promise<ContainerStatus | null>;
+    /**
+     * Get logs from a container.
+     */
+    getContainerLogs(containerName: string, opts?: {
+        since?: string;
+        tail?: number;
+    }): Promise<string | null>;
+    /**
+     * List all containers matching a name prefix.
+     */
+    listContainersByPrefix(prefix: string): Promise<ContainerInfo[]>;
+    /**
+     * Generate container name from session key.
+     */
+    containerNameFromSessionKey(sessionKey: string): string;
+    /**
+     * Extract session key from container name.
+     */
+    sessionKeyFromContainerName(containerName: string): string | null;
+}
+//# sourceMappingURL=podman-runner.d.ts.map

package/dist/podman-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"podman-runner.d.ts","sourceRoot":"","sources":["../src/podman-runner.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,SAAS,GAAG,iBAAiB,GAAG,cAAc,GAAG,KAAK,GAAG,OAAO,GAAG,cAAc,CAAC;AAE9F,MAAM,WAAW,eAAe;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AA6CD,sDAAsD;AACtD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,8CAA8C;AAC9C,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAkBD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAI1B,aAAa,CAAC,MAAM,EAAE;QAC1B,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAU7B,OAAO,CAAC,SAAS;IA4DjB,OAAO,CAAC,OAAO;IA2Kf,OAAO,CAAC,WAAW;IA6Bb,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAW9B,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBhD,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAelF;;;OAGG;IACH,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IA4D9E;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS;IA8BjE;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE;QAC1B,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA8EhC;;OAEG;IACG,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IA2ChF;;OAEG;IACG,gBAAgB,CACpB,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GACvC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAsCzB;;OAEG;IACG,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAoDtE;;OAEG;IACH,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIvD;;OAEG;IACH,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAMlE"}

package/dist/podman-runner.js

@@ -0,0 +1,537 @@
+import { spawn } from "node:child_process";
+function isClaudeCodeOutput(value) {
+    return typeof value === "object" && value !== null;
+}
+function isPodmanStatsOutput(value) {
+    return typeof value === "object" && value !== null;
+}
+function isPodmanInspectOutput(value) {
+    return typeof value === "object" && value !== null;
+}
+function isPodmanPsOutput(value) {
+    return typeof value === "object" && value !== null;
+}
+export class PodmanRunner {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async runClaudeCode(params) {
+        const containerName = `claude-${params.sessionKey.replace(/[^a-zA-Z0-9-]/g, "-")}`;
+        // Clean up stale container from previous crash
+        await this.killContainer(params.sessionKey);
+        const args = this.buildArgs(params, containerName);
+        return this.execute(args, containerName);
+    }
+    buildArgs(params, containerName) {
+        // Build the claude command to run inside bash
+        // Claude doesn't output when run as PID 1, must run through bash
+        const resumeFlag = params.resumeSessionId ? `--resume '${params.resumeSessionId}'` : "";
+        const escapedPrompt = params.prompt.replace(/'/g, "'\\''");
+        const claudeCmd = `claude --print --dangerously-skip-permissions ${resumeFlag} -p '${escapedPrompt}' < /dev/null 2>&1`;
+        const args = [
+            "run",
+            "--rm",
+            "--name",
+            containerName,
+            "--network",
+            this.config.network,
+            "--cap-drop",
+            "ALL",
+        ];
+        // Add AppArmor profile if configured
+        if (this.config.apparmorProfile) {
+            args.push("--security-opt", `apparmor=${this.config.apparmorProfile}`);
+        }
+        // Note: no --read-only, claude needs to write temp files
+        args.push("--memory", this.config.memory, "--cpus", this.config.cpus, "--pids-limit", "100", "--tmpfs", "/tmp:rw,noexec,nosuid,size=64m", 
+        // :U flag handles UID mapping for permissions
+        "-v", `${params.claudeDir}:/home/claude/.claude:U`, "-v", `${params.workspaceDir}:/workspace:U`);
+        // Only add API key if provided (otherwise uses credentials file)
+        if (params.apiKey) {
+            args.push("-e", `ANTHROPIC_API_KEY=${params.apiKey}`);
+        }
+        args.push("-w", "/workspace", "--entrypoint", "/bin/bash", this.config.image, "-c", claudeCmd);
+        return args;
+    }
+    execute(args, containerName) {
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const proc = spawn(this.config.runtime, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            let killed = false;
+            let killReason = null;
+            let lastActivity = Date.now();
+            let hadOutput = false;
+            let totalOutputSize = 0;
+            let outputTruncated = false;
+            const maxSize = this.config.maxOutputSize;
+            let lastMetrics;
+            const cleanup = () => {
+                clearTimeout(startupTimeoutId);
+                clearInterval(idleCheckInterval);
+                clearInterval(metricsInterval);
+            };
+            const killProcess = (reason) => {
+                if (killed)
+                    return;
+                killed = true;
+                killReason = reason;
+                cleanup();
+                proc.kill("SIGTERM");
+                // Give 5s for graceful shutdown, then SIGKILL
+                setTimeout(() => {
+                    if (!proc.killed) {
+                        proc.kill("SIGKILL");
+                    }
+                }, 5000);
+            };
+            // Startup timeout - must produce first output within N seconds
+            const startupTimeoutId = setTimeout(() => {
+                if (!hadOutput) {
+                    killProcess("startup_timeout");
+                }
+            }, this.config.startupTimeout * 1000);
+            // Idle timeout check - no output for N seconds = hung
+            const idleCheckInterval = setInterval(() => {
+                if (!hadOutput)
+                    return; // Still waiting for startup, don't check idle
+                const idleSeconds = (Date.now() - lastActivity) / 1000;
+                if (idleSeconds > this.config.idleTimeout) {
+                    killProcess("idle_timeout");
+                }
+            }, 5000);
+            // Periodically sample container metrics (every 10s)
+            const metricsInterval = setInterval(() => {
+                if (!hadOutput)
+                    return; // Container not started yet
+                void this.getContainerStats(containerName).then((metrics) => {
+                    if (metrics) {
+                        lastMetrics = metrics;
+                    }
+                });
+            }, 10000);
+            const onOutput = () => {
+                if (!hadOutput) {
+                    hadOutput = true;
+                    clearTimeout(startupTimeoutId);
+                }
+                lastActivity = Date.now();
+            };
+            proc.stdout.on("data", (data) => {
+                onOutput();
+                const dataStr = data.toString();
+                if (maxSize > 0 && totalOutputSize + dataStr.length > maxSize) {
+                    if (!outputTruncated) {
+                        const remaining = maxSize - totalOutputSize;
+                        stdout += dataStr.slice(0, remaining);
+                        outputTruncated = true;
+                    }
+                    totalOutputSize += dataStr.length;
+                }
+                else {
+                    stdout += dataStr;
+                    totalOutputSize += dataStr.length;
+                }
+            });
+            proc.stderr.on("data", (data) => {
+                onOutput();
+                const dataStr = data.toString();
+                if (maxSize > 0 && totalOutputSize + dataStr.length > maxSize) {
+                    if (!outputTruncated) {
+                        const remaining = maxSize - totalOutputSize;
+                        stderr += dataStr.slice(0, remaining);
+                        outputTruncated = true;
+                    }
+                    totalOutputSize += dataStr.length;
+                }
+                else {
+                    stderr += dataStr;
+                    totalOutputSize += dataStr.length;
+                }
+            });
+            proc.on("error", (err) => {
+                cleanup();
+                const elapsed = (Date.now() - startTime) / 1000;
+                reject(Object.assign(new Error(`Failed to spawn ${this.config.runtime}: ${err.message}`), {
+                    errorType: "spawn_failed",
+                    elapsedSeconds: elapsed,
+                }));
+            });
+            proc.on("close", (code, signal) => {
+                cleanup();
+                const elapsed = (Date.now() - startTime) / 1000;
+                if (killed && killReason) {
+                    const message = killReason === "startup_timeout"
+                        ? `Container startup timeout (no output for ${String(this.config.startupTimeout)}s)`
+                        : `Container idle timeout (no output for ${String(this.config.idleTimeout)}s) after ${elapsed.toFixed(1)}s total`;
+                    reject(Object.assign(new Error(message), {
+                        errorType: killReason,
+                        elapsedSeconds: elapsed,
+                    }));
+                    return;
+                }
+                if (signal === "SIGKILL" || code === 137) {
+                    reject(Object.assign(new Error(`Container killed (OOM or resource limit) after ${elapsed.toFixed(1)}s: ${stderr || stdout}`), { errorType: "oom", elapsedSeconds: elapsed }));
+                    return;
+                }
+                if (code !== 0) {
+                    reject(Object.assign(new Error(`Container failed (exit ${String(code)}) after ${elapsed.toFixed(1)}s: ${stderr || stdout}`), { errorType: "crash", elapsedSeconds: elapsed }));
+                    return;
+                }
+                const result = this.parseOutput(stdout, code);
+                result.elapsedSeconds = elapsed;
+                if (outputTruncated) {
+                    result.outputTruncated = true;
+                    result.originalSize = totalOutputSize;
+                }
+                if (lastMetrics) {
+                    result.metrics = lastMetrics;
+                }
+                resolve(result);
+            });
+        });
+    }
+    parseOutput(output, exitCode) {
+        // Claude Code --print outputs JSON when available
+        // Try to parse as JSON first
+        try {
+            const lines = output.trim().split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const line = lines[i].trim();
+                if (line.startsWith("{") && line.endsWith("}")) {
+                    const parsed = JSON.parse(line);
+                    if (isClaudeCodeOutput(parsed)) {
+                        return {
+                            content: parsed.result ?? parsed.content ?? parsed.message ?? output,
+                            sessionId: parsed.session_id ?? parsed.sessionId ?? null,
+                            exitCode,
+                        };
+                    }
+                }
+            }
+        }
+        catch {
+            // Not JSON, use raw output
+        }
+        return {
+            content: output.trim(),
+            sessionId: null,
+            exitCode,
+        };
+    }
+    async checkImage() {
+        return new Promise((resolve) => {
+            const proc = spawn(this.config.runtime, ["image", "exists", this.config.image], {
+                stdio: "ignore",
+            });
+            proc.on("error", () => resolve(false));
+            proc.on("close", (code) => resolve(code === 0));
+        });
+    }
+    async killContainer(sessionKey) {
+        const containerName = `claude-${sessionKey.replace(/[^a-zA-Z0-9-]/g, "-")}`;
+        // First try to kill, then remove (in case it's stopped but not removed)
+        await new Promise((resolve) => {
+            const proc = spawn(this.config.runtime, ["kill", containerName], {
+                stdio: "ignore",
+            });
+            proc.on("error", () => resolve());
+            proc.on("close", () => resolve());
+        });
+        await new Promise((resolve) => {
+            const proc = spawn(this.config.runtime, ["rm", "-f", containerName], {
+                stdio: "ignore",
+            });
+            proc.on("error", () => resolve());
+            proc.on("close", () => resolve());
+        });
+    }
+    async verifyContainerRunning(containerName, retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            await new Promise((r) => setTimeout(r, 500));
+            const exists = await new Promise((resolve) => {
+                const proc = spawn(this.config.runtime, ["container", "exists", containerName], {
+                    stdio: "ignore",
+                });
+                proc.on("close", (code) => resolve(code === 0));
+                proc.on("error", () => resolve(false));
+            });
+            if (exists)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Get resource metrics for a running container.
+     * Returns undefined if container is not running or stats unavailable.
+     */
+    getContainerStats(containerName) {
+        return new Promise((resolve) => {
+            const proc = spawn(this.config.runtime, ["stats", "--no-stream", "--format", "json", containerName], { stdio: ["ignore", "pipe", "ignore"] });
+            let stdout = "";
+            let timeoutId = null;
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.on("error", () => resolve(undefined));
+            proc.on("close", (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (code !== 0) {
+                    resolve(undefined);
+                    return;
+                }
+                try {
+                    const stats = JSON.parse(stdout);
+                    // Podman stats JSON format - may be array or single object
+                    const statArray = Array.isArray(stats) ? stats : [stats];
+                    const stat = statArray[0];
+                    if (!isPodmanStatsOutput(stat)) {
+                        resolve(undefined);
+                        return;
+                    }
+                    const memUsage = this.parseMemoryString(stat.MemUsage ?? stat.mem_usage);
+                    const memLimit = this.parseMemoryString(stat.MemLimit ?? stat.mem_limit);
+                    resolve({
+                        memoryUsageMB: memUsage,
+                        memoryLimitMB: memLimit,
+                        memoryPercent: stat.MemPerc
+                            ? parseFloat(String(stat.MemPerc).replace("%", ""))
+                            : undefined,
+                        cpuPercent: stat.CPUPerc
+                            ? parseFloat(String(stat.CPUPerc).replace("%", ""))
+                            : undefined,
+                    });
+                }
+                catch {
+                    resolve(undefined);
+                }
+            });
+            // Timeout after 5s
+            timeoutId = setTimeout(() => {
+                proc.kill();
+                resolve(undefined);
+            }, 5000);
+        });
+    }
+    /**
+     * Parse memory string like "123.4MiB" or "1.2GiB" to MB
+     */
+    parseMemoryString(memStr) {
+        if (!memStr)
+            return undefined;
+        // Handle "used / limit" format (e.g., "256MiB / 512MiB")
+        const parts = memStr.split("/");
+        const valueStr = parts[0].trim();
+        const match = /^([\d.]+)\s*(B|KB|KiB|MB|MiB|GB|GiB)/i.exec(valueStr);
+        if (!match)
+            return undefined;
+        const value = parseFloat(match[1]);
+        const unit = match[2].toLowerCase();
+        switch (unit) {
+            case "b":
+                return value / (1024 * 1024);
+            case "kb":
+            case "kib":
+                return value / 1024;
+            case "mb":
+            case "mib":
+                return value;
+            case "gb":
+            case "gib":
+                return value * 1024;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Start a container in detached mode. Returns immediately with container ID.
+     */
+    async startDetached(params) {
+        const containerName = `claude-${params.sessionKey.replace(/[^a-zA-Z0-9-]/g, "-")}`;
+        // Clean up stale container from previous run
+        await this.killContainer(params.sessionKey);
+        // Build the claude command
+        const resumeFlag = params.resumeSessionId ? `--resume '${params.resumeSessionId}'` : "";
+        const escapedPrompt = params.prompt.replace(/'/g, "'\\''");
+        const claudeCmd = `claude --print --dangerously-skip-permissions ${resumeFlag} -p '${escapedPrompt}' < /dev/null 2>&1`;
+        const args = [
+            "run",
+            "--detach",
+            "--name",
+            containerName,
+            "--network",
+            this.config.network,
+            "--cap-drop",
+            "ALL",
+        ];
+        if (this.config.apparmorProfile) {
+            args.push("--security-opt", `apparmor=${this.config.apparmorProfile}`);
+        }
+        args.push("--memory", this.config.memory, "--cpus", this.config.cpus, "--pids-limit", "100", "--tmpfs", "/tmp:rw,noexec,nosuid,size=64m", "-v", `${params.claudeDir}:/home/claude/.claude:U`, "-v", `${params.workspaceDir}:/workspace:U`);
+        if (params.apiKey) {
+            args.push("-e", `ANTHROPIC_API_KEY=${params.apiKey}`);
+        }
+        args.push("-w", "/workspace", "--entrypoint", "/bin/bash", this.config.image, "-c", claudeCmd);
+        return new Promise((resolve, reject) => {
+            const proc = spawn(this.config.runtime, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("error", (err) => {
+                reject(new Error(`Failed to spawn ${this.config.runtime}: ${err.message}`));
+            });
+            proc.on("close", (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Failed to start container: ${stderr || stdout}`));
+                    return;
+                }
+                const containerId = stdout.trim();
+                resolve({ containerName, containerId });
+            });
+        });
+    }
+    /**
+     * Get the status of a container by name.
+     */
+    async getContainerStatus(containerName) {
+        return new Promise((resolve) => {
+            const proc = spawn(this.config.runtime, ["inspect", "--format", "json", containerName], {
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            let stdout = "";
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.on("error", () => resolve(null));
+            proc.on("close", (code) => {
+                if (code !== 0) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(stdout);
+                    const inspectArray = Array.isArray(parsed) ? parsed : [parsed];
+                    const inspect = inspectArray[0];
+                    if (!isPodmanInspectOutput(inspect) || !inspect.State) {
+                        resolve(null);
+                        return;
+                    }
+                    const state = inspect.State;
+                    resolve({
+                        running: state.Running ?? false,
+                        exitCode: state.ExitCode ?? null,
+                        startedAt: state.StartedAt ?? null,
+                        finishedAt: state.FinishedAt ?? null,
+                    });
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    /**
+     * Get logs from a container.
+     */
+    async getContainerLogs(containerName, opts) {
+        return new Promise((resolve) => {
+            const args = ["logs"];
+            if (opts?.since) {
+                args.push("--since", opts.since);
+            }
+            if (opts?.tail !== undefined) {
+                args.push("--tail", String(opts.tail));
+            }
+            args.push(containerName);
+            const proc = spawn(this.config.runtime, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let output = "";
+            proc.stdout.on("data", (data) => {
+                output += data.toString();
+            });
+            proc.stderr.on("data", (data) => {
+                output += data.toString();
+            });
+            proc.on("error", () => resolve(null));
+            proc.on("close", (code) => {
+                if (code !== 0) {
+                    resolve(null);
+                    return;
+                }
+                resolve(output);
+            });
+        });
+    }
+    /**
+     * List all containers matching a name prefix.
+     */
+    async listContainersByPrefix(prefix) {
+        return new Promise((resolve) => {
+            const proc = spawn(this.config.runtime, ["ps", "-a", "--filter", `name=^${prefix}`, "--format", "json"], { stdio: ["ignore", "pipe", "ignore"] });
+            let stdout = "";
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.on("error", () => resolve([]));
+            proc.on("close", (code) => {
+                if (code !== 0) {
+                    resolve([]);
+                    return;
+                }
+                try {
+                    // Podman outputs one JSON object per line
+                    const lines = stdout.trim().split("\n").filter(Boolean);
+                    const containers = [];
+                    for (const line of lines) {
+                        const parsed = JSON.parse(line);
+                        if (!isPodmanPsOutput(parsed))
+                            continue;
+                        const name = Array.isArray(parsed.Names) ? parsed.Names[0] : parsed.Names;
+                        if (!name)
+                            continue;
+                        const running = parsed.State === "running" ||
+                            (typeof parsed.Status === "string" && parsed.Status.startsWith("Up"));
+                        containers.push({
+                            name,
+                            running,
+                            createdAt: parsed.Created ?? parsed.CreatedAt ?? "",
+                        });
+                    }
+                    resolve(containers);
+                }
+                catch {
+                    resolve([]);
+                }
+            });
+        });
+    }
+    /**
+     * Generate container name from session key.
+     */
+    containerNameFromSessionKey(sessionKey) {
+        return `claude-${sessionKey.replace(/[^a-zA-Z0-9-]/g, "-")}`;
+    }
+    /**
+     * Extract session key from container name.
+     */
+    sessionKeyFromContainerName(containerName) {
+        if (!containerName.startsWith("claude-")) {
+            return null;
+        }
+        return containerName.slice(7); // Remove "claude-" prefix
+    }
+}
+//# sourceMappingURL=podman-runner.js.map