covebox 0.1.0 → 0.1.3

package/dist/interactive.js

@@ -118,6 +118,9 @@ async function handleCommand(client, line, rl) {
                 if (sandbox.noVncUrl) {
                     console.log(`  NoVNC: ${chalk.blue(sandbox.noVncUrl)}`);
                 }
+                if (sandbox.ptyUrl) {
+                    console.log(`  PTY:   ${chalk.green(sandbox.ptyUrl)}`);
+                }
                 if (sandbox.vncUrl) {
                     console.log(`  VNC WS: ${chalk.gray(sandbox.vncUrl)}`);
                 }
@@ -242,11 +245,6 @@ async function handleCommand(client, line, rl) {
                     console.log(chalk.red("Usage: ssh <id>"));
                     break;
                 }
-                const daytonaApiKey = process.env["DAYTONA_API_KEY"];
-                if (!daytonaApiKey) {
-                    console.log(chalk.red("DAYTONA_API_KEY environment variable is required for shell access."));
-                    break;
-                }
                 const sandboxId = await resolveId(client, id);
                 if (!sandboxId)
                     break;
@@ -257,18 +255,20 @@ async function handleCommand(client, line, rl) {
                     console.log(chalk.red(`Sandbox is ${sandbox.state}. Start it first with: start ${sandboxId.slice(0, 12)}`));
                     break;
                 }
-                if (sandbox.noVncUrl) {
-                    console.log(`NoVNC: ${chalk.blue(sandbox.noVncUrl)}`);
+                if (!sandbox.ptyUrl) {
+                    console.log(chalk.red("Shell access not available for this sandbox."));
+                    break;
                 }
                 console.log(chalk.gray(`\nConnecting to ${sandboxId.slice(0, 12)}...\n`));
                 // Close readline before PTY (removes its stdin listeners)
                 if (rl) {
                     rl.close();
                 }
-                // Only remove keypress listener (readline's), not all listeners
                 process.stdin.removeAllListeners("keypress");
+                // Small delay for bun's event loop to settle after readline close
+                await new Promise((r) => setTimeout(r, 100));
                 try {
-                    await runPtySession(sandboxId, daytonaApiKey);
+                    await runPtySession(sandbox.ptyUrl);
                 }
                 catch (err) {
                     console.error(chalk.red(`Connection failed: ${err}`));

package/dist/pty-client.d.ts

@@ -1,9 +1,9 @@
 /**
- * PTY Client using Daytona SDK
+ * PTY Client using WebSocket
  *
- * Provides interactive terminal access to sandboxes using Daytona's native PTY support.
+ * Connects to the sandbox's PTY endpoint for interactive terminal access.
  */
 /**
- * Run an interactive PTY session using Daytona SDK
+ * Run an interactive PTY session
  */
-export declare function runPtySession(sandboxId: string, apiKey: string): Promise<void>;
+export declare function runPtySession(ptyUrl: string): Promise<void>;

package/dist/pty-client.js

@@ -1,110 +1,189 @@
 /**
- * PTY Client using Daytona SDK
+ * PTY Client using WebSocket
  *
- * Provides interactive terminal access to sandboxes using Daytona's native PTY support.
+ * Connects to the sandbox's PTY endpoint for interactive terminal access.
  */
-import { Daytona } from "@daytonaio/sdk";
+import WebSocket from "ws";
+// Message types (must match cove-proxy/pty.go)
+const MsgStdin = 0x00;
+const MsgStdout = 0x01;
+const MsgResize = 0x10;
+const MsgCreateSession = 0x20;
+const MsgAttachSession = 0x22;
+const MsgCreateWindow = 0x30;
+const MsgCreatePane = 0x40;
+const MsgResponse = 0xf0;
+const MsgError = 0xff;
 /**
- * Run an interactive PTY session using Daytona SDK
+ * Run an interactive PTY session
  */
-export async function runPtySession(sandboxId, apiKey) {
-    const client = new Daytona({ apiKey });
-    // Get terminal size
-    const rows = process.stdout.rows || 24;
-    const cols = process.stdout.columns || 80;
-    let pty = null;
-    let cleanedUp = false;
-    let stdinHandler = null;
-    let resizeHandler = null;
-    const cleanup = async () => {
-        if (cleanedUp)
-            return;
-        cleanedUp = true;
-        // Remove event listeners first
-        if (stdinHandler) {
-            process.stdin.removeListener("data", stdinHandler);
-            stdinHandler = null;
-        }
-        if (resizeHandler) {
-            process.stdout.removeListener("resize", resizeHandler);
-            resizeHandler = null;
-        }
-        // Restore terminal to cooked mode
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(false);
-        }
-        // Reset encoding to default (buffer) so readline can manage it
-        process.stdin.setEncoding("utf8");
-        process.stdin.pause();
-        // Disconnect PTY
-        if (pty) {
-            try {
-                await pty.disconnect();
+export async function runPtySession(ptyUrl) {
+    return new Promise((resolve, reject) => {
+        const rows = process.stdout.rows || 24;
+        const cols = process.stdout.columns || 80;
+        let ws = null;
+        let paneId = null;
+        let cleanedUp = false;
+        let stdinHandler = null;
+        let resizeHandler = null;
+        const cleanup = () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            if (stdinHandler) {
+                process.stdin.removeListener("data", stdinHandler);
+                stdinHandler = null;
             }
-            catch {
-                // Ignore disconnect errors
+            if (resizeHandler) {
+                process.stdout.removeListener("resize", resizeHandler);
+                resizeHandler = null;
             }
-            pty = null;
-        }
-    };
-    try {
-        const sandbox = await client.get(sandboxId);
-        // Create PTY session with unique ID
-        const sessionId = `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        pty = await sandbox.process.createPty({
-            id: sessionId,
-            cols,
-            rows,
-            onData: (data) => {
-                const text = typeof data === "string" ? data : new TextDecoder().decode(data);
-                process.stdout.write(text);
-            },
-        });
-        // Wait for connection to be established
-        await pty.waitForConnection();
-        // Set raw mode for stdin (disables local echo)
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-        }
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-        // Handle stdin - use named function so we can remove it later
-        stdinHandler = (data) => {
-            if (pty && !cleanedUp) {
-                pty.sendInput(data.toString()).catch(() => {
-                    // Connection may have closed
-                });
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
             }
+            process.stdin.setEncoding("utf8");
+            process.stdin.pause();
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.close();
+            }
+            ws = null;
         };
-        process.stdin.on("data", stdinHandler);
-        // Handle resize
-        resizeHandler = () => {
-            if (pty && !cleanedUp) {
-                const newRows = process.stdout.rows || 24;
-                const newCols = process.stdout.columns || 80;
-                pty.resize(newCols, newRows).catch(() => {
-                    // Ignore resize errors
-                });
+        const sendBinary = (data) => {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(data);
             }
         };
-        process.stdout.on("resize", resizeHandler);
-        // Handle process signals
-        const handleSignal = async () => {
-            await cleanup();
-            process.exit(0);
+        const sendJson = (msgType, payload) => {
+            const json = JSON.stringify(payload);
+            const buf = Buffer.alloc(1 + json.length);
+            buf[0] = msgType;
+            buf.write(json, 1);
+            sendBinary(buf);
+        };
+        const sendStdin = (data) => {
+            if (paneId === null)
+                return;
+            const dataBuf = Buffer.from(data);
+            const buf = Buffer.alloc(5 + dataBuf.length);
+            buf[0] = MsgStdin;
+            buf.writeUInt32BE(paneId, 1);
+            dataBuf.copy(buf, 5);
+            sendBinary(buf);
+        };
+        const sendResize = (newRows, newCols) => {
+            if (paneId === null)
+                return;
+            const buf = Buffer.alloc(9);
+            buf[0] = MsgResize;
+            buf.writeUInt32BE(paneId, 1);
+            buf.writeUInt16BE(newRows, 5);
+            buf.writeUInt16BE(newCols, 7);
+            sendBinary(buf);
         };
-        process.once("SIGINT", handleSignal);
-        process.once("SIGTERM", handleSignal);
-        // Wait for PTY to exit
-        const result = await pty.wait();
-        console.log(`\nSession ended (exit code: ${result.exitCode})`);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`\nPTY Error: ${message}`);
-        throw error;
-    }
-    finally {
-        await cleanup();
-    }
+        try {
+            ws = new WebSocket(ptyUrl, { followRedirects: true });
+            ws.on("open", () => {
+                // Create session
+                sendJson(MsgCreateSession, { name: "cli-session" });
+            });
+            ws.on("message", (data) => {
+                if (data.length < 1)
+                    return;
+                const msgType = data[0];
+                const payload = data.slice(1);
+                if (msgType === MsgStdout && paneId !== null) {
+                    // Skip pane ID (4 bytes), output the rest
+                    const output = payload.slice(4);
+                    process.stdout.write(output);
+                }
+                else if (msgType === MsgResponse) {
+                    try {
+                        const response = JSON.parse(payload.toString());
+                        if (response.type === "session_created" && response.session) {
+                            // Attach to session
+                            const sessionId = response.session.id;
+                            const buf = Buffer.alloc(1 + 36);
+                            buf[0] = MsgAttachSession;
+                            buf.write(sessionId, 1);
+                            sendBinary(buf);
+                        }
+                        else if (response.type === "attached") {
+                            // Create window
+                            sendJson(MsgCreateWindow, { name: "main" });
+                        }
+                        else if (response.type === "window_created" && response.window) {
+                            // Create pane
+                            sendJson(MsgCreatePane, {
+                                windowId: response.window.id,
+                                rows,
+                                cols,
+                            });
+                        }
+                        else if (response.type === "pane_created" && response.pane) {
+                            paneId = response.pane.id;
+                            // Now we're connected - set up terminal
+                            if (process.stdin.isTTY) {
+                                process.stdin.setRawMode(true);
+                            }
+                            process.stdin.resume();
+                            process.stdin.setEncoding("utf8");
+                            stdinHandler = (inputData) => {
+                                if (!cleanedUp) {
+                                    sendStdin(inputData.toString());
+                                }
+                            };
+                            process.stdin.on("data", stdinHandler);
+                            resizeHandler = () => {
+                                if (!cleanedUp) {
+                                    const newRows = process.stdout.rows || 24;
+                                    const newCols = process.stdout.columns || 80;
+                                    sendResize(newRows, newCols);
+                                }
+                            };
+                            process.stdout.on("resize", resizeHandler);
+                        }
+                        else if (response.type === "pane_closed") {
+                            // Shell exited - close connection
+                            cleanup();
+                            resolve();
+                            return;
+                        }
+                    }
+                    catch {
+                        // Ignore JSON parse errors
+                    }
+                }
+                else if (msgType === MsgError) {
+                    try {
+                        const error = JSON.parse(payload.toString());
+                        console.error(`\nPTY Error: ${error.error}`);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+            });
+            ws.on("close", () => {
+                cleanup();
+                resolve();
+            });
+            ws.on("error", (err) => {
+                cleanup();
+                // Extract meaningful error message from WebSocket error
+                const message = err.message || err.code || String(err);
+                reject(new Error(message));
+            });
+            // Handle signals
+            const handleSignal = () => {
+                cleanup();
+                resolve();
+            };
+            process.once("SIGINT", handleSignal);
+            process.once("SIGTERM", handleSignal);
+        }
+        catch (error) {
+            cleanup();
+            reject(error);
+        }
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "covebox",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "CLI for Cove sandboxes - cloud development environments",
   "type": "module",
   "bin": {
@@ -18,15 +18,16 @@
     "test:e2e": "tsx src/test-e2e.ts"
   },
   "dependencies": {
-    "@daytonaio/sdk": "^0.115.2",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
     "conf": "^13.1.0",
-    "ora": "^8.2.0"
+    "ora": "^8.2.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^22.15.32",
+    "@types/ws": "^8.5.13",
     "tsx": "^4.21.0",
     "typescript": "^5.7.3"
   }