@pocketenv/cli 0.2.5 → 0.3.0

package/dist/index.js

@@ -22,7 +22,7 @@ import relativeTime from 'dayjs/plugin/relativeTime.js';
 import { password, editor, input } from '@inquirer/prompts';
 import sodium from 'libsodium-wrappers';
 
-var version = "0.2.5";
+var version = "0.3.0";
 
 async function getAccessToken() {
   const tokenPath = path.join(os.homedir(), ".pocketenv", "token.json");
@@ -480,6 +480,17 @@ async function whoami() {
   );
 }
 
+const c = {
+  primary: (s) => chalk.rgb(0, 232, 198)(s),
+  secondary: (s) => chalk.rgb(0, 198, 232)(s),
+  accent: (s) => chalk.rgb(130, 100, 255)(s),
+  highlight: (s) => chalk.rgb(100, 232, 130)(s),
+  muted: (s) => chalk.rgb(200, 210, 220)(s),
+  link: (s) => chalk.rgb(255, 160, 100)(s),
+  sky: (s) => chalk.rgb(0, 210, 255)(s),
+  error: (s) => chalk.rgb(255, 100, 100)(s)
+};
+
 dayjs.extend(relativeTime);
 async function listSandboxes() {
   const token = await getAccessToken();
@@ -503,10 +514,10 @@ async function listSandboxes() {
   );
   const table = new Table({
     head: [
-      chalk.cyan("NAME"),
-      chalk.cyan("BASE"),
-      chalk.cyan("STATUS"),
-      chalk.cyan("CREATED AT")
+      c.primary("NAME"),
+      c.primary("BASE"),
+      c.primary("STATUS"),
+      c.primary("CREATED AT")
     ],
     chars: {
       top: "",
@@ -532,9 +543,9 @@ async function listSandboxes() {
   });
   for (const sandbox of response.data.sandboxes) {
     table.push([
-      chalk.greenBright(sandbox.name),
+      c.secondary(sandbox.name),
       sandbox.baseSandbox,
-      sandbox.status === "RUNNING" ? chalk.greenBright(sandbox.status) : sandbox.status,
+      sandbox.status === "RUNNING" ? c.highlight(sandbox.status) : sandbox.status,
       dayjs(sandbox.createdAt).fromNow()
     ]);
   }
@@ -566,7 +577,7 @@ async function createSandbox(name, {
   const token = await getAccessToken();
   if (["deno", "vercel", "daytona"].includes(provider || "")) {
     consola.error(
-      `This Sandbox Runtime is temporarily disabled. ${chalk.greenBright(provider ?? "")}`
+      `This Sandbox Runtime is temporarily disabled. ${c.primary(provider ?? "")}`
     );
     process.exit(1);
   }
@@ -586,7 +597,7 @@ async function createSandbox(name, {
     );
     if (!ssh$1) {
       consola.success(
-        `Sandbox created successfully: ${chalk.greenBright(sandbox.data.name)}`
+        `Sandbox created successfully: ${c.primary(sandbox.data.name)}`
       );
       return;
     }
@@ -662,7 +673,7 @@ async function listSecrets(sandbox) {
     }
   );
   const table = new Table({
-    head: [chalk.cyan("ID"), chalk.cyan("NAME"), chalk.cyan("CREATED AT")],
+    head: [c.primary("ID"), c.primary("NAME"), c.primary("CREATED AT")],
     chars: {
       top: "",
       "top-mid": "",
@@ -687,8 +698,8 @@ async function listSecrets(sandbox) {
   });
   for (const secret of response.data.secrets) {
     table.push([
-      chalk.greenBright(secret.id),
-      chalk.greenBright(secret.name),
+      c.secondary(secret.id),
+      c.highlight(secret.name),
       dayjs(secret.createdAt).fromNow()
     ]);
   }
@@ -696,7 +707,13 @@ async function listSecrets(sandbox) {
 }
 async function putSecret(sandbox, key) {
   const token = await getAccessToken();
-  const value = await password({ message: "Enter secret value" });
+  const isStdinPiped = !process.stdin.isTTY;
+  const value = isStdinPiped ? await new Promise((resolve) => {
+    let data2 = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => data2 += chunk);
+    process.stdin.on("end", () => resolve(data2.trimEnd()));
+  }) : await password({ message: "Enter secret value" });
   const { data } = await client.get("/xrpc/io.pocketenv.sandbox.getSandbox", {
     params: {
       id: sandbox
@@ -709,21 +726,26 @@ async function putSecret(sandbox, key) {
     consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
     process.exit(1);
   }
-  await client.post(
-    "/xrpc/io.pocketenv.secret.addSecret",
-    {
-      secret: {
-        sandboxId: data.sandbox.id,
-        name: key,
-        value: await encrypt(value)
-      }
-    },
-    {
-      headers: {
-        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+  try {
+    await client.post(
+      "/xrpc/io.pocketenv.secret.addSecret",
+      {
+        secret: {
+          sandboxId: data.sandbox.id,
+          name: key,
+          value: await encrypt(value)
+        }
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
       }
-    }
-  );
+    );
+    consola.success("Secret added successfully");
+  } catch (error) {
+    consola.error("Failed to add secret:", error);
+  }
 }
 async function deleteSecret(id) {
   const token = await getAccessToken();
@@ -737,8 +759,8 @@ async function deleteSecret(id) {
       }
     });
     consola.success("Secret deleted successfully");
-  } catch {
-    consola.error("Failed to delete secret");
+  } catch (error) {
+    consola.error("Failed to delete secret:", error);
   }
 }
 
@@ -756,7 +778,7 @@ async function listEnvs(sandbox) {
     }
   );
   if (!data.sandbox) {
-    consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
+    consola.error(`Sandbox not found: ${c.primary(sandbox)}`);
     process.exit(1);
   }
   const response = await client.get(
@@ -774,10 +796,10 @@ async function listEnvs(sandbox) {
   );
   const table = new Table({
     head: [
-      chalk.cyan("ID"),
-      chalk.cyan("NAME"),
-      chalk.cyan("VALUE"),
-      chalk.cyan("CREATED AT")
+      c.primary("ID"),
+      c.primary("NAME"),
+      c.primary("VALUE"),
+      c.primary("CREATED AT")
     ],
     chars: {
       top: "",
@@ -803,8 +825,8 @@ async function listEnvs(sandbox) {
   });
   for (const variable of response.data.variables) {
     table.push([
-      chalk.greenBright(variable.id),
-      chalk.greenBright(variable.name),
+      c.secondary(variable.id),
+      c.highlight(variable.name),
       variable.value,
       dayjs(variable.createdAt).fromNow()
     ]);
@@ -1100,7 +1122,7 @@ async function putAuthKey(sandbox) {
     }
   );
   if (!data.sandbox) {
-    consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
+    consola.error(`Sandbox not found: ${c.primary(sandbox)}`);
     process.exit(1);
   }
   const redacted = authKey.length > 14 ? authKey.slice(0, 11) + "*".repeat(authKey.length - 14) + authKey.slice(-3) : authKey;
@@ -1119,7 +1141,7 @@ async function putAuthKey(sandbox) {
   );
   consola.success(redacted);
   consola.success(
-    `Tailscale auth key saved for sandbox: ${chalk.greenBright(sandbox)}`
+    `Tailscale auth key saved for sandbox: ${c.primary(sandbox)}`
   );
 }
 async function getTailscaleAuthKey(sandbox) {
@@ -1136,7 +1158,7 @@ async function getTailscaleAuthKey(sandbox) {
     }
   );
   if (!data.sandbox) {
-    consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
+    consola.error(`Sandbox not found: ${c.primary(sandbox)}`);
     process.exit(1);
   }
   try {
@@ -1151,24 +1173,349 @@ async function getTailscaleAuthKey(sandbox) {
         }
       }
     );
-    consola.info(`Tailscale auth key: ${chalk.greenBright(tailscale.authKey)}`);
+    consola.info(`Tailscale auth key: ${c.primary(tailscale.authKey)}`);
   } catch {
     consola.error(
-      `No Tailscale Auth Key found for sandbox: ${chalk.greenBright(sandbox)}`
+      `No Tailscale Auth Key found for sandbox: ${c.primary(sandbox)}`
     );
     process.exit(1);
   }
 }
 
-const c = {
-  primary: (s) => chalk.rgb(0, 232, 198)(s),
-  secondary: (s) => chalk.rgb(0, 198, 232)(s),
-  accent: (s) => chalk.rgb(130, 100, 255)(s),
-  highlight: (s) => chalk.rgb(100, 232, 130)(s),
-  muted: (s) => chalk.rgb(200, 210, 220)(s),
-  link: (s) => chalk.rgb(255, 160, 100)(s),
-  sky: (s) => chalk.rgb(0, 210, 255)(s)
-};
+async function exposePort(sandbox, port, description) {
+  const token = await getAccessToken();
+  try {
+    const response = await client.post(
+      `/xrpc/io.pocketenv.sandbox.exposePort`,
+      { port, description },
+      {
+        params: {
+          id: sandbox
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    consola.success(
+      `Port ${c.primary(port)} exposed for sandbox ${c.primary(sandbox)}`
+    );
+    if (response.data.previewUrl) {
+      consola.success(`Preview URL: ${c.secondary(response.data.previewUrl)}`);
+    }
+  } catch (error) {
+    consola.error("Failed to expose port:", error);
+    process.exit(1);
+  }
+}
+
+async function unexposePort(sandbox, port) {
+  const token = await getAccessToken();
+  try {
+    await client.post(
+      `/xrpc/io.pocketenv.sandbox.unexposePort`,
+      { port },
+      {
+        params: {
+          id: sandbox
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    consola.success(
+      `Port ${c.primary(port)} unexposed for sandbox ${c.primary(sandbox)}`
+    );
+  } catch (error) {
+    consola.error(`Failed to unexpose port: ${error}`);
+    process.exit(1);
+  }
+}
+
+dayjs.extend(relativeTime);
+async function listVolumes(sandboxId) {
+  const token = await getAccessToken();
+  const response = await client.get(
+    "/xrpc/io.pocketenv.volume.getVolumes",
+    {
+      params: {
+        sandboxId
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    }
+  );
+  const table = new Table({
+    head: [
+      c.primary("ID"),
+      c.primary("NAME"),
+      c.primary("PATH"),
+      c.primary("CREATED AT")
+    ],
+    chars: {
+      top: "",
+      "top-mid": "",
+      "top-left": "",
+      "top-right": "",
+      bottom: "",
+      "bottom-mid": "",
+      "bottom-left": "",
+      "bottom-right": "",
+      left: "",
+      "left-mid": "",
+      mid: "",
+      "mid-mid": "",
+      right: "",
+      "right-mid": "",
+      middle: " "
+    },
+    style: {
+      border: [],
+      head: []
+    }
+  });
+  for (const volume of response.data.volumes) {
+    table.push([
+      c.secondary(volume.id),
+      volume.name,
+      volume.path,
+      dayjs(volume.createdAt).fromNow()
+    ]);
+  }
+  consola.log(table.toString());
+}
+async function createVolume(sandbox, name, path) {
+  const token = await getAccessToken();
+  try {
+    await client.post(
+      "/xrpc/io.pocketenv.volume.addVolume",
+      {
+        volume: {
+          sandboxId: sandbox,
+          name,
+          path
+        }
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    consola.success(
+      `Volume ${chalk.rgb(0, 232, 198)(name)} successfully mounted in sandbox ${chalk.rgb(0, 232, 198)(sandbox)} at path ${chalk.rgb(0, 232, 198)(path)}`
+    );
+  } catch (error) {
+    consola.error("Failed to create volume:", error);
+  }
+}
+async function deleteVolume(id) {
+  const token = await getAccessToken();
+  try {
+    await client.post(`/xrpc/io.pocketenv.volume.deleteVolume`, void 0, {
+      params: {
+        id
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    });
+  } catch (error) {
+    consola.error(`Failed to delete volume: ${error}`);
+    return;
+  }
+  consola.success(
+    `Volume ${chalk.rgb(0, 232, 198)(id)} successfully deleted from sandbox`
+  );
+}
+
+dayjs.extend(relativeTime);
+async function putFile(sandbox, remotePath, localPath) {
+  const token = await getAccessToken();
+  let content;
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    content = Buffer.concat(chunks).toString().trim();
+  } else if (localPath) {
+    const resolvedPath = path.resolve(localPath);
+    try {
+      await fs.access(resolvedPath);
+    } catch (err) {
+      consola.error(`No such file: ${c.error(localPath)}`);
+      process.exit(1);
+    }
+    content = await fs.readFile(resolvedPath, "utf-8");
+  } else {
+    content = (await editor({
+      message: "File content (opens in $EDITOR):",
+      waitForUserInput: false
+    })).trim();
+  }
+  try {
+    await client.post(
+      "/xrpc/io.pocketenv.file.addFile",
+      {
+        file: {
+          sandboxId: sandbox,
+          path: remotePath,
+          content: await encrypt(content)
+        }
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    consola.success(
+      `File ${c.primary(remotePath)} successfully created in sandbox ${c.primary(sandbox)}`
+    );
+  } catch (error) {
+    consola.error(`Failed to create file: ${error}`);
+  }
+}
+async function listFiles(sandboxId) {
+  const token = await getAccessToken();
+  const response = await client.get(
+    "/xrpc/io.pocketenv.file.getFiles",
+    {
+      params: {
+        sandboxId
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    }
+  );
+  const table = new Table({
+    head: [c.primary("ID"), c.primary("PATH"), c.primary("CREATED AT")],
+    chars: {
+      top: "",
+      "top-mid": "",
+      "top-left": "",
+      "top-right": "",
+      bottom: "",
+      "bottom-mid": "",
+      "bottom-left": "",
+      "bottom-right": "",
+      left: "",
+      "left-mid": "",
+      mid: "",
+      "mid-mid": "",
+      right: "",
+      "right-mid": "",
+      middle: " "
+    },
+    style: {
+      border: [],
+      head: []
+    }
+  });
+  for (const file of response.data.files) {
+    table.push([
+      c.secondary(file.id),
+      file.path,
+      dayjs(file.createdAt).fromNow()
+    ]);
+  }
+  consola.log(table.toString());
+}
+async function deleteFile(id) {
+  const token = await getAccessToken();
+  try {
+    await client.post(`/xrpc/io.pocketenv.file.deleteFile`, void 0, {
+      params: {
+        id
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    });
+    consola.success(`File ${c.primary(id)} successfully deleted from sandbox`);
+  } catch (error) {
+    consola.error(`Failed to delete file: ${error}`);
+  }
+}
+
+async function listPorts(sandbox) {
+  const token = await getAccessToken();
+  const response = await client.get(
+    "/xrpc/io.pocketenv.sandbox.getExposedPorts",
+    {
+      params: {
+        id: sandbox
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    }
+  );
+  const table = new Table({
+    head: [
+      c.primary("PORT"),
+      c.primary("DESCRIPTION"),
+      c.primary("PREVIEW URL")
+    ],
+    chars: {
+      top: "",
+      "top-mid": "",
+      "top-left": "",
+      "top-right": "",
+      bottom: "",
+      "bottom-mid": "",
+      "bottom-left": "",
+      "bottom-right": "",
+      left: "",
+      "left-mid": "",
+      mid: "",
+      "mid-mid": "",
+      right: "",
+      "right-mid": "",
+      middle: " "
+    },
+    style: {
+      border: [],
+      head: []
+    }
+  });
+  for (const port of response.data.ports) {
+    table.push([
+      c.secondary(port.port),
+      port.description || "-",
+      c.link(port.previewUrl || "-")
+    ]);
+  }
+  consola.log(table.toString());
+}
+
+async function exposeVscode(sandbox) {
+  const token = await getAccessToken();
+  try {
+    const response = await client.post(
+      `/xrpc/io.pocketenv.sandbox.exposeVscode`,
+      void 0,
+      {
+        params: {
+          id: sandbox
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    consola.success(`VS Code Server exposed for sandbox ${c.primary(sandbox)}`);
+    if (response.data.previewUrl) {
+      consola.success(`Preview URL: ${c.secondary(response.data.previewUrl)}`);
+    }
+  } catch (error) {
+    consola.error("Failed to expose VS Code:", error);
+    process.exit(1);
+  }
+}
+
 const program = new Command();
 program.name("pocketenv").description(
   `${chalk.bold.rgb(0, 232, 198)(`pocketenv v${version}`)} ${c.muted("\u2500")} ${c.muted("Open, interoperable sandbox platform for agents and humans")}`
@@ -1203,6 +1550,34 @@ program.command("create").aliases(["new"]).option("--provider, -p <provider>", "
 ).option("--ssh, -s", "connect to the Sandbox and automatically open a shell").argument("[name]", "the name of the sandbox to create").description("create a new sandbox").action(createSandbox);
 program.command("logout").description("logout (removes session token)").action(logout);
 program.command("rm").aliases(["delete", "remove"]).argument("<sandbox>", "the sandbox to delete").description("delete the given sandbox").action(deleteSandbox);
+program.command("vscode").argument("<sandbox>", "the sandbox to expose VS Code for").description(
+  "expose a VS Code Server instance running in the given sandbox to the internet"
+).action(exposeVscode);
+program.command("expose").argument("<sandbox>", "the sandbox to expose a port for").argument("<port>", "the port to expose", (val) => {
+  const port = parseInt(val, 10);
+  if (isNaN(port)) {
+    consola.error(`port must be a number, got: ${val}`);
+    process.exit(1);
+  }
+  return port;
+}).argument("[description]", "an optional description for the exposed port").description("expose a port from the given sandbox to the internet").action(exposePort);
+program.command("unexpose").argument("<sandbox>", "the sandbox to unexpose a port for").argument("<port>", "the port to unexpose", (val) => {
+  const port = parseInt(val, 10);
+  if (isNaN(port)) {
+    consola.error(`port must be a number, got: ${val}`);
+    process.exit(1);
+  }
+  return port;
+}).description("unexpose a port from the given sandbox").action(unexposePort);
+const volume = program.command("volume").description("manage volumes");
+volume.command("put").argument("<sandbox>", "the sandbox to put the volume in").argument("<name>", "the name of the volume").argument("<path>", "the path to mount the volume at").description("put a volume in the given sandbox").action(createVolume);
+volume.command("list").aliases(["ls"]).argument("<sandbox>", "the sandbox to list volumes for").description("list volumes in the given sandbox").action(listVolumes);
+volume.command("delete").aliases(["rm", "remove"]).argument("<id>", "the ID of the volume to delete").description("delete a volume").action(deleteVolume);
+const file = program.command("file").description("manage files");
+file.command("put").argument("<sandbox>", "the sandbox to put the file in").argument("<path>", "the remote path to upload the file to").argument("[localPath]", "the local path of the file to upload").description("upload a file to the given sandbox").action(putFile);
+file.command("list").aliases(["ls"]).argument("<sandbox>", "the sandbox to list files for").description("list files in the given sandbox").action(listFiles);
+file.command("delete").aliases(["rm", "remove"]).argument("<id>", "the ID of the file to delete").description("delete a file").action(deleteFile);
+program.command("ports").argument("<sandbox>", "the sandbox to list exposed ports for").description("list exposed ports for a sandbox").action(listPorts);
 const secret = program.command("secret").description("manage secrets");
 secret.command("put").argument("<sandbox>", "the sandbox to put the secret in").argument("<key>", "the key of the secret").description("put a secret in the given sandbox").action(putSecret);
 secret.command("list").aliases(["ls"]).argument("<sandbox>", "the sandbox to list secrets for").description("list secrets in the given sandbox").action(listSecrets);

package/package.json

@@ -4,7 +4,7 @@
   "bin": {
     "pocketenv": "dist/index.js"
   },
-  "version": "0.2.5",
+  "version": "0.3.0",
   "type": "module",
   "keywords": [
     "sandbox",

package/src/cmd/create.ts

@@ -2,8 +2,8 @@ import consola from "consola";
 import { client } from "../client";
 import getAccessToken from "../lib/getAccessToken";
 import type { Sandbox } from "../types/sandbox";
-import chalk from "chalk";
 import connectToSandbox from "./ssh";
+import { c } from "../theme";
 
 async function createSandbox(
   name: string,
@@ -21,7 +21,7 @@ async function createSandbox(
 
   if (["deno", "vercel", "daytona"].includes(provider || "")) {
     consola.error(
-      `This Sandbox Runtime is temporarily disabled. ${chalk.greenBright(provider ?? "")}`,
+      `This Sandbox Runtime is temporarily disabled. ${c.primary(provider ?? "")}`,
     );
     process.exit(1);
   }
@@ -43,7 +43,7 @@ async function createSandbox(
     );
     if (!ssh) {
       consola.success(
-        `Sandbox created successfully: ${chalk.greenBright(sandbox.data.name)}`,
+        `Sandbox created successfully: ${c.primary(sandbox.data.name)}`,
       );
       return;
     }

package/src/cmd/env.ts

@@ -2,11 +2,11 @@ import { client } from "../client";
 import getAccessToken from "../lib/getAccessToken";
 import type { Sandbox } from "../types/sandbox";
 import type { Variable } from "../types/variable";
-import chalk from "chalk";
 import dayjs from "dayjs";
 import consola from "consola";
 import Table from "cli-table3";
 import { env } from "../lib/env";
+import { c } from "../theme";
 
 export async function listEnvs(sandbox: string) {
   const token = await getAccessToken();
@@ -23,7 +23,7 @@ export async function listEnvs(sandbox: string) {
   );
 
   if (!data.sandbox) {
-    consola.error(`Sandbox not found: ${chalk.greenBright(sandbox)}`);
+    consola.error(`Sandbox not found: ${c.primary(sandbox)}`);
     process.exit(1);
   }
 
@@ -43,10 +43,10 @@ export async function listEnvs(sandbox: string) {
 
   const table = new Table({
     head: [
-      chalk.cyan("ID"),
-      chalk.cyan("NAME"),
-      chalk.cyan("VALUE"),
-      chalk.cyan("CREATED AT"),
+      c.primary("ID"),
+      c.primary("NAME"),
+      c.primary("VALUE"),
+      c.primary("CREATED AT"),
     ],
     chars: {
       top: "",
@@ -73,8 +73,8 @@ export async function listEnvs(sandbox: string) {
 
   for (const variable of response.data.variables) {
     table.push([
-      chalk.greenBright(variable.id),
-      chalk.greenBright(variable.name),
+      c.secondary(variable.id),
+      c.highlight(variable.name),
       variable.value,
       dayjs(variable.createdAt).fromNow(),
     ]);