@pocketenv/cli 0.2.0

package/src/cmd/ssh/cloudflare.ts

@@ -0,0 +1,212 @@
+import WebSocket from "ws";
+import chalk from "chalk";
+import consola from "consola";
+import getAccessToken from "../../lib/getAccessToken";
+import { client } from "../../client";
+import { env } from "../../lib/env";
+import type { Sandbox } from "../../types/sandbox";
+
+// ── Protocol (mirrors @cloudflare/sandbox xterm addon) ───────────────────────
+//
+// Server → Client:
+//   - Binary frame   raw PTY output (UTF-8 bytes), write directly to stdout
+//   - Text frame     JSON control message:
+//       { type: "ready" }                  session is live
+//       { type: "error", message: string } terminal error
+//       { type: "exit",  code: number }    remote shell exited
+//
+// Client → Server:
+//   - Binary frame   raw keystroke bytes (UTF-8) — same as TextEncoder output
+//   - Text frame     { type: "resize", cols: number, rows: number }
+
+type ControlMessage =
+  | { type: "ready" }
+  | { type: "error"; message: string }
+  | { type: "exit"; code: number; signal?: string };
+
+function sendInput(ws: WebSocket, data: Buffer): void {
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(data);
+  }
+}
+
+function sendResize(ws: WebSocket, cols: number, rows: number): void {
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: "resize", cols, rows }));
+  }
+}
+
+/**
+ * Resolve the Cloudflare worker URL for a given baseSandbox (template) name.
+ *
+ * The web app constructs the URL with:
+ *   CF_URL.replace("sbx", worker).replace("claude-code", "claudecode")
+ *
+ * The production CF_URL is "https://sbx.pocketenv.io", so for a worker named
+ * "claude-code" the final URL becomes "https://claudecode.pocketenv.io".
+ */
+function resolveWorkerUrl(baseSandbox: string, cfUrl: string): string {
+  return cfUrl.replace("sbx", baseSandbox).replace("claude-code", "claudecode");
+}
+
+async function ssh(sandbox: Sandbox) {
+  const token = await getAccessToken();
+  const authToken = env.POCKETENV_TOKEN || token;
+
+  const tokenResponse = await client.get<{ token?: string }>(
+    "/xrpc/io.pocketenv.actor.getTerminalToken",
+    { headers: { Authorization: `Bearer ${authToken}` } },
+  );
+
+  const terminalToken = tokenResponse.data.token;
+  if (!terminalToken) {
+    consola.error("Failed to obtain a terminal token.");
+    process.exit(1);
+  }
+
+  const cfBaseUrl = env.POCKETENV_CF_URL;
+  const workerUrl = resolveWorkerUrl(sandbox.baseSandbox, cfBaseUrl);
+
+  // Convert http(s) → ws(s)
+  const wsBase = workerUrl.replace(/^http/, "ws");
+  const wsUrl = new URL(`${wsBase}/v1/sandboxes/${sandbox.id}/ws/terminal`);
+  wsUrl.searchParams.set("t", terminalToken);
+  wsUrl.searchParams.set("session", crypto.randomUUID());
+
+  let cols = process.stdout.columns ?? 220;
+  let rows = process.stdout.rows ?? 50;
+
+  consola.info(
+    `Connecting to ${chalk.cyanBright(sandbox.name)} via Cloudflare Sandbox…`,
+  );
+
+  // Use default binaryType ("nodebuffer") so binary frames arrive as Buffer,
+  // which is what isBinary:true + Buffer.isBuffer() correctly identifies.
+  const ws = new WebSocket(wsUrl.toString(), {
+    headers: { "User-Agent": "pocketenv-cli" },
+  });
+
+  let exiting = false;
+  let stdinAttached = false;
+
+  function teardown(code = 0): void {
+    if (exiting) return;
+    exiting = true;
+
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+        // ignore – may already be restored
+      }
+    }
+    process.stdin.pause();
+
+    if (
+      ws.readyState === WebSocket.OPEN ||
+      ws.readyState === WebSocket.CONNECTING
+    ) {
+      ws.close(1000, "client disconnect");
+    }
+
+    process.exit(code);
+  }
+
+  ws.on("open", () => {
+    // Nothing to do on open — wait for "ready" before sending resize or input.
+    // (Matches the xterm addon behaviour: onSocketOpen only registers listeners,
+    //  sendResize is called from handleControlMessage("ready").)
+  });
+
+  ws.on("message", (raw: WebSocket.RawData, isBinary: boolean) => {
+    if (isBinary) {
+      // Raw PTY output — write the bytes directly to stdout unchanged.
+      // raw is a Buffer (default nodebuffer binaryType).
+      process.stdout.write(raw as Buffer);
+      return;
+    }
+
+    // Text frame → JSON control message.
+    let msg: ControlMessage;
+    try {
+      msg = JSON.parse(raw.toString()) as ControlMessage;
+    } catch {
+      return;
+    }
+
+    switch (msg.type) {
+      case "ready": {
+        // ── Session is live ──────────────────────────────────────────────
+        // 1. Send current terminal dimensions now that the PTY is ready.
+        sendResize(ws, cols, rows);
+
+        if (stdinAttached) break;
+        stdinAttached = true;
+
+        // 2. Switch stdin to raw mode — every keystroke is forwarded
+        //    immediately, no local echo or line-buffering.
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(true);
+        }
+        // Keep stdin flowing as a raw binary stream. Using no encoding
+        // means data events fire with Buffer objects, which we send
+        // directly as binary WebSocket frames — no encoding round-trip.
+        process.stdin.resume();
+
+        // stdin → WebSocket (binary frame, UTF-8 bytes)
+        process.stdin.on("data", (chunk: Buffer) => {
+          sendInput(ws, chunk);
+        });
+
+        // Terminal resize → notify the remote PTY.
+        process.stdout.on("resize", () => {
+          cols = process.stdout.columns ?? cols;
+          rows = process.stdout.rows ?? rows;
+          sendResize(ws, cols, rows);
+        });
+
+        break;
+      }
+
+      case "error":
+        process.stderr.write(
+          `\r\n${chalk.red("Terminal error:")} ${msg.message}\r\n`,
+        );
+        teardown(1);
+        break;
+
+      case "exit":
+        process.stderr.write(
+          `\r\n${chalk.dim(
+            `Session exited with code ${msg.code}${msg.signal ? ` (${msg.signal})` : ""}`,
+          )}\r\n`,
+        );
+        teardown(msg.code ?? 0);
+        break;
+    }
+  });
+
+  ws.on("close", (code, reason) => {
+    if (!exiting) {
+      process.stderr.write(
+        `\r\n${chalk.yellow("Connection closed")} (${code}${reason.length ? ` – ${reason}` : ""})\r\n`,
+      );
+      teardown(0);
+    }
+  });
+
+  ws.on("error", (err: Error) => {
+    consola.error("WebSocket error:", err.message);
+    teardown(1);
+  });
+
+  process.on("SIGINT", () => teardown(0));
+  process.on("SIGTERM", () => teardown(0));
+
+  await new Promise<void>((resolve) => {
+    ws.on("close", resolve);
+    ws.on("error", () => resolve());
+  });
+}
+
+export default ssh;

