@pocketenv/cli 0.2.5 → 0.3.1

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.1";
 
 async function getAccessToken() {
   const tokenPath = path.join(os.homedir(), ".pocketenv", "token.json");
@@ -410,17 +410,23 @@ async function ssh(sandboxName) {
   }
 }
 
-async function start(name, { ssh: ssh$1 }) {
+async function start(name, { ssh: ssh$1, repo }) {
   const token = await getAccessToken();
   try {
-    await client.post("/xrpc/io.pocketenv.sandbox.startSandbox", void 0, {
-      params: {
-        id: name
+    await client.post(
+      "/xrpc/io.pocketenv.sandbox.startSandbox",
+      {
+        repo
       },
-      headers: {
-        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      {
+        params: {
+          id: name
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
       }
-    });
+    );
     if (ssh$1) {
       await ssh(name);
       return;
@@ -480,6 +486,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 +520,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 +549,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()
     ]);
   }
@@ -561,12 +578,13 @@ async function stop(name) {
 async function createSandbox(name, {
   provider,
   ssh: ssh$1,
-  base
+  base,
+  repo
 }) {
   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);
   }
@@ -576,7 +594,8 @@ async function createSandbox(name, {
       {
         name,
         base: base ?? "at://did:plc:aturpi2ls3yvsmhc6wybomun/io.pocketenv.sandbox/openclaw",
-        provider: provider ?? "cloudflare"
+        provider: provider ?? "cloudflare",
+        repo
       },
       {
         headers: {
@@ -586,7 +605,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 +681,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 +706,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 +715,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 +734,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 +767,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 +786,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 +804,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 +833,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 +1130,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 +1149,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 +1166,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 +1181,386 @@ 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);
+  }
+}
+
+async function exec(sandbox, command) {
+  const token = await getAccessToken();
+  try {
+    const [cmd, ...args] = command;
+    const response = await client.post(
+      "/xrpc/io.pocketenv.sandbox.exec",
+      {
+        command: `${cmd} ${args.join(" ")}`
+      },
+      {
+        params: {
+          id: sandbox
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    if (response.data.stdout) {
+      process.stdout.write(
+        response.data.stdout.endsWith("\n") ? response.data.stdout : response.data.stdout + "\n"
+      );
+    }
+    if (response.data.stderr) {
+      process.stderr.write(
+        response.data.stderr.endsWith("\n") ? response.data.stderr : response.data.stderr + "\n"
+      );
+    }
+    if (response.data.exitCode !== 0) {
+      consola.error(`Command exited with code ${response.data.exitCode}`);
+    }
+    process.exit(response.data.exitCode);
+  } catch (error) {
+    consola.error("Failed to execute command:", error);
+  }
+}
+
 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")}`
@@ -1195,14 +1587,47 @@ program.command("login").argument("<handle>", "your AT Proto handle (e.g., <user
 program.command("whoami").description("get the current logged-in user").action(whoami);
 program.command("console").aliases(["shell", "ssh", "s"]).argument("[sandbox]", "the sandbox to connect to").description("open an interactive shell for the given sandbox").action(ssh);
 program.command("ls").description("list sandboxes").action(listSandboxes);
-program.command("start").argument("<sandbox>", "the sandbox to start").option("--ssh, -s", "connect to the Sandbox and automatically open a shell").description("start the given sandbox").action(start);
+program.command("start").argument("<sandbox>", "the sandbox to start").option("--ssh, -s", "connect to the Sandbox and automatically open a shell").option(
+  "--repo, -r <repo>",
+  "the repository to clone into the sandbox (e.g., github:user/repo, tangled:user/repo, or a Git URL)"
+).description("start the given sandbox").action(start);
 program.command("stop").argument("<sandbox>", "the sandbox to stop").description("stop the given sandbox").action(stop);
 program.command("create").aliases(["new"]).option("--provider, -p <provider>", "the provider to use for the sandbox").option(
   "--base, -b <base>",
   "the base sandbox to use for the sandbox, e.g. openclaw, claude-code, codex, copilot ..."
-).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);
+).option("--ssh, -s", "connect to the Sandbox and automatically open a shell").option(
+  "--repo, -r <repo>",
+  "the repository to clone into the sandbox (e.g., github:user/repo, tangled:user/repo, or a Git URL)"
+).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").aliases(["code", "code-server"]).argument("<sandbox>", "the sandbox to expose VS Code for").description("expose a visual code server to the internet").action(exposeVscode);
+program.enablePositionalOptions().command("exec").argument("<sandbox>", "the sandbox to execute the command in").argument("<command...>", "the command to execute").description("execute a command in the given sandbox").passThroughOptions().action(exec);
+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);