@paperpod/cli 0.1.0

package/dist/commands.js

@@ -0,0 +1,1053 @@
+/**
+ * CLI Commands
+ *
+ * Command implementations for the ppod CLI.
+ */
+import * as fs from "fs";
+import * as readline from "readline";
+import { getTransport } from "./transport.js";
+import { getToken, saveToken, clearToken } from "./config.js";
+// ============================================================================
+// ASCII Art
+// ============================================================================
+const PAPERPOD_WELCOME = `
+ ██████╗  █████╗ ██████╗ ███████╗██████╗ ██████╗  ██████╗ ██████╗ 
+ ██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
+ ██████╔╝███████║██████╔╝█████╗  ██████╔╝██████╔╝██║   ██║██║  ██║
+ ██╔═══╝ ██╔══██║██╔═══╝ ██╔══╝  ██╔══██╗██╔═══╝ ██║   ██║██║  ██║
+ ██║     ██║  ██║██║     ███████╗██║  ██║██║     ╚██████╔╝██████╔╝
+ ╚═╝     ╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝      ╚═════╝ ╚═════╝ 
+
+  Welcome to PaperPod! Token saved to ~/.paperpod/config.json
+
+  Get started:
+    ppod exec "echo Hello, World!"
+    ppod exec "python -c 'print(1+1)'"
+    ppod status
+    ppod help
+
+  Docs: https://paperpod.dev/docs
+`;
+const PAPERPOD_LOGIN_HELP = `
+ ██████╗  █████╗ ██████╗ ███████╗██████╗ ██████╗  ██████╗ ██████╗ 
+ ██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
+ ██████╔╝███████║██████╔╝█████╗  ██████╔╝██████╔╝██║   ██║██║  ██║
+ ██╔═══╝ ██╔══██║██╔═══╝ ██╔══╝  ██╔══██╗██╔═══╝ ██║   ██║██║  ██║
+ ██║     ██║  ██║██║     ███████╗██║  ██║██║     ╚██████╔╝██████╔╝
+ ╚═╝     ╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝      ╚═════╝ ╚═════╝ 
+
+  To get your PaperPod token:
+
+  1. Request a magic link:
+     curl -X POST https://paperpod.dev/login \\
+       -H "Content-Type: application/json" \\
+       -d '{"email": "you@example.com"}'
+
+  2. Check your email and click the magic link
+
+  3. Copy the pp_sess_... token from the success page
+
+  4. Run: ppod login pp_sess_...
+
+  Docs: https://paperpod.dev/docs
+`;
+export async function execCommand(command, options = {}) {
+    const transport = getTransport();
+    const transportOpts = {
+        timeout: options.timeout,
+    };
+    // Stream output if --stream or by default
+    if (options.stream !== false) {
+        transportOpts.onStdout = (text) => process.stdout.write(text);
+        transportOpts.onStderr = (text) => process.stderr.write(text);
+    }
+    try {
+        const result = await transport.exec(command, transportOpts);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (!options.stream) {
+            // Non-streaming mode: print output after completion
+            if (result.stdout)
+                process.stdout.write(result.stdout);
+            if (result.stderr)
+                process.stderr.write(result.stderr);
+        }
+        return result.exitCode;
+    }
+    catch (err) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return 1;
+    }
+    finally {
+        // Close connection after single command (unless in session mode)
+        transport.disconnect();
+    }
+}
+export async function writeCommand(remotePath, localPath, options = {}) {
+    const transport = getTransport();
+    try {
+        let content;
+        if (localPath) {
+            // Read from local file
+            if (!fs.existsSync(localPath)) {
+                console.error(`Error: File not found: ${localPath}`);
+                return 1;
+            }
+            content = fs.readFileSync(localPath, "utf-8");
+        }
+        else {
+            // Read from stdin
+            content = await readStdin();
+        }
+        await transport.writeFile(remotePath, content, { timeout: options.timeout });
+        console.log(`Written: ${remotePath}`);
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function readCommand(remotePath, options = {}) {
+    const transport = getTransport();
+    try {
+        const content = await transport.readFile(remotePath, { timeout: options.timeout });
+        if (options.output) {
+            fs.writeFileSync(options.output, content);
+            console.error(`Written to: ${options.output}`);
+        }
+        else {
+            process.stdout.write(content);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function listCommand(remotePath, options = {}) {
+    const transport = getTransport();
+    try {
+        const files = await transport.listDir(remotePath, { timeout: options.timeout });
+        if (options.json) {
+            console.log(JSON.stringify(files, null, 2));
+        }
+        else {
+            for (const file of files) {
+                const prefix = file.isDirectory ? "d" : "-";
+                const size = file.size.toString().padStart(10);
+                console.log(`${prefix} ${size}  ${file.name}`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+// ============================================================================
+// Login Command
+// ============================================================================
+export async function loginCommand(token) {
+    if (token) {
+        // Token provided as argument
+        saveToken(token);
+        console.log(PAPERPOD_WELCOME);
+        return 0;
+    }
+    // Show how to get a token first
+    console.log(PAPERPOD_LOGIN_HELP);
+    // Interactive mode - prompt for token
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question("Enter your PaperPod token (or press Enter to exit): ", (answer) => {
+            rl.close();
+            if (answer.trim()) {
+                saveToken(answer.trim());
+                console.log("\n✓ Token saved to ~/.paperpod/config.json\n");
+                console.log("  Get started: ppod exec \"echo Hello, World!\"");
+                resolve(0);
+            }
+            else {
+                console.log("No token provided. Run 'ppod login <token>' when you have one.");
+                resolve(1);
+            }
+        });
+    });
+}
+// ============================================================================
+// Logout Command
+// ============================================================================
+export async function logoutCommand() {
+    clearToken();
+    console.log("Token cleared from ~/.paperpod/config.json");
+    return 0;
+}
+// ============================================================================
+// Status Command
+// ============================================================================
+export async function statusCommand() {
+    const token = getToken();
+    console.log("PaperPod CLI Status");
+    console.log("-------------------");
+    console.log(`Token: ${token ? "Set" : "Not set"}`);
+    if (token) {
+        const source = process.env.PAPERPOD_TOKEN ? "PAPERPOD_TOKEN env var" : "~/.paperpod/config.json";
+        console.log(`Source: ${source}`);
+    }
+    // Test connection
+    if (token) {
+        console.log("\nTesting connection...");
+        const transport = getTransport();
+        try {
+            const sandboxId = await transport.connect({ timeout: 10000 });
+            console.log(`Connected! Sandbox: ${sandboxId}`);
+            transport.disconnect();
+        }
+        catch (err) {
+            console.error(`Connection failed: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+    }
+    return 0;
+}
+export async function exposeCommand(port, options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.expose(port, { timeout: options.timeout });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`✓ Port ${port} exposed`);
+            console.log(`  URL: ${result.url}`);
+            if (result.wsUrl) {
+                console.log(`  WebSocket: ${result.wsUrl}`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+/**
+ * Helper to wrap a browser operation with tracing
+ */
+async function withTrace(transport, traceOutput, operation) {
+    if (!traceOutput) {
+        return { result: await operation() };
+    }
+    // Start tracing
+    await transport.browserTrace("start", {});
+    console.log("📍 Tracing enabled...");
+    try {
+        // Run the operation
+        const result = await operation();
+        // Stop tracing and get data
+        const traceResult = await transport.browserTrace("stop", {});
+        if (traceResult.traceData) {
+            const traceBuffer = Buffer.from(traceResult.traceData, "base64");
+            fs.writeFileSync(traceOutput, traceBuffer);
+            console.log(`📍 Trace saved to ${traceOutput}`);
+        }
+        return { result, traceData: traceResult.traceData };
+    }
+    catch (err) {
+        // Try to stop tracing even on error
+        try {
+            await transport.browserTrace("stop", {});
+        }
+        catch {
+            // Ignore trace stop errors
+        }
+        throw err;
+    }
+}
+export async function screenshotCommand(url, options = {}) {
+    const transport = getTransport();
+    try {
+        const { result } = await withTrace(transport, options.trace, () => transport.browserScreenshot(url, {
+            timeout: options.timeout,
+            fullPage: options.fullPage,
+            width: options.width,
+            height: options.height,
+            format: options.format,
+        }));
+        if (options.output) {
+            // Write base64 image to file
+            const buffer = Buffer.from(result.image, "base64");
+            fs.writeFileSync(options.output, buffer);
+            console.log(`Screenshot saved to ${options.output}`);
+        }
+        else if (options.json) {
+            console.log(JSON.stringify({ ...result, image: `[${result.image.length} bytes base64]` }, null, 2));
+        }
+        else {
+            console.log(`Screenshot: ${result.width}x${result.height} ${result.format}`);
+            console.log(`Use -o <file> to save the image`);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function pdfCommand(url, options = {}) {
+    const transport = getTransport();
+    try {
+        const { result } = await withTrace(transport, options.trace, () => transport.browserPdf(url, {
+            timeout: options.timeout,
+            format: options.paperFormat,
+            landscape: options.landscape,
+        }));
+        if (options.output) {
+            const buffer = Buffer.from(result.pdf, "base64");
+            fs.writeFileSync(options.output, buffer);
+            console.log(`PDF saved to ${options.output} (${result.pages} pages)`);
+        }
+        else if (options.json) {
+            console.log(JSON.stringify({ pages: result.pages, pdf: `[${result.pdf.length} bytes base64]` }, null, 2));
+        }
+        else {
+            console.log(`PDF generated: ${result.pages} pages`);
+            console.log(`Use -o <file> to save the PDF`);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function scrapeCommand(url, selector, options = {}) {
+    const transport = getTransport();
+    try {
+        const { result } = await withTrace(transport, options.trace, () => transport.browserScrape(url, selector, {
+            timeout: options.timeout,
+            limit: options.limit,
+        }));
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Found ${result.elements.length} elements matching "${selector}":`);
+            for (const el of result.elements) {
+                console.log(`  - ${el.text.slice(0, 100)}${el.text.length > 100 ? "..." : ""}`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function markdownCommand(url, options = {}) {
+    const transport = getTransport();
+    try {
+        const { result } = await withTrace(transport, options.trace, () => transport.browserMarkdown(url, {
+            timeout: options.timeout,
+        }));
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (options.output) {
+            fs.writeFileSync(options.output, result.markdown);
+            console.log(`✓ Markdown saved to ${options.output}`);
+        }
+        else {
+            console.log(result.markdown);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function contentCommand(url, options = {}) {
+    const transport = getTransport();
+    try {
+        const { result } = await withTrace(transport, options.trace, () => transport.browserContent(url, {
+            timeout: options.timeout,
+        }));
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (options.output) {
+            fs.writeFileSync(options.output, result.html);
+            console.log(`✓ HTML saved to ${options.output}`);
+        }
+        else {
+            console.log(result.html);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function traceCommand(action, options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.browserTrace(action, {
+            timeout: options.timeout,
+            sessionId: options.sessionId,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (action === "start") {
+            console.log(`✓ Tracing started${result.sessionId ? ` (session: ${result.sessionId})` : ""}`);
+        }
+        else if (action === "stop" && result.traceData) {
+            if (options.output) {
+                const traceBuffer = Buffer.from(result.traceData, "base64");
+                fs.writeFileSync(options.output, traceBuffer);
+                console.log(`✓ Trace saved to ${options.output}`);
+            }
+            else {
+                console.log(`Trace data: ${result.traceData.length} bytes (base64)`);
+                console.log(`Use -o trace.zip to save`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function testCommand(url, assertionsJson, options = {}) {
+    const transport = getTransport();
+    try {
+        let assertions;
+        try {
+            assertions = JSON.parse(assertionsJson);
+        }
+        catch {
+            console.error("Error: Assertions must be valid JSON array");
+            console.error('Example: \'[{"type":"visible","selector":"h1"},{"type":"text","selector":"h1","expected":"Hello"}]\'');
+            return 1;
+        }
+        const result = await transport.browserTest(url, assertions, {
+            timeout: options.timeout,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Test ${result.passed ? "PASSED ✓" : "FAILED ✗"}`);
+            for (const r of result.results) {
+                const status = r.passed ? "✓" : "✗";
+                console.log(`  ${status} ${r.assertion}${r.error ? `: ${r.error}` : ""}`);
+            }
+        }
+        return result.passed ? 0 : 1;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function browserSessionsCommand(options = {}) {
+    const transport = getTransport();
+    try {
+        const sessions = await transport.browserSessions({
+            timeout: options.timeout,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(sessions, null, 2));
+        }
+        else if (sessions.length === 0) {
+            console.log("No active browser sessions");
+        }
+        else {
+            console.log("Active browser sessions:");
+            for (const s of sessions) {
+                console.log(`  ${s.sessionId} - ${s.url ?? "no URL"} (created: ${s.createdAt})`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function browserLimitsCommand(options = {}) {
+    const transport = getTransport();
+    try {
+        const limits = await transport.browserLimits({
+            timeout: options.timeout,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(limits, null, 2));
+        }
+        else {
+            console.log("Browser limits:");
+            console.log(`  Max concurrent sessions: ${limits.maxConcurrent}`);
+            console.log(`  Currently active: ${limits.currentActive}`);
+            console.log(`  Max session duration: ${limits.maxSessionDuration / 1000}s`);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function aiGenerateCommand(prompt, options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.aiGenerate(prompt, {
+            timeout: options.timeout,
+            model: options.model,
+            systemPrompt: options.systemPrompt,
+            maxTokens: options.maxTokens,
+            temperature: options.temperature,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(result.text);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function aiEmbedCommand(text, options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.aiEmbed(text, {
+            timeout: options.timeout,
+            model: options.model,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Model: ${result.model}`);
+            console.log(`Dimensions: ${result.embeddings[0]?.length ?? 0}`);
+            console.log(`Embeddings: ${result.embeddings.length} vector(s)`);
+            // Show first few dimensions as preview
+            if (result.embeddings[0]) {
+                const preview = result.embeddings[0].slice(0, 5).map(n => n.toFixed(4)).join(", ");
+                console.log(`Preview: [${preview}, ...]`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function aiImageCommand(prompt, options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.aiImage(prompt, {
+            timeout: options.timeout ?? 120000, // Images take longer
+            model: options.model,
+            width: options.width,
+            height: options.height,
+        });
+        // Check for empty image and warn user
+        if (!result.image || result.image.length === 0) {
+            console.error("⚠ Warning: Image generation returned empty data");
+            console.error("  This may be a temporary issue with the image model.");
+            console.error("  Try again or use a different model with --model <name>");
+            if (options.json) {
+                console.log(JSON.stringify({ ...result, warning: "Image data empty" }, null, 2));
+            }
+            return 1;
+        }
+        if (options.output) {
+            const imageBuffer = Buffer.from(result.image, "base64");
+            fs.writeFileSync(options.output, imageBuffer);
+            console.log(`✓ Image saved to ${options.output} (${imageBuffer.length} bytes)`);
+        }
+        else if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Model: ${result.model}`);
+            console.log(`Image: ${result.image.length} bytes (base64)`);
+            console.log(`Use -o filename.png to save`);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function aiTranscribeCommand(audioPath, options = {}) {
+    const transport = getTransport();
+    try {
+        if (!fs.existsSync(audioPath)) {
+            console.error(`Error: File not found: ${audioPath}`);
+            return 1;
+        }
+        const audioBuffer = fs.readFileSync(audioPath);
+        const audioBase64 = audioBuffer.toString("base64");
+        const result = await transport.aiTranscribe(audioBase64, {
+            timeout: options.timeout ?? 120000, // Transcription takes longer
+            model: options.model,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(result.text);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function interpretCommand(code, options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.interpret(code, {
+            timeout: options.timeout,
+            language: options.language,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            for (const item of result.results) {
+                if (item.type === "text" && item.text) {
+                    console.log(item.text);
+                }
+                else if (item.type === "image" && item.data) {
+                    console.log(`[Image: ${item.mimeType ?? "image/png"}, ${item.data.length} bytes base64]`);
+                }
+                else if (item.type === "error" && item.text) {
+                    console.error(`Error: ${item.text}`);
+                }
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function memoryWriteCommand(path, localPath, options = {}) {
+    const transport = getTransport();
+    try {
+        let content;
+        if (localPath) {
+            if (!fs.existsSync(localPath)) {
+                console.error(`Error: File not found: ${localPath}`);
+                return 1;
+            }
+            content = fs.readFileSync(localPath, "utf-8");
+        }
+        else {
+            content = await readStdin();
+        }
+        await transport.memoryWrite(path, content, { timeout: options.timeout });
+        console.log(`✓ Written to memory: ${path}`);
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function memoryReadCommand(path, options = {}) {
+    const transport = getTransport();
+    try {
+        const content = await transport.memoryRead(path, { timeout: options.timeout });
+        if (options.output) {
+            fs.writeFileSync(options.output, content);
+            console.log(`Memory content written to ${options.output}`);
+        }
+        else {
+            process.stdout.write(content);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function memoryListCommand(prefix, options = {}) {
+    const transport = getTransport();
+    try {
+        const files = await transport.memoryList(prefix, { timeout: options.timeout });
+        if (options.json) {
+            console.log(JSON.stringify(files, null, 2));
+        }
+        else {
+            if (files.length === 0) {
+                console.log("No files in memory");
+            }
+            else {
+                console.log(`Memory files${prefix ? ` (prefix: ${prefix})` : ""}:`);
+                for (const file of files) {
+                    const size = file.size.toString().padStart(10);
+                    console.log(`  ${size}  ${file.path}`);
+                }
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function memoryDeleteCommand(path, options = {}) {
+    const transport = getTransport();
+    try {
+        await transport.memoryDelete(path, { timeout: options.timeout });
+        console.log(`✓ Deleted from memory: ${path}`);
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function memoryUsageCommand(options = {}) {
+    const transport = getTransport();
+    try {
+        const usage = await transport.memoryUsage({ timeout: options.timeout });
+        if (options.json) {
+            console.log(JSON.stringify(usage, null, 2));
+        }
+        else {
+            const usedMB = (usage.usedBytes / 1024 / 1024).toFixed(2);
+            const quotaMB = (usage.quotaBytes / 1024 / 1024).toFixed(0);
+            const pct = ((usage.usedBytes / usage.quotaBytes) * 100).toFixed(1);
+            console.log(`Memory usage: ${usedMB} MB / ${quotaMB} MB (${pct}%)`);
+            console.log(`Files: ${usage.fileCount}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function processStartCommand(command, options = {}) {
+    const transport = getTransport();
+    try {
+        // Wait 2s for port detection suggestions (server detects after ~1.5s)
+        const result = await transport.processStart(command, {
+            timeout: options.timeout,
+            processId: options.processId,
+            waitForSuggestions: 2000,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`✓ Process started: ${result.processId}`);
+            if (result.pid) {
+                console.log(`  PID: ${result.pid}`);
+            }
+            // Show port detection suggestions
+            for (const suggestion of result.suggestions) {
+                if (suggestion.category === "port_detected" && suggestion.action?.port) {
+                    console.log(`\n💡 Detected server on port ${suggestion.action.port}`);
+                    console.log(`   Run: ppod expose ${suggestion.action.port}`);
+                }
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function processListCommand(options = {}) {
+    const transport = getTransport();
+    try {
+        const processes = await transport.processList({ timeout: options.timeout });
+        if (options.json) {
+            console.log(JSON.stringify(processes, null, 2));
+        }
+        else {
+            if (processes.length === 0) {
+                console.log("No running processes");
+            }
+            else {
+                console.log("Running processes:");
+                for (const proc of processes) {
+                    console.log(`  ${proc.processId} [${proc.status}] ${proc.command}`);
+                }
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+export async function processKillCommand(processId, options = {}) {
+    const transport = getTransport();
+    try {
+        await transport.processKill(processId, { timeout: options.timeout });
+        console.log(`✓ Process killed: ${processId}`);
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+// ============================================================================
+// Balance Command
+// ============================================================================
+export async function balanceCommand(options = {}) {
+    const transport = getTransport();
+    try {
+        const result = await transport.balance({ timeout: options.timeout });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            const total = (result.balance / 1_000_000).toFixed(2);
+            const free = (result.freeCredits / 1_000_000).toFixed(2);
+            const paid = (result.paidCredits / 1_000_000).toFixed(2);
+            console.log(`Balance: $${total}`);
+            console.log(`  Free credits:  $${free}`);
+            console.log(`  Paid credits:  $${paid}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    finally {
+        transport.disconnect();
+    }
+}
+// ============================================================================
+// Help Command
+// ============================================================================
+const VERSION = "0.2.0";
+const HELP_TEXT = `
+ ██████╗  █████╗ ██████╗ ███████╗██████╗ ██████╗  ██████╗ ██████╗ 
+ ██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
+ ██████╔╝███████║██████╔╝█████╗  ██████╔╝██████╔╝██║   ██║██║  ██║
+ ██╔═══╝ ██╔══██║██╔═══╝ ██╔══╝  ██╔══██╗██╔═══╝ ██║   ██║██║  ██║
+ ██║     ██║  ██║██║     ███████╗██║  ██║██║     ╚██████╔╝██████╔╝
+ ╚═╝     ╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝      ╚═════╝ ╚═════╝ 
+                                              cli v${VERSION}
+
+USAGE:
+  ppod <command> [options]
+
+COMMANDS:
+  Sandbox:
+    exec <command>              Execute a shell command
+    write <path> [file]         Write file (stdin if no file)
+    read <path>                 Read file from sandbox
+    ls [path]                   List directory contents
+
+  Processes:
+    ps                          List running processes
+    start <command>             Start background process
+    kill <id>                   Kill a process
+
+  Ports:
+    expose <port>               Expose port → get public URL
+
+  Browser (use browser: prefix or short form):
+    browser:screenshot <url>    Take screenshot (-o file.png)
+    browser:pdf <url>           Generate PDF (-o file.pdf)
+    browser:scrape <url> [sel]  Scrape elements (default: body)
+    browser:markdown <url>      Extract markdown
+    browser:content <url>       Get rendered HTML
+    browser:trace start|stop    Browser tracing
+    browser:test <url> <json>   Run assertions
+    browser:sessions            List active sessions
+    browser:limits              Check browser limits
+
+  AI:
+    ai <prompt>                 Generate text with LLM
+    ai:embed <text>             Generate embeddings
+    ai:image <prompt>           Generate image (-o file.png)
+    ai:transcribe <audio>       Transcribe audio to text
+
+  Code:
+    interpret <code>            Rich output (charts, images)
+
+  Memory (persistent):
+    mem:write <path> [file]     Write to memory
+    mem:read <path>             Read from memory
+    mem:ls [prefix]             List memory files
+    mem:rm <path>               Delete from memory
+    mem:usage                   Check quota
+
+  Account:
+    login [token]               Save auth token
+    logout                      Clear token
+    status                      Connection status
+    balance                     Check credit balance
+
+OPTIONS:
+  --timeout <ms>          Command timeout (default: 60000)
+  --json                  Output as JSON
+  --no-stream             Disable streaming (exec only)
+  -o, --output <file>     Save output to file
+  -h, --help              Show help for a command
+  --trace <file>          Capture browser trace (browser:* commands)
+
+EXAMPLES:
+  ppod exec "python train.py"
+  ppod start "node server.js" && ppod expose 3000
+  ppod browser:screenshot https://example.com -o shot.png
+  ppod browser:scrape https://example.com ".article"
+  ppod ai "Write a haiku about coding"
+  ppod ai:image "A sunset over mountains" -o sunset.png
+  ppod mem:write state.json ./local.json
+  
+  # Per-command help:
+  ppod browser:screenshot --help
+  ppod ai --help
+
+UPDATE:
+  npm update -g @paperpod/cli
+
+ENVIRONMENT:
+  PAPERPOD_TOKEN          Auth token (overrides config)
+  PAPERPOD_API_URL        API URL (default: wss://paperpod.dev/ws)
+
+Docs: https://paperpod.dev/docs
+`;
+export function helpCommand() {
+    console.log(HELP_TEXT);
+    return 0;
+}
+export function versionCommand() {
+    console.log(`ppod v${VERSION}`);
+    return 0;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            resolve(data);
+        });
+        process.stdin.on("error", reject);
+    });
+}
+//# sourceMappingURL=commands.js.map