package/src/cmd/ssh/index.ts

@@ -0,0 +1,96 @@
+import chalk from "chalk";
+import consola from "consola";
+import getAccessToken from "../../lib/getAccessToken";
+import { client } from "../../client";
+import { env } from "../../lib/env";
+import type { Sandbox } from "../../types/sandbox";
+import type { Profile } from "../../types/profile";
+import cloudflare from "./cloudflare";
+import tty from "./tty";
+
+async function ssh(sandboxName: string | undefined) {
+  const token = await getAccessToken();
+  const authToken = env.POCKETENV_TOKEN || token;
+
+  let sandbox: Sandbox;
+
+  if (!sandboxName) {
+    // No name provided – list the user's sandboxes and pick the first running one.
+    const profile = await client.get<Profile>(
+      "/xrpc/io.pocketenv.actor.getProfile",
+      { headers: { Authorization: `Bearer ${authToken}` } },
+    );
+
+    const response = await client.get<{ sandboxes: Sandbox[] }>(
+      "/xrpc/io.pocketenv.actor.getActorSandboxes",
+      {
+        params: { did: profile.data.did, offset: 0, limit: 100 },
+        headers: { Authorization: `Bearer ${authToken}` },
+      },
+    );
+
+    const runningSandboxes = response.data.sandboxes.filter(
+      (s) => s.status === "RUNNING",
+    );
+
+    if (runningSandboxes.length === 0) {
+      consola.error(
+        `No running sandboxes found. ` +
+          `Start one with ${chalk.greenBright("pocketenv start <sandbox>")} first.`,
+      );
+      process.exit(1);
+    }
+
+    sandbox = runningSandboxes[0] as Sandbox;
+    consola.info(`Connecting to sandbox ${chalk.greenBright(sandbox.name)}…`);
+  } else {
+    // Look up the named sandbox.
+    const response = await client.get<{ sandbox: Sandbox | null }>(
+      "/xrpc/io.pocketenv.sandbox.getSandbox",
+      {
+        params: { id: sandboxName },
+        headers: { Authorization: `Bearer ${authToken}` },
+      },
+    );
+
+    if (!response.data.sandbox) {
+      consola.error(`Sandbox ${chalk.yellowBright(sandboxName)} not found.`);
+      process.exit(1);
+    }
+
+    sandbox = response.data.sandbox;
+  }
+
+  if (sandbox.status !== "RUNNING") {
+    consola.error(
+      `Sandbox ${chalk.yellowBright(sandbox.name)} is not running. ` +
+        `Start it with ${chalk.greenBright(`pocketenv start ${sandbox.name}`)}.`,
+    );
+    process.exit(1);
+  }
+
+  // export type Provider = "daytona" | "deno" | "cloudflare" | "vercel" | "sprites";
+  switch (sandbox.provider) {
+    case "cloudflare":
+      await cloudflare(sandbox);
+      break;
+    case "daytona":
+      break;
+    case "deno":
+      break;
+    case "vercel":
+      break;
+    case "sprites":
+      await tty(sandbox);
+      break;
+    default:
+      consola.error(
+        `Sandbox ${chalk.yellowBright(sandbox.name)} uses provider ` +
+          `${chalk.cyan(sandbox.provider)}, but this command only supports ` +
+          `${chalk.cyan("cloudflare")}, ${chalk.cyan("daytona")}, ${chalk.cyan("deno")}, ${chalk.cyan("vercel")}, or ${chalk.cyan("sprites")} sandboxes.`,
+      );
+      process.exit(1);
+  }
+}
+
+export default ssh;

