@pocketenv/cli 0.3.4 → 0.4.0

package/README.md

@@ -1,6 +1,7 @@
 # Pocketenv CLI
 
 [![npm version](https://img.shields.io/npm/v/@pocketenv/cli?color=green)](https://www.npmjs.com/package/@pocketenv/cli)
+![NPM Downloads](https://img.shields.io/npm/dw/%40pocketenv%2Fcli)
 [![discord](https://img.shields.io/discord/1270021300240252979?label=discord&logo=discord&color=5865F2)](https://discord.gg/9ada4pFUFS)
 [![License: MPL-2.0](https://img.shields.io/badge/License-MPL_2.0-blue.svg)](https://opensource.org/licenses/MPL-2.0)
 

package/dist/index.js

@@ -23,8 +23,9 @@ import { execSync } from 'child_process';
 import * as fs from 'fs';
 import { password, editor, input } from '@inquirer/prompts';
 import sodium from 'libsodium-wrappers';
+import process$1 from 'node:process';
 
-var version = "0.3.4";
+var version = "0.4.0";
 
 async function getAccessToken() {
   const tokenPath = path.join(os.homedir(), ".pocketenv", "token.json");
@@ -440,7 +441,11 @@ async function waitUntilRunning(name, authToken, timeoutMs = 6e4, intervalMs = 2
   );
 }
 
-async function start(name, { ssh: ssh$1, repo }) {
+async function start(name, {
+  ssh: ssh$1,
+  repo,
+  keepAlive
+}) {
   const token = await getAccessToken();
   if (repo) repo = expandRepo(repo);
   try {
@@ -448,7 +453,8 @@ async function start(name, { ssh: ssh$1, repo }) {
     await client.post(
       "/xrpc/io.pocketenv.sandbox.startSandbox",
       {
-        repo
+        repo,
+        keepAlive
       },
       {
         params: {
@@ -536,7 +542,7 @@ function detectLightTerminal() {
       if (!savedState) return false;
       const tty = fs.openSync("/dev/tty", "r+");
       try {
-        execSync("stty raw -echo min 0 time 2 </dev/tty 2>/dev/null");
+        execSync("stty -icanon -echo min 0 time 2 </dev/tty 2>/dev/null");
         fs.writeSync(tty, "\x1B]11;?\x07");
         let resp = "";
         const buf = Buffer.alloc(64);
@@ -553,8 +559,14 @@ function detectLightTerminal() {
           return 0.299 * r + 0.587 * g + 0.114 * b > 127;
         }
       } finally {
-        fs.closeSync(tty);
-        execSync(`stty ${savedState} </dev/tty 2>/dev/null`);
+        try {
+          fs.closeSync(tty);
+        } catch {
+        }
+        try {
+          execSync(`stty ${savedState} </dev/tty 2>/dev/null`);
+        } catch {
+        }
       }
     } catch {
     }
@@ -1639,6 +1651,160 @@ async function exec(sandbox, command) {
   }
 }
 
+dayjs.extend(relativeTime);
+async function createService(sandboxId, name, command, { ports, description }) {
+  const token = await getAccessToken();
+  try {
+    await client.post(
+      "/xrpc/io.pocketenv.service.addService",
+      {
+        service: {
+          name,
+          command: command.join(" "),
+          description,
+          ports: ports?.map((port) => parseInt(port))
+        }
+      },
+      {
+        params: {
+          sandboxId
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    consola.success(`Service ${c.highlight(name)} created successfully`);
+  } catch (error) {
+    consola.error("Failed to create service", error);
+    process$1.exit(1);
+  }
+}
+async function listServices(sandboxId) {
+  const token = await getAccessToken();
+  try {
+    const { data } = await client.get(
+      "/xrpc/io.pocketenv.service.getServices",
+      {
+        params: {
+          sandboxId
+        },
+        headers: {
+          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+        }
+      }
+    );
+    const table = new Table({
+      head: [
+        c.primary("ID"),
+        c.primary("NAME"),
+        c.primary("COMMAND"),
+        c.primary("STATUS"),
+        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 service of data.services) {
+      table.push([
+        c.secondary(service.id),
+        service.name,
+        service.command,
+        service.status === "RUNNING" ? c.highlight(service.status) : service.status,
+        dayjs(service.createdAt).fromNow()
+      ]);
+    }
+    consola.log(table.toString());
+  } catch (error) {
+    consola.error("Failed to list services", error);
+    process$1.exit(1);
+  }
+}
+async function restartService(serviceId) {
+  const token = await getAccessToken();
+  try {
+    await client.post("/xrpc/io.pocketenv.service.restartService", void 0, {
+      params: {
+        serviceId
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    });
+  } catch (error) {
+    consola.error(`Failed to restart service ${serviceId}`, error);
+    process$1.exit(1);
+  }
+}
+async function startService(serviceId) {
+  const token = await getAccessToken();
+  try {
+    await client.post("/xrpc/io.pocketenv.service.startService", void 0, {
+      params: {
+        serviceId
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    });
+  } catch (error) {
+    consola.error(`Failed to start service ${serviceId}`, error);
+    process$1.exit(1);
+  }
+}
+async function stopService(serviceId) {
+  const token = await getAccessToken();
+  try {
+    await client.post("/xrpc/io.pocketenv.service.stopService", void 0, {
+      params: {
+        serviceId
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    });
+  } catch (error) {
+    consola.error(`Failed to stop service ${serviceId}`, error);
+    process$1.exit(1);
+  }
+}
+async function deleteService(serviceId) {
+  const token = await getAccessToken();
+  try {
+    await client.post("/xrpc/io.pocketenv.service.deleteService", void 0, {
+      params: {
+        serviceId
+      },
+      headers: {
+        Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+      }
+    });
+    consola.success(`Service ${c.highlight(serviceId)} deleted successfully`);
+  } catch (error) {
+    consola.error(`Failed to delete service ${serviceId}`, error);
+    process$1.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")}`
@@ -1668,6 +1834,9 @@ 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").option(
   "--repo, -r <repo>",
   "the repository to clone into the sandbox (e.g., github:user/repo, tangled:user/repo, or a Git URL)"
+).option(
+  "--keep-alive, -k",
+  "keep the sandbox alive, ignoring inactivity timeout"
 ).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(
@@ -1720,6 +1889,13 @@ sshkeys.command("get").argument("<sandbox>", "the sandbox to get the SSH key fro
 const tailscale = program.command("tailscale").description("manage Tailscale");
 tailscale.command("put").argument("<sandbox>", "the sandbox to put the Tailscale Auth Key in").description("put a Tailscale Auth Key in the given sandbox").action(putAuthKey);
 tailscale.command("get").argument("<sandbox>", "the sandbox to get the Tailscale Auth Key from").description("get a Tailscale Auth Key (redacted) from the given sandbox").action(getTailscaleAuthKey);
+const service = program.command("service").description("manage services");
+service.command("create").argument("<sandbox>", "the sandbox to create the service in").argument("<name>", "the name of the service").argument("<command...>", "the command to run for the service").option("--description, -d <description>", "a description for the service").option("--ports, -p <ports...>", "a list of ports to expose for the service").description("create a new service in the given sandbox").action(createService);
+service.command("list").aliases(["ls"]).argument("<sandbox>", "the sandbox to list services for").description("list services in the given sandbox").action(listServices);
+service.command("delete").aliases(["rm", "remove"]).argument("<service_id>", "the ID of the service to delete").description("delete a service").action(deleteService);
+service.command("start").argument("<service_id>", "the ID of the service to start").description("start a service").action(startService);
+service.command("stop").argument("<service_id>", "the ID of the service to stop").description("stop a service").action(stopService);
+service.command("restart").argument("<service_id>", "the ID of the service to restart").description("restart a service").action(restartService);
 if (process.argv.length <= 2) {
   program.help();
 }

package/package.json

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

package/src/cmd/service.ts

@@ -0,0 +1,191 @@
+import consola from "consola";
+import { client } from "../client";
+import { env } from "../lib/env";
+import getAccessToken from "../lib/getAccessToken";
+import type { Service } from "../types/service";
+import Table from "cli-table3";
+import dayjs from "dayjs";
+import relativeTime from "dayjs/plugin/relativeTime";
+import { c } from "../theme";
+import process from "node:process";
+
+dayjs.extend(relativeTime);
+
+type CreateServiceOptions = {
+  ports?: string[];
+  description?: string;
+};
+
+export async function createService(
+  sandboxId: string,
+  name: string,
+  command: string[],
+  { ports, description }: CreateServiceOptions,
+) {
+  const token = await getAccessToken();
+
+  try {
+    await client.post(
+      "/xrpc/io.pocketenv.service.addService",
+      {
+        service: {
+          name,
+          command: command.join(" "),
+          description,
+          ports: ports?.map((port) => parseInt(port)),
+        },
+      },
+      {
+        params: {
+          sandboxId,
+        },
+        headers: {
+          Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+        },
+      },
+    );
+
+    consola.success(`Service ${c.highlight(name)} created successfully`);
+  } catch (error) {
+    consola.error("Failed to create service", error);
+    process.exit(1);
+  }
+}
+
+export async function listServices(sandboxId: string) {
+  const token = await getAccessToken();
+
+  try {
+    const { data } = await client.get<{ services: Service[] }>(
+      "/xrpc/io.pocketenv.service.getServices",
+      {
+        params: {
+          sandboxId,
+        },
+        headers: {
+          Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+        },
+      },
+    );
+
+    const table = new Table({
+      head: [
+        c.primary("ID"),
+        c.primary("NAME"),
+        c.primary("COMMAND"),
+        c.primary("STATUS"),
+        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 service of data.services) {
+      table.push([
+        c.secondary(service.id),
+        service.name,
+        service.command,
+        service.status === "RUNNING"
+          ? c.highlight(service.status)
+          : service.status,
+        dayjs(service.createdAt).fromNow(),
+      ]);
+    }
+
+    consola.log(table.toString());
+  } catch (error) {
+    consola.error("Failed to list services", error);
+    process.exit(1);
+  }
+}
+
+export async function restartService(serviceId: string) {
+  const token = await getAccessToken();
+  try {
+    await client.post("/xrpc/io.pocketenv.service.restartService", undefined, {
+      params: {
+        serviceId,
+      },
+      headers: {
+        Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+      },
+    });
+  } catch (error) {
+    consola.error(`Failed to restart service ${serviceId}`, error);
+    process.exit(1);
+  }
+}
+
+export async function startService(serviceId: string) {
+  const token = await getAccessToken();
+
+  try {
+    await client.post("/xrpc/io.pocketenv.service.startService", undefined, {
+      params: {
+        serviceId,
+      },
+      headers: {
+        Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+      },
+    });
+  } catch (error) {
+    consola.error(`Failed to start service ${serviceId}`, error);
+    process.exit(1);
+  }
+}
+
+export async function stopService(serviceId: string) {
+  const token = await getAccessToken();
+
+  try {
+    await client.post("/xrpc/io.pocketenv.service.stopService", undefined, {
+      params: {
+        serviceId,
+      },
+      headers: {
+        Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+      },
+    });
+  } catch (error) {
+    consola.error(`Failed to stop service ${serviceId}`, error);
+    process.exit(1);
+  }
+}
+
+export async function deleteService(serviceId: string) {
+  const token = await getAccessToken();
+
+  try {
+    await client.post("/xrpc/io.pocketenv.service.deleteService", undefined, {
+      params: {
+        serviceId,
+      },
+      headers: {
+        Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+      },
+    });
+    consola.success(`Service ${c.highlight(serviceId)} deleted successfully`);
+  } catch (error) {
+    consola.error(`Failed to delete service ${serviceId}`, error);
+    process.exit(1);
+  }
+}

package/src/cmd/start.ts

@@ -9,7 +9,11 @@ import waitUntilRunning from "../lib/waitUntilRunning";
 
 async function start(
   name: string,
-  { ssh, repo }: { ssh?: boolean; repo?: string },
+  {
+    ssh,
+    repo,
+    keepAlive,
+  }: { ssh?: boolean; repo?: string; keepAlive?: boolean },
 ) {
   const token = await getAccessToken();
   if (repo) repo = expandRepo(repo);
@@ -20,6 +24,7 @@ async function start(
       "/xrpc/io.pocketenv.sandbox.startSandbox",
       {
         repo,
+        keepAlive,
       },
       {
         params: {

package/src/index.ts

@@ -23,6 +23,14 @@ import { listPorts } from "./cmd/ports";
 import { c } from "./theme";
 import { exposeVscode } from "./cmd/vscode";
 import { exec } from "./cmd/exec";
+import {
+  createService,
+  deleteService,
+  listServices,
+  restartService,
+  startService,
+  stopService,
+} from "./cmd/service";
 
 const program = new Command();
 
@@ -81,6 +89,10 @@ program
     "--repo, -r <repo>",
     "the repository to clone into the sandbox (e.g., github:user/repo, tangled:user/repo, or a Git URL)",
   )
+  .option(
+    "--keep-alive, -k",
+    "keep the sandbox alive, ignoring inactivity timeout",
+  )
   .description("start the given sandbox")
   .action(start);
 
@@ -296,6 +308,50 @@ tailscale
   .description("get a Tailscale Auth Key (redacted) from the given sandbox")
   .action(getTailscaleAuthKey);
 
+const service = program.command("service").description("manage services");
+
+service
+  .command("create")
+  .argument("<sandbox>", "the sandbox to create the service in")
+  .argument("<name>", "the name of the service")
+  .argument("<command...>", "the command to run for the service")
+  .option("--description, -d <description>", "a description for the service")
+  .option("--ports, -p <ports...>", "a list of ports to expose for the service")
+  .description("create a new service in the given sandbox")
+  .action(createService);
+
+service
+  .command("list")
+  .aliases(["ls"])
+  .argument("<sandbox>", "the sandbox to list services for")
+  .description("list services in the given sandbox")
+  .action(listServices);
+
+service
+  .command("delete")
+  .aliases(["rm", "remove"])
+  .argument("<service_id>", "the ID of the service to delete")
+  .description("delete a service")
+  .action(deleteService);
+
+service
+  .command("start")
+  .argument("<service_id>", "the ID of the service to start")
+  .description("start a service")
+  .action(startService);
+
+service
+  .command("stop")
+  .argument("<service_id>", "the ID of the service to stop")
+  .description("stop a service")
+  .action(stopService);
+
+service
+  .command("restart")
+  .argument("<service_id>", "the ID of the service to restart")
+  .description("restart a service")
+  .action(restartService);
+
 if (process.argv.length <= 2) {
   program.help();
 }

package/src/theme.ts

@@ -27,7 +27,9 @@ function detectLightTerminal(): boolean {
       if (!savedState) return false;
       const tty = fs.openSync("/dev/tty", "r+");
       try {
-        execSync("stty raw -echo min 0 time 2 </dev/tty 2>/dev/null");
+        // Use -icanon -echo instead of raw: avoids disabling ISIG (Ctrl+C) so
+        // signal handling stays intact even if the restore below fails.
+        execSync("stty -icanon -echo min 0 time 2 </dev/tty 2>/dev/null");
         fs.writeSync(tty, "\x1b]11;?\x07");
         // Read in a loop until we see the response terminator (BEL or ST),
         // so leftover bytes don't leak into the terminal input buffer.
@@ -47,8 +49,8 @@ function detectLightTerminal(): boolean {
           return 0.299 * r + 0.587 * g + 0.114 * b > 127;
         }
       } finally {
-        fs.closeSync(tty);
-        execSync(`stty ${savedState} </dev/tty 2>/dev/null`);
+        try { fs.closeSync(tty); } catch {}
+        try { execSync(`stty ${savedState} </dev/tty 2>/dev/null`); } catch {}
       }
     } catch {}
   }

package/src/types/service.ts

@@ -0,0 +1,9 @@
+export type Service = {
+  id: string;
+  name: string;
+  ports?: number[];
+  command: string;
+  description?: string;
+  status: "RUNNING" | "STOPPED";
+  createdAt: string;
+};