@pocketenv/cli 0.3.2 → 0.3.4

package/dist/index.js

@@ -2,7 +2,7 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import consola from 'consola';
-import fs from 'fs/promises';
+import fs$1 from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { env as env$2 } from 'process';
@@ -13,21 +13,23 @@ import { EventSource } from 'eventsource';
 import open from 'open';
 import express from 'express';
 import cors from 'cors';
-import fs$1 from 'node:fs/promises';
+import fs$2 from 'node:fs/promises';
 import os$1 from 'node:os';
 import path$1 from 'node:path';
 import Table from 'cli-table3';
 import dayjs from 'dayjs';
 import relativeTime from 'dayjs/plugin/relativeTime.js';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
 import { password, editor, input } from '@inquirer/prompts';
 import sodium from 'libsodium-wrappers';
 
-var version = "0.3.2";
+var version = "0.3.4";
 
 async function getAccessToken() {
   const tokenPath = path.join(os.homedir(), ".pocketenv", "token.json");
   try {
-    await fs.access(tokenPath);
+    await fs$1.access(tokenPath);
   } catch (err) {
     if (!env$2.POCKETENV_TOKEN) {
       consola.error(
@@ -38,7 +40,7 @@ async function getAccessToken() {
       process.exit(1);
     }
   }
-  const tokenData = await fs.readFile(tokenPath, "utf-8");
+  const tokenData = await fs$1.readFile(tokenPath, "utf-8");
   const { token } = JSON.parse(tokenData);
   if (!token) {
     consola.error(
@@ -415,13 +417,34 @@ function expandRepo(repo) {
   if (githubMatch) return `https://github.com/${githubMatch[1]}`;
   const tangledMatch = repo.match(/^tangled:([^/]+\/[^/]+)$/);
   if (tangledMatch) return `https://tangled.org/${tangledMatch[1]}`;
+  const gitlabMatch = repo.match(/^gitlab:([^/]+\/[^/]+)$/);
+  if (gitlabMatch) return `https://gitlab.com/${gitlabMatch[1]}`;
   return repo;
 }
 
+async function waitUntilRunning(name, authToken, timeoutMs = 6e4, intervalMs = 2e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const response = await client.get(
+      "/xrpc/io.pocketenv.sandbox.getSandbox",
+      {
+        params: { id: name },
+        headers: { Authorization: `Bearer ${authToken}` }
+      }
+    );
+    if (response.data.sandbox?.status === "RUNNING") return;
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error(
+    `Sandbox ${name} did not reach RUNNING state within ${timeoutMs / 1e3}s`
+  );
+}
+
 async function start(name, { ssh: ssh$1, repo }) {
   const token = await getAccessToken();
   if (repo) repo = expandRepo(repo);
   try {
+    const authToken = env$1.POCKETENV_TOKEN || token;
     await client.post(
       "/xrpc/io.pocketenv.sandbox.startSandbox",
       {
@@ -432,11 +455,12 @@ async function start(name, { ssh: ssh$1, repo }) {
           id: name
         },
         headers: {
-          Authorization: `Bearer ${env$1.POCKETENV_TOKEN || token}`
+          Authorization: `Bearer ${authToken}`
         }
       }
     );
     if (ssh$1) {
+      await waitUntilRunning(name, authToken);
       await ssh(name);
       return;
     }
@@ -457,8 +481,8 @@ async function login(handle) {
   app.post("/token", async (req, res) => {
     console.log(chalk.bold(chalk.greenBright("Login successful!\n")));
     const tokenPath = path$1.join(os$1.homedir(), ".pocketenv", "token.json");
-    await fs$1.mkdir(path$1.dirname(tokenPath), { recursive: true });
-    await fs$1.writeFile(
+    await fs$2.mkdir(path$1.dirname(tokenPath), { recursive: true });
+    await fs$2.writeFile(
       tokenPath,
       JSON.stringify({ token: req.body.token }, null, 2)
     );
@@ -495,12 +519,55 @@ async function whoami() {
   );
 }
 
+function detectLightTerminal() {
+  const vscodeTheme = process.env.VSCODE_THEME_KIND;
+  if (vscodeTheme) {
+    return vscodeTheme === "vscode-light" || vscodeTheme === "vscode-high-contrast-light";
+  }
+  const colorfgbg = process.env.COLORFGBG;
+  if (colorfgbg) {
+    const parts = colorfgbg.split(";");
+    const bg = parseInt(parts[parts.length - 1] ?? "", 10);
+    if (!isNaN(bg)) return bg >= 8;
+  }
+  if (process.stdout.isTTY) {
+    try {
+      const savedState = execSync("stty -g </dev/tty 2>/dev/null", { encoding: "utf8" }).trim();
+      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");
+        fs.writeSync(tty, "\x1B]11;?\x07");
+        let resp = "";
+        const buf = Buffer.alloc(64);
+        for (let i = 0; i < 16; i++) {
+          const n = fs.readSync(tty, buf, 0, 64, null);
+          if (n === 0) break;
+          resp += buf.slice(0, n).toString();
+          if (resp.includes("\x07") || resp.includes("\x1B\\")) break;
+        }
+        const m = resp.match(/rgb:([0-9a-f]+)\/([0-9a-f]+)\/([0-9a-f]+)/i);
+        if (m?.[1] && m[2] && m[3]) {
+          const norm = (h) => parseInt(h.slice(0, 2), 16);
+          const r = norm(m[1]), g = norm(m[2]), b = norm(m[3]);
+          return 0.299 * r + 0.587 * g + 0.114 * b > 127;
+        }
+      } finally {
+        fs.closeSync(tty);
+        execSync(`stty ${savedState} </dev/tty 2>/dev/null`);
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+const isLightTerminal = detectLightTerminal();
 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),
+  muted: (s) => isLightTerminal ? chalk.black(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)
@@ -619,6 +686,7 @@ async function createSandbox(name, {
       );
       return;
     }
+    await waitUntilRunning(sandbox.data.name, token);
     await ssh(sandbox.data.name);
   } catch (error) {
     consola.error(`Failed to create sandbox: ${error}`);
@@ -628,12 +696,12 @@ async function createSandbox(name, {
 async function logout() {
   const tokenPath = path$1.join(os$1.homedir(), ".pocketenv", "token.json");
   try {
-    await fs$1.access(tokenPath);
+    await fs$2.access(tokenPath);
   } catch {
     consola.log("Logged out successfully");
     return;
   }
-  await fs$1.unlink(tokenPath);
+  await fs$2.unlink(tokenPath);
   consola.log("Logged out successfully");
 }
 
@@ -1032,10 +1100,10 @@ async function putKeys(sandbox, options) {
     publicKey = generated.publicKey;
   }
   if (options.privateKey && !options.generate) {
-    privateKey = await fs$1.readFile(options.privateKey, "utf8");
+    privateKey = await fs$2.readFile(options.privateKey, "utf8");
   }
   if (options.publicKey && !options.generate) {
-    publicKey = await fs$1.readFile(options.publicKey, "utf8");
+    publicKey = await fs$2.readFile(options.publicKey, "utf8");
   }
   const validatePrivateKey = (value) => {
     const trimmed = value.trim();
@@ -1360,12 +1428,12 @@ async function putFile(sandbox, remotePath, localPath) {
   } else if (localPath) {
     const resolvedPath = path.resolve(localPath);
     try {
-      await fs.access(resolvedPath);
+      await fs$1.access(resolvedPath);
     } catch (err) {
       consola.error(`No such file: ${c.error(localPath)}`);
       process.exit(1);
     }
-    content = await fs.readFile(resolvedPath, "utf-8");
+    content = await fs$1.readFile(resolvedPath, "utf-8");
   } else {
     content = (await editor({
       message: "File content (opens in $EDITOR):",

package/package.json

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

package/src/cmd/create.ts

@@ -5,6 +5,7 @@ import type { Sandbox } from "../types/sandbox";
 import connectToSandbox from "./ssh";
 import { c } from "../theme";
 import { expandRepo } from "../lib/expandRepo";
+import waitUntilRunning from "../lib/waitUntilRunning";
 
 async function createSandbox(
   name: string,
@@ -52,6 +53,7 @@ async function createSandbox(
       );
       return;
     }
+    await waitUntilRunning(sandbox.data.name, token);
     await connectToSandbox(sandbox.data.name);
   } catch (error) {
     consola.error(`Failed to create sandbox: ${error}`);

package/src/cmd/start.ts

@@ -5,6 +5,7 @@ import { client } from "../client";
 import { env } from "../lib/env";
 import connectToSandbox from "./ssh";
 import { expandRepo } from "../lib/expandRepo";
+import waitUntilRunning from "../lib/waitUntilRunning";
 
 async function start(
   name: string,
@@ -14,6 +15,7 @@ async function start(
   if (repo) repo = expandRepo(repo);
 
   try {
+    const authToken = env.POCKETENV_TOKEN || token;
     await client.post(
       "/xrpc/io.pocketenv.sandbox.startSandbox",
       {
@@ -24,12 +26,13 @@ async function start(
           id: name,
         },
         headers: {
-          Authorization: `Bearer ${env.POCKETENV_TOKEN || token}`,
+          Authorization: `Bearer ${authToken}`,
         },
       },
     );
 
     if (ssh) {
+      await waitUntilRunning(name, authToken);
       await connectToSandbox(name);
       return;
     }

package/src/lib/expandRepo.ts

@@ -5,5 +5,8 @@ export function expandRepo(repo: string): string {
   const tangledMatch = repo.match(/^tangled:([^/]+\/[^/]+)$/);
   if (tangledMatch) return `https://tangled.org/${tangledMatch[1]}`;
 
+  const gitlabMatch = repo.match(/^gitlab:([^/]+\/[^/]+)$/);
+  if (gitlabMatch) return `https://gitlab.com/${gitlabMatch[1]}`;
+
   return repo;
 }

package/src/lib/waitUntilRunning.ts

@@ -0,0 +1,27 @@
+import { client } from "../client";
+import type { Sandbox } from "../types/sandbox";
+
+async function waitUntilRunning(
+  name: string,
+  authToken: string,
+  timeoutMs = 60_000,
+  intervalMs = 2_000,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const response = await client.get<{ sandbox: Sandbox | null }>(
+      "/xrpc/io.pocketenv.sandbox.getSandbox",
+      {
+        params: { id: name },
+        headers: { Authorization: `Bearer ${authToken}` },
+      },
+    );
+    if (response.data.sandbox?.status === "RUNNING") return;
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error(
+    `Sandbox ${name} did not reach RUNNING state within ${timeoutMs / 1000}s`,
+  );
+}
+
+export default waitUntilRunning;

package/src/theme.ts

@@ -1,11 +1,69 @@
 import chalk from "chalk";
+import { execSync } from "child_process";
+import * as fs from "fs";
+
+function detectLightTerminal(): boolean {
+  // VS Code terminal
+  const vscodeTheme = process.env.VSCODE_THEME_KIND;
+  if (vscodeTheme) {
+    return vscodeTheme === "vscode-light" || vscodeTheme === "vscode-high-contrast-light";
+  }
+
+  // COLORFGBG — set by xterm, iTerm2, etc. ("fg;bg", bg >= 8 = light)
+  const colorfgbg = process.env.COLORFGBG;
+  if (colorfgbg) {
+    const parts = colorfgbg.split(";");
+    const bg = parseInt(parts[parts.length - 1] ?? "", 10);
+    if (!isNaN(bg)) return bg >= 8;
+  }
+
+  // OSC 11 background color query — works with Apple Terminal, iTerm2, etc.
+  // stty is redirected from /dev/tty explicitly because execSync pipes stdio,
+  // which means stty would otherwise fail to find the terminal.
+  if (process.stdout.isTTY) {
+    try {
+      const savedState = execSync("stty -g </dev/tty 2>/dev/null", { encoding: "utf8" }).trim();
+      // If we couldn't save the state, skip to avoid leaving the terminal in raw mode.
+      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");
+        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.
+        let resp = "";
+        const buf = Buffer.alloc(64);
+        for (let i = 0; i < 16; i++) {
+          const n = fs.readSync(tty, buf, 0, 64, null);
+          if (n === 0) break;
+          resp += buf.slice(0, n).toString();
+          if (resp.includes("\x07") || resp.includes("\x1b\\")) break;
+        }
+        const m = resp.match(/rgb:([0-9a-f]+)\/([0-9a-f]+)\/([0-9a-f]+)/i);
+        if (m?.[1] && m[2] && m[3]) {
+          // Components can be 2 or 4 hex digits; normalize to 0-255
+          const norm = (h: string) => parseInt(h.slice(0, 2), 16);
+          const r = norm(m[1]), g = norm(m[2]), b = norm(m[3]);
+          return 0.299 * r + 0.587 * g + 0.114 * b > 127;
+        }
+      } finally {
+        fs.closeSync(tty);
+        execSync(`stty ${savedState} </dev/tty 2>/dev/null`);
+      }
+    } catch {}
+  }
+
+  return false;
+}
+
+const isLightTerminal = detectLightTerminal();
 
 export const c = {
   primary: (s: string | number) => chalk.rgb(0, 232, 198)(s),
   secondary: (s: string | number) => chalk.rgb(0, 198, 232)(s),
   accent: (s: string | number) => chalk.rgb(130, 100, 255)(s),
   highlight: (s: string | number) => chalk.rgb(100, 232, 130)(s),
-  muted: (s: string | number) => chalk.rgb(200, 210, 220)(s),
+  muted: (s: string | number) => isLightTerminal ? chalk.black(s) : chalk.rgb(200, 210, 220)(s),
   link: (s: string | number) => chalk.rgb(255, 160, 100)(s),
   sky: (s: string | number) => chalk.rgb(0, 210, 255)(s),
   error: (s: string | number) => chalk.rgb(255, 100, 100)(s),