@paperpod/cli 0.1.0

package/dist/transport.js

@@ -0,0 +1,684 @@
+/**
+ * WebSocket Transport
+ *
+ * Handles WebSocket connection to PaperPod server.
+ * Provides a simple request/response interface over WebSocket.
+ *
+ * Note: The server derives sandbox ID from the authenticated user's
+ * identity (email). No client-side session tracking needed.
+ */
+import WebSocket from "ws";
+import { getToken, getApiUrl, DEFAULT_TIMEOUT } from "./config.js";
+// ============================================================================
+// Transport Class
+// ============================================================================
+export class PaperpodTransport {
+    ws = null;
+    sandboxId = null;
+    pendingRequests = new Map();
+    globalSuggestionHandler = null;
+    messageIdCounter = 0;
+    /**
+     * Connect to PaperPod WebSocket server
+     *
+     * The server derives the sandbox ID from your authenticated identity.
+     * Same token → same user → same sandbox.
+     */
+    async connect(options = {}) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            return this.sandboxId;
+        }
+        const token = getToken();
+        if (!token) {
+            throw new Error("No token found. Set PAPERPOD_TOKEN env var or run: ppod login");
+        }
+        const url = getApiUrl();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error("Connection timeout"));
+                this.ws?.close();
+            }, options.timeout ?? DEFAULT_TIMEOUT);
+            this.ws = new WebSocket(url, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            this.ws.on("open", () => {
+                // Wait for connected message
+            });
+            this.ws.on("message", (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    // Handle connection acknowledgment
+                    if (message.type === "connected") {
+                        clearTimeout(timeout);
+                        this.sandboxId = message.data?.sessionId || null;
+                        resolve(this.sandboxId);
+                        return;
+                    }
+                    // Handle streaming output
+                    if (message.type === "stdout" && message.id) {
+                        const pending = this.pendingRequests.get(message.id);
+                        if (pending?.onStdout) {
+                            pending.onStdout(message.data?.text ?? "");
+                        }
+                        return;
+                    }
+                    if (message.type === "stderr" && message.id) {
+                        const pending = this.pendingRequests.get(message.id);
+                        if (pending?.onStderr) {
+                            pending.onStderr(message.data?.text ?? "");
+                        }
+                        return;
+                    }
+                    // Handle suggestion messages (port detection, etc.)
+                    if (message.type === "suggestion") {
+                        const suggestionData = message.data;
+                        if (suggestionData) {
+                            // Try request-specific handler first, then global
+                            if (message.id) {
+                                const pending = this.pendingRequests.get(message.id);
+                                if (pending?.onSuggestion) {
+                                    pending.onSuggestion(suggestionData);
+                                    return;
+                                }
+                            }
+                            // Fall back to global handler
+                            if (this.globalSuggestionHandler) {
+                                this.globalSuggestionHandler(suggestionData);
+                            }
+                        }
+                        return;
+                    }
+                    // Handle result/exit/error responses
+                    if (message.id && (message.type === "result" || message.type === "exit" || message.type === "error")) {
+                        const pending = this.pendingRequests.get(message.id);
+                        if (pending) {
+                            this.pendingRequests.delete(message.id);
+                            pending.resolve(message);
+                        }
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            });
+            this.ws.on("error", (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            this.ws.on("close", (code, reason) => {
+                clearTimeout(timeout);
+                // Reject all pending requests
+                for (const [id, pending] of this.pendingRequests) {
+                    pending.reject(new Error(`Connection closed: ${code} ${reason}`));
+                    this.pendingRequests.delete(id);
+                }
+                this.ws = null;
+                this.sandboxId = null;
+            });
+        });
+    }
+    /**
+     * Disconnect from server
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this.sandboxId = null;
+        }
+        this.globalSuggestionHandler = null;
+    }
+    /**
+     * Set a global suggestion handler for background suggestions (like port detection)
+     */
+    setSuggestionHandler(handler) {
+        this.globalSuggestionHandler = handler;
+    }
+    /**
+     * Send a message and wait for response
+     */
+    async send(message, options = {}) {
+        await this.connect(options);
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("Not connected");
+        }
+        const id = `msg_${++this.messageIdCounter}_${Date.now()}`;
+        const messageWithId = { ...message, id };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error("Request timeout"));
+            }, options.timeout ?? DEFAULT_TIMEOUT);
+            this.pendingRequests.set(id, {
+                resolve: (response) => {
+                    clearTimeout(timeout);
+                    resolve(response);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+                onStdout: options.onStdout,
+                onStderr: options.onStderr,
+                onSuggestion: options.onSuggestion,
+            });
+            this.ws.send(JSON.stringify(messageWithId));
+        });
+    }
+    /**
+     * Execute a command and return result
+     */
+    async exec(command, options = {}) {
+        const response = await this.send({
+            type: "exec",
+            command,
+            stream: !!(options.onStdout || options.onStderr),
+        }, options);
+        // Handle exit message (streaming) or result message (non-streaming)
+        const data = response.data || {};
+        return {
+            exitCode: data.exitCode ?? 1,
+            stdout: data.stdout ?? "",
+            stderr: data.stderr ?? "",
+        };
+    }
+    /**
+     * Write a file to the sandbox
+     */
+    async writeFile(path, content, options = {}) {
+        const response = await this.send({
+            type: "write",
+            path,
+            content,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Write failed");
+        }
+    }
+    /**
+     * Read a file from the sandbox
+     */
+    async readFile(path, options = {}) {
+        const response = await this.send({
+            type: "read",
+            path,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Read failed");
+        }
+        return response.data?.content ?? "";
+    }
+    /**
+     * List directory contents
+     */
+    async listDir(path, options = {}) {
+        const response = await this.send({
+            type: "list",
+            path,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "List failed");
+        }
+        return response.data?.files ?? [];
+    }
+    /**
+     * Write multiple files at once
+     */
+    async writeMany(files, options = {}) {
+        const response = await this.send({
+            type: "writeMany",
+            files,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Write many failed");
+        }
+        return {
+            written: response.data?.written ?? files.length,
+            failed: response.data?.failed ?? [],
+        };
+    }
+    /**
+     * Send stdin input to a running process
+     */
+    async stdin(processId, input, options = {}) {
+        const response = await this.send({
+            type: "stdin",
+            processId,
+            input,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Stdin failed");
+        }
+    }
+    /**
+     * Run code with rich output interpreter (charts, images)
+     */
+    async interpret(code, options = {}) {
+        const response = await this.send({
+            type: "interpret",
+            code,
+            language: options.language ?? "python",
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Interpret failed");
+        }
+        return {
+            results: response.data?.results ?? [],
+        };
+    }
+    /**
+     * Get sandbox ID (assigned by server based on your identity)
+     */
+    getSandboxId() {
+        return this.sandboxId;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+    // ==========================================================================
+    // Port Exposure
+    // ==========================================================================
+    /**
+     * Expose a port and get a public preview URL
+     */
+    async expose(port, options = {}) {
+        const response = await this.send({ type: "expose", port }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Expose failed");
+        }
+        return {
+            url: response.data?.url ?? "",
+            wsUrl: response.data?.wsUrl,
+            exposedAt: response.data?.exposedAt ?? new Date().toISOString(),
+        };
+    }
+    // ==========================================================================
+    // Browser Operations
+    // ==========================================================================
+    /**
+     * Take a screenshot of a URL
+     */
+    async browserScreenshot(url, options = {}) {
+        const response = await this.send({
+            type: "browser_screenshot",
+            url,
+            fullPage: options.fullPage,
+            width: options.width,
+            height: options.height,
+            format: options.format,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Screenshot failed");
+        }
+        return {
+            image: response.data?.image ?? "",
+            format: response.data?.format ?? "png",
+            width: response.data?.width ?? 0,
+            height: response.data?.height ?? 0,
+        };
+    }
+    /**
+     * Generate PDF of a URL
+     */
+    async browserPdf(url, options = {}) {
+        const response = await this.send({
+            type: "browser_pdf",
+            url,
+            format: options.format,
+            landscape: options.landscape,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "PDF generation failed");
+        }
+        return {
+            pdf: response.data?.pdf ?? "",
+            pages: response.data?.pages ?? 1,
+        };
+    }
+    /**
+     * Extract markdown from a URL
+     */
+    async browserMarkdown(url, options = {}) {
+        const response = await this.send({ type: "browser_markdown", url }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Markdown extraction failed");
+        }
+        return {
+            markdown: response.data?.markdown ?? "",
+            title: response.data?.title,
+        };
+    }
+    /**
+     * Scrape elements from a URL
+     */
+    async browserScrape(url, selector, options = {}) {
+        const response = await this.send({
+            type: "browser_scrape",
+            url,
+            selector,
+            attributes: options.attributes,
+            limit: options.limit,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Scrape failed");
+        }
+        return {
+            elements: response.data?.elements ?? [],
+        };
+    }
+    /**
+     * Get rendered HTML content of a URL
+     */
+    async browserContent(url, options = {}) {
+        const response = await this.send({ type: "browser_content", url }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Content extraction failed");
+        }
+        return {
+            html: response.data?.html ?? "",
+            title: response.data?.title,
+        };
+    }
+    /**
+     * Start/stop browser tracing for performance recording
+     */
+    async browserTrace(action, options = {}) {
+        const response = await this.send({
+            type: "browser_trace",
+            action,
+            sessionId: options.sessionId,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Trace operation failed");
+        }
+        return {
+            traceData: response.data?.traceData,
+            sessionId: response.data?.sessionId,
+        };
+    }
+    /**
+     * Run Playwright assertions on a page
+     */
+    async browserTest(url, assertions, options = {}) {
+        const response = await this.send({
+            type: "browser_test",
+            url,
+            assertions,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Test execution failed");
+        }
+        return {
+            passed: response.data?.passed ?? false,
+            results: response.data?.results ?? [],
+        };
+    }
+    /**
+     * List active browser sessions
+     */
+    async browserSessions(options = {}) {
+        const response = await this.send({ type: "browser_sessions" }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Failed to list sessions");
+        }
+        return response.data?.sessions ?? [];
+    }
+    /**
+     * Get browser usage limits
+     */
+    async browserLimits(options = {}) {
+        const response = await this.send({ type: "browser_limits" }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Failed to get limits");
+        }
+        return {
+            maxConcurrent: response.data?.maxConcurrent ?? 2,
+            currentActive: response.data?.currentActive ?? 0,
+            maxSessionDuration: response.data?.maxSessionDuration ?? 300000,
+        };
+    }
+    // ==========================================================================
+    // AI Operations
+    // ==========================================================================
+    /**
+     * Generate text with LLM
+     */
+    async aiGenerate(prompt, options = {}) {
+        const response = await this.send({
+            type: "ai_generate",
+            prompt,
+            model: options.model,
+            systemPrompt: options.systemPrompt,
+            maxTokens: options.maxTokens,
+            temperature: options.temperature,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "AI generation failed");
+        }
+        return {
+            // Server sends 'response', not 'text'
+            text: response.data?.response ?? response.data?.text ?? "",
+            model: response.data?.model ?? "unknown",
+            tokens: response.data?.neuronsUsed,
+        };
+    }
+    /**
+     * Generate embeddings
+     */
+    async aiEmbed(text, options = {}) {
+        const response = await this.send({
+            type: "ai_embed",
+            text,
+            model: options.model,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Embedding failed");
+        }
+        return {
+            embeddings: response.data?.embeddings ?? [],
+            model: response.data?.model ?? "unknown",
+        };
+    }
+    /**
+     * Generate images from text prompts
+     */
+    async aiImage(prompt, options = {}) {
+        const response = await this.send({
+            type: "ai_image",
+            prompt,
+            model: options.model,
+            width: options.width,
+            height: options.height,
+            num_steps: options.numSteps,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Image generation failed");
+        }
+        return {
+            image: response.data?.image ?? "",
+            model: response.data?.model ?? "unknown",
+        };
+    }
+    /**
+     * Transcribe audio to text
+     */
+    async aiTranscribe(audio, options = {}) {
+        const response = await this.send({
+            type: "ai_transcribe",
+            audio,
+            model: options.model,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Transcription failed");
+        }
+        return {
+            text: response.data?.text ?? "",
+            model: response.data?.model ?? "unknown",
+        };
+    }
+    // ==========================================================================
+    // Agent Memory (Persistent Storage)
+    // ==========================================================================
+    /**
+     * Write to persistent memory
+     */
+    async memoryWrite(path, content, options = {}) {
+        const response = await this.send({
+            type: "memory_write",
+            path,
+            content,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Memory write failed");
+        }
+    }
+    /**
+     * Read from persistent memory
+     */
+    async memoryRead(path, options = {}) {
+        const response = await this.send({ type: "memory_read", path }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Memory read failed");
+        }
+        return response.data?.content ?? "";
+    }
+    /**
+     * List persistent memory files
+     */
+    async memoryList(prefix, options = {}) {
+        const response = await this.send({ type: "memory_list", prefix }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Memory list failed");
+        }
+        return response.data?.files ?? [];
+    }
+    /**
+     * Delete from persistent memory
+     */
+    async memoryDelete(path, options = {}) {
+        const response = await this.send({ type: "memory_delete", path }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Memory delete failed");
+        }
+    }
+    /**
+     * Get memory usage
+     */
+    async memoryUsage(options = {}) {
+        const response = await this.send({ type: "memory_usage" }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Memory usage failed");
+        }
+        return {
+            usedBytes: response.data?.usedBytes ?? 0,
+            quotaBytes: response.data?.quotaBytes ?? 10 * 1024 * 1024,
+            fileCount: response.data?.fileCount ?? 0,
+        };
+    }
+    // ==========================================================================
+    // Process Management
+    // ==========================================================================
+    /**
+     * Start a background process
+     *
+     * @param command - Shell command to run
+     * @param options.waitForSuggestions - Wait N ms for port detection suggestions (default: 0)
+     * @returns Process info and any detected suggestions
+     */
+    async processStart(command, options = {}) {
+        const suggestions = [];
+        // Collect suggestions during the request
+        const response = await this.send({
+            type: "process",
+            action: "start",
+            command,
+            processId: options.processId,
+            env: options.env,
+        }, {
+            ...options,
+            onSuggestion: (s) => suggestions.push(s),
+        });
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Process start failed");
+        }
+        const result = {
+            processId: response.data?.processId ?? "",
+            pid: response.data?.pid,
+            suggestions,
+        };
+        // Wait for background suggestions (port detection happens ~1.5s after start)
+        if (options.waitForSuggestions && options.waitForSuggestions > 0) {
+            await new Promise((resolve) => {
+                const timeout = setTimeout(resolve, options.waitForSuggestions);
+                // Set up temporary global handler to catch late suggestions
+                const originalHandler = this.globalSuggestionHandler;
+                this.globalSuggestionHandler = (s) => {
+                    suggestions.push(s);
+                    // Also call original handler if exists
+                    originalHandler?.(s);
+                };
+                // Clean up after timeout
+                setTimeout(() => {
+                    this.globalSuggestionHandler = originalHandler;
+                }, options.waitForSuggestions + 100);
+            });
+        }
+        return result;
+    }
+    /**
+     * List running processes
+     */
+    async processList(options = {}) {
+        const response = await this.send({ type: "process", action: "list" }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Process list failed");
+        }
+        return response.data?.processes ?? [];
+    }
+    /**
+     * Kill a process
+     */
+    async processKill(processId, options = {}) {
+        const response = await this.send({
+            type: "process",
+            action: "kill",
+            processId,
+        }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Process kill failed");
+        }
+    }
+    /**
+     * Get balance
+     */
+    async balance(options = {}) {
+        const response = await this.send({ type: "balance" }, options);
+        if (response.data?.success === false) {
+            throw new Error(response.data.error || "Balance check failed");
+        }
+        return {
+            balance: response.data?.balance ?? 0,
+            freeCredits: response.data?.freeCredits ?? 0,
+            paidCredits: response.data?.paidCredits ?? 0,
+        };
+    }
+}
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let instance = null;
+/**
+ * Get shared transport instance
+ */
+export function getTransport() {
+    if (!instance) {
+        instance = new PaperpodTransport();
+    }
+    return instance;
+}
+//# sourceMappingURL=transport.js.map