package/src/cmd/ssh/tty.ts

@@ -0,0 +1,221 @@
+import chalk from "chalk";
+import consola from "consola";
+import getAccessToken from "../../lib/getAccessToken";
+import { env } from "../../lib/env";
+import type { Sandbox } from "../../types/sandbox";
+import { EventSource } from "eventsource";
+import type { ErrorEvent } from "eventsource";
+import axios from "axios";
+
+// ── Protocol (mirrors TtyTerminal web component) ──────────────────────────────
+//
+// Server → Client (SSE stream at GET /tty/:id/stream):
+//   event: output   data: { "data": "<string>" }   raw PTY output chunk
+//   event: exit     data: { "code": <number> }      remote shell exited
+//
+// Client → Server:
+//   POST /tty/:id/input   Content-Type: text/plain         raw keystroke bytes
+//   POST /tty/:id/resize  Content-Type: application/json   { cols, rows }
+
+async function sendInput(
+  ttyUrl: string,
+  sandboxId: string,
+  data: string | Buffer,
+  token: string,
+): Promise<void> {
+  try {
+    await axios.post(
+      `${ttyUrl}/tty/${sandboxId}/input`,
+      data instanceof Buffer ? data.toString("utf-8") : data,
+      {
+        headers: {
+          "Content-Type": "text/plain",
+          Authorization: `Bearer ${token}`,
+        },
+      },
+    );
+  } catch {
+    // session may have closed — swallow the error silently
+  }
+}
+
+async function sendResize(
+  ttyUrl: string,
+  sandboxId: string,
+  cols: number,
+  rows: number,
+  token: string,
+): Promise<void> {
+  try {
+    await axios.post(
+      `${ttyUrl}/tty/${sandboxId}/resize`,
+      { cols, rows },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+      },
+    );
+  } catch {
+    // ignore transient resize errors
+  }
+}
+
+/**
+ * Build a custom fetch function that injects the Authorization header into
+ * every SSE request.  The eventsource v3 package uses a fetch-based
+ * implementation and exposes this hook via `EventSourceInit.fetch`.
+ */
+function makeAuthFetch(
+  token: string,
+): (url: string | URL, init: RequestInit) => Promise<Response> {
+  return (url: string | URL, init: RequestInit): Promise<Response> => {
+    const headers = new Headers((init.headers as Record<string, string>) ?? {});
+    headers.set("Authorization", `Bearer ${token}`);
+    return fetch(url, { ...init, headers });
+  };
+}
+
+async function ssh(sandbox: Sandbox): Promise<void> {
+  const token = await getAccessToken();
+  const authToken = env.POCKETENV_TOKEN || token;
+
+  const ttyUrl = env.POCKETENV_TTY_URL;
+
+  let cols = process.stdout.columns ?? 220;
+  let rows = process.stdout.rows ?? 50;
+
+  consola.info(
+    `Connecting to ${chalk.cyanBright(sandbox.name)} via TTY stream…`,
+  );
+
+  let exiting = false;
+  let es: EventSource | null = null;
+  let stdinAttached = false;
+
+  function teardown(code = 0): void {
+    if (exiting) return;
+    exiting = true;
+
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+        // ignore – may already be restored by the time teardown runs
+      }
+    }
+    process.stdin.pause();
+
+    if (es) {
+      es.close();
+      es = null;
+    }
+
+    process.exit(code);
+  }
+
+  function attachStdin(): void {
+    if (stdinAttached) return;
+    stdinAttached = true;
+
+    // Switch stdin to raw mode — every keystroke is forwarded immediately,
+    // with no local echo or line-buffering.
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    // Keep stdin flowing as a raw binary stream.
+    process.stdin.resume();
+
+    // stdin → POST /tty/:id/input
+    process.stdin.on("data", (chunk: Buffer) => {
+      sendInput(ttyUrl, sandbox.id, chunk, authToken);
+    });
+
+    // Terminal resize → notify the remote PTY.
+    process.stdout.on("resize", () => {
+      cols = process.stdout.columns ?? cols;
+      rows = process.stdout.rows ?? rows;
+      sendResize(ttyUrl, sandbox.id, cols, rows, authToken);
+    });
+  }
+
+  // Mirror TtyTerminal: print a magenta "Connecting…" hint before the stream
+  // opens, then erase it once the `open` event fires.
+  process.stdout.write(`\x1b[35mConnecting to terminal...\x1b[0m\r\n`);
+
+  // Open the SSE stream.
+  // eventsource v3 is fetch-based, so we inject the Authorization header via
+  // a custom fetch implementation instead of an `headers` init option.
+  es = new EventSource(`${ttyUrl}/tty/${sandbox.id}/stream`, {
+    fetch: makeAuthFetch(authToken),
+  });
+
+  es.addEventListener("open", () => {
+    // Erase the "Connecting…" line (carriage-return + erase-to-end-of-line),
+    // exactly as TtyTerminal does with `instance.write("\r\x1b[K")`.
+    process.stdout.write("\r\x1b[K");
+
+    // Sync terminal dimensions immediately after connecting, then attach stdin.
+    sendResize(ttyUrl, sandbox.id, cols, rows, authToken).then(() => {
+      attachStdin();
+    });
+  });
+
+  // `event: output`  data: { "data": "..." }
+  es.addEventListener("output", (event: MessageEvent) => {
+    try {
+      const { data } = JSON.parse(event.data as string) as { data: string };
+      process.stdout.write(data);
+    } catch {
+      // Fall back to writing the raw SSE data if the JSON wrapper is absent.
+      process.stdout.write(event.data as string);
+    }
+  });
+
+  // `event: exit`  data: { "code": <number> }
+  es.addEventListener("exit", (event: MessageEvent) => {
+    let code = 0;
+    try {
+      const parsed = JSON.parse(event.data as string) as { code: number };
+      code = parsed.code ?? 0;
+      process.stderr.write(
+        `\r\n${chalk.dim(`Process exited with code ${code}`)}\r\n`,
+      );
+    } catch {
+      process.stderr.write(`\r\n${chalk.dim("Process exited.")}\r\n`);
+    }
+    teardown(code);
+  });
+
+  // `onerror` receives an `ErrorEvent` (eventsource v3 type).
+  // readyState === 2 (CLOSED) means the stream is gone and the client will
+  // NOT auto-retry.  readyState === 0 (CONNECTING) is an auto-retry — let it.
+  es.onerror = (err: ErrorEvent) => {
+    // The eventsource package exposes readyState on the EventSource instance.
+    if (es && es.readyState === EventSource.CLOSED) {
+      const detail = err.message ? ` (${err.message})` : "";
+      process.stderr.write(
+        `\r\n${chalk.red(`Terminal connection lost${detail}`)}\r\n`,
+      );
+      teardown(1);
+    }
+  };
+
+  process.on("SIGINT", () => teardown(0));
+  process.on("SIGTERM", () => teardown(0));
+
+  // Block until teardown() fires (which calls process.exit, but the Promise
+  // is here as a safety net for future refactors that remove process.exit).
+  await new Promise<void>((resolve) => {
+    const poll = setInterval(() => {
+      if (exiting) {
+        clearInterval(poll);
+        resolve();
+      }
+    }, 200);
+  });
+}
+
+export default ssh;

package/src/cmd/sshkeys.ts

@@ -0,0 +1,176 @@
+import { editor, input } from "@inquirer/prompts";
+import getAccessToken from "../lib/getAccessToken";
+import { generateEd25519SSHKeyPair } from "../lib/sshKeys";
+import consola from "consola";
+import fs from "node:fs/promises";
+import encrypt from "../lib/sodium";
+import { client } from "../client";
+import type { Sandbox } from "../types/sandbox";
+import { env } from "../lib/env";
+import type { SshKeys } from "../types/sshkeys";
+import chalk from "chalk";
+
+export async function getSshKey(sandbox: string) {
+  const token = await getAccessToken();
+
+  const { data } = await client.get<{ sandbox: Sandbox }>(
+    "/xrpc/io.pocketenv.sandbox.getSandbox",
+    {
+      params: {
+        id: sandbox,
+      },
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    },
+  );
+
+  if (!data.sandbox) {
+    consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
+    process.exit(1);
+  }
+
+  try {
+    const { data: sshKeys } = await client.get<SshKeys>(
+      "/xrpc/io.pocketenv.sandbox.getSshKeys",
+      {
+        params: {
+          id: data.sandbox.id,
+        },
+        headers: {
+          Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+        },
+      },
+    );
+
+    consola.log("\nPrivate Key:");
+    consola.log(sshKeys.privateKey.replace(/\\n/g, "\n"));
+    consola.log("\nPublic Key:");
+    consola.log(sshKeys.publicKey, "\n");
+  } catch (error) {
+    consola.info(
+      `No SSH keys found for this sandbox.\n  Create one with ${chalk.greenBright(`pocketenv sshkeys put ${sandbox} --generate`)}.`,
+    );
+  }
+}
+
+export async function putKeys(
+  sandbox: string,
+  options: { generate?: boolean; publicKey?: string; privateKey?: string },
+) {
+  const token = await getAccessToken();
+  let privateKey: string | undefined;
+  let publicKey: string | undefined;
+
+  if (options.generate) {
+    const generated = await generateEd25519SSHKeyPair("");
+    privateKey = generated.privateKey;
+    publicKey = generated.publicKey;
+  }
+
+  if (options.privateKey && !options.generate) {
+    privateKey = await fs.readFile(options.privateKey, "utf8");
+  }
+
+  if (options.publicKey && !options.generate) {
+    publicKey = await fs.readFile(options.publicKey, "utf8");
+  }
+
+  const validatePrivateKey = (value: string): string | true => {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("-----BEGIN")) {
+      return "Private key must start with a PEM header (e.g. -----BEGIN OPENSSH PRIVATE KEY-----)";
+    }
+    if (!trimmed.endsWith("-----")) {
+      return "Private key must end with a PEM footer (e.g. -----END OPENSSH PRIVATE KEY-----)";
+    }
+    return true;
+  };
+
+  if (!privateKey) {
+    privateKey = (
+      await editor({
+        message: "Enter your SSH private key (opens in $EDITOR):",
+        postfix: ".pem",
+        waitForUserInput: false,
+        validate: validatePrivateKey,
+      })
+    ).trim();
+  }
+
+  if (!publicKey) {
+    publicKey = (
+      await input({
+        message: "Enter your SSH public key:",
+        validate: (value: string): string | true =>
+          value.trim().length > 0 ? true : "Public key cannot be empty.",
+      })
+    ).trim();
+  }
+
+  const { data } = await client.get<{ sandbox: Sandbox }>(
+    "/xrpc/io.pocketenv.sandbox.getSandbox",
+    {
+      params: {
+        id: sandbox,
+      },
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    },
+  );
+
+  if (!data.sandbox) {
+    consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
+    process.exit(1);
+  }
+
+  const encryptedPrivateKey = await encrypt(privateKey);
+
+  const redacted = (() => {
+    const header = "-----BEGIN OPENSSH PRIVATE KEY-----";
+    const footer = "-----END OPENSSH PRIVATE KEY-----";
+    const headerIndex = privateKey.indexOf(header);
+    const footerIndex = privateKey.indexOf(footer);
+    if (headerIndex === -1 || footerIndex === -1)
+      return privateKey.replace(/\n/g, "\\n");
+    const body = privateKey.slice(headerIndex + header.length, footerIndex);
+    const chars = body.split("");
+    const nonNewlineIndices = chars
+      .map((c, i) => (c !== "\n" ? i : -1))
+      .filter((i) => i !== -1);
+    const maskedBody =
+      nonNewlineIndices.length > 15
+        ? (() => {
+            const middleIndices = nonNewlineIndices.slice(10, -5);
+            middleIndices.forEach((i) => {
+              chars[i] = "*";
+            });
+            return chars.join("");
+          })()
+        : body;
+    return `${header}${maskedBody}${footer}`.replace(/\n/g, "\\n");
+  })();
+
+  await client.post(
+    "/xrpc/io.pocketenv.sandbox.putSshKeys",
+    {
+      id: data.sandbox.id,
+      privateKey: encryptedPrivateKey,
+      publicKey,
+      redacted,
+    },
+    {
+      headers: {
+        Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+      },
+    },
+  );
+
+  consola.log("\nPrivate Key:");
+  consola.log(redacted.replace(/\\n/g, "\n"));
+  consola.log("\nPublic Key:");
+  consola.log(publicKey, "\n");
+
+  consola.success("SSH keys saved successfully!");
+}