deepspace 0.3.6 → 0.3.8

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/cli.ts
-import { defineCommand as defineCommand14, runMain } from "citty";
+import { defineCommand as defineCommand16, runMain } from "citty";
 import { execSync as execSync5 } from "child_process";
 import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
 import { dirname as dirname2, join as join12 } from "path";
@@ -14,7 +14,24 @@ import { join as join2 } from "path";
 import { homedir } from "os";
 import { exec } from "child_process";
 import { platform } from "os";
+import * as p2 from "@clack/prompts";
+
+// src/cli/lib/spinner.ts
 import * as p from "@clack/prompts";
+function createSpinner() {
+  if (process.stdout.isTTY) return p.spinner();
+  return {
+    start: (msg) => {
+      if (msg) console.log(msg);
+    },
+    stop: (msg) => {
+      if (msg) console.log(msg);
+    },
+    message: (msg) => {
+      if (msg) console.log(msg);
+    }
+  };
+}
 
 // src/cli/env.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
@@ -261,36 +278,36 @@ var login_default = defineCommand({
       console.log("Logged in");
       return;
     }
-    p.intro("DeepSpace Login");
-    const s = p.spinner();
+    p2.intro("DeepSpace Login");
+    const s = createSpinner();
     s.start("Creating login session...");
     const sessionRes = await fetch(`${AUTH_URL}/api/auth/cli/session`, { method: "POST" });
     if (!sessionRes.ok) {
       s.stop("Failed");
-      p.cancel("Could not create login session");
+      p2.cancel("Could not create login session");
       process.exit(1);
     }
     const sessionData = await sessionRes.json();
     if (!sessionData.sessionId || !sessionData.loginUrl) {
       s.stop("Failed");
-      p.cancel("Could not create login session");
+      p2.cancel("Could not create login session");
       process.exit(1);
     }
     const { sessionId, loginUrl } = sessionData;
     s.stop("Opening browser...");
-    p.log.info(`If the browser doesn't open, visit:
+    p2.log.info(`If the browser doesn't open, visit:
   ${loginUrl}`);
     openBrowser(loginUrl);
     s.start("Waiting for authentication...");
     const result = await pollForCompletion(sessionId);
     if (!result) {
       s.stop("Timed out");
-      p.cancel("Login timed out. Run `deepspace login` to try again.");
+      p2.cancel("Login timed out. Run `deepspace login` to try again.");
       process.exit(1);
     }
     storeCredentials(result.sessionToken, result.jwt);
     s.stop("Authenticated");
-    p.outro(`Logged in as ${result.name ?? result.email}`);
+    p2.outro(`Logged in as ${result.name ?? result.email}`);
   }
 });
 async function pollForCompletion(sessionId) {
@@ -328,7 +345,7 @@ function openBrowser(url) {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function doEmailLogin(email, password) {
   const res = await fetch(`${AUTH_URL}/api/auth/sign-in/email`, {
@@ -422,13 +439,13 @@ async function ensureToken() {
       return existing;
     }
   }
-  const token = await exchangeSession(AUTH_URL3, sessionToken);
-  if (!token) {
+  const token2 = await exchangeSession(AUTH_URL3, sessionToken);
+  if (!token2) {
     throw new Error("Session expired. Run `deepspace login` to re-authenticate.");
   }
   mkdirSync2(DIR2, { recursive: true });
-  writeFileSync3(TOKEN_PATH2, token, { mode: 384 });
-  return token;
+  writeFileSync3(TOKEN_PATH2, token2, { mode: 384 });
+  return token2;
 }
 function isTokenValid(jwt) {
   try {
@@ -471,16 +488,16 @@ var dev_default = defineCommand3({
       console.error("No wrangler.toml found. Are you in a DeepSpace app directory?");
       process.exit(1);
     }
-    let token;
+    let token2;
     try {
-      token = await ensureToken();
+      token2 = await ensureToken();
     } catch (err) {
       console.error(err.message);
       process.exit(1);
     }
     let payload;
     try {
-      payload = JSON.parse(atob(token.split(".")[1]));
+      payload = JSON.parse(atob(token2.split(".")[1]));
     } catch {
       console.error("Malformed session token. Run `npx deepspace login`.");
       process.exit(1);
@@ -488,7 +505,7 @@ var dev_default = defineCommand3({
     console.log(`Logged in as ${payload.name ?? payload.email}`);
     console.log(`Environment: ${env}`);
     console.log(`Port: ${port}`);
-    await writeDevVars(appDir, env, payload.sub, token);
+    await writeDevVars(appDir, env, payload.sub, token2);
     console.log("Starting dev server...\n");
     const vite = spawn(
       "npx",
@@ -681,7 +698,33 @@ function isAlive(pid) {
 import { defineCommand as defineCommand5 } from "citty";
 import { existsSync as existsSync5 } from "fs";
 import { join as join6, resolve as resolve2 } from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+
+// src/cli/lib/playwright.ts
 import { execSync, spawnSync as spawnSync2 } from "child_process";
+function ensurePlaywright(appDir) {
+  try {
+    execSync("npx playwright --version", { cwd: appDir, stdio: "pipe" });
+  } catch {
+    console.log("Installing Playwright...");
+    execSync("npm install -D @playwright/test", { cwd: appDir, stdio: "pipe" });
+  }
+  const isLinux = process.platform === "linux";
+  const isRoot = isLinux && typeof process.getuid === "function" && process.getuid() === 0;
+  const args = isRoot ? ["install", "--with-deps", "chromium"] : ["install", "chromium"];
+  const result = spawnSync2("npx", ["playwright", ...args], {
+    cwd: appDir,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) {
+    console.error("\nPlaywright install failed. On Linux, system libs may be missing. Try:");
+    console.error("  sudo npx playwright install --with-deps chromium");
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/test.ts
 var DEFAULT_PORT3 = 5173;
 var test_default = defineCommand5({
   meta: {
@@ -708,17 +751,17 @@ var test_default = defineCommand5({
       console.error("No wrangler.toml found. Are you in a DeepSpace app directory?");
       process.exit(1);
     }
-    let token;
+    let token2;
     let ownerId;
     try {
-      token = await ensureToken();
-      const payload = JSON.parse(atob(token.split(".")[1]));
+      token2 = await ensureToken();
+      const payload = JSON.parse(atob(token2.split(".")[1]));
       ownerId = payload.sub;
     } catch (err) {
       console.error("`deepspace test` requires you to be logged in. Run `deepspace login` first.");
       process.exit(1);
     }
-    await writeDevVars(appDir, "dev", ownerId, token);
+    await writeDevVars(appDir, "dev", ownerId, token2);
     if (suite !== "unit") {
       ensurePlaywright(appDir);
     }
@@ -756,7 +799,7 @@ var test_default = defineCommand5({
   }
 });
 function runPlaywright(appDir, testFiles, port) {
-  const result = spawnSync2("npx", [
+  const result = spawnSync3("npx", [
     "playwright",
     "test",
     "--config",
@@ -771,30 +814,13 @@ function runPlaywright(appDir, testFiles, port) {
   return result.status ?? 1;
 }
 function runVitest(appDir) {
-  const result = spawnSync2("npx", ["vitest", "run", "--passWithNoTests"], {
+  const result = spawnSync3("npx", ["vitest", "run", "--passWithNoTests"], {
     cwd: appDir,
     stdio: "inherit",
     shell: process.platform === "win32"
   });
   return result.status ?? 1;
 }
-function ensurePlaywright(appDir) {
-  try {
-    execSync("npx playwright --version", { cwd: appDir, stdio: "pipe" });
-  } catch {
-    console.log("Installing Playwright...");
-    execSync("npm install -D @playwright/test", { cwd: appDir, stdio: "pipe" });
-  }
-  const isLinux = process.platform === "linux";
-  const isRoot = isLinux && typeof process.getuid === "function" && process.getuid() === 0;
-  const args = isRoot ? ["install", "--with-deps", "chromium"] : ["install", "chromium"];
-  const result = spawnSync2("npx", ["playwright", ...args], { cwd: appDir, stdio: "inherit" });
-  if (result.status !== 0) {
-    console.error("\nPlaywright install failed. On Linux, system libs may be missing \u2014 try:");
-    console.error("  sudo npx playwright install --with-deps chromium");
-    process.exit(1);
-  }
-}
 function resolvePort3(arg) {
   const raw = arg ?? process.env.DEEPSPACE_PORT;
   if (!raw) return DEFAULT_PORT3;
@@ -806,9 +832,57 @@ function resolvePort3(arg) {
   return n;
 }
 
-// src/cli/commands/test-accounts.ts
+// src/cli/commands/screenshot.ts
 import { defineCommand as defineCommand6 } from "citty";
-import * as p2 from "@clack/prompts";
+import { spawnSync as spawnSync4 } from "child_process";
+import { resolve as resolve3 } from "path";
+var screenshot_default = defineCommand6({
+  meta: {
+    name: "screenshot",
+    description: "Take a Playwright screenshot, installing Chromium on demand"
+  },
+  args: {
+    url: {
+      type: "positional",
+      description: "URL to capture, for example http://localhost:5173/",
+      required: true
+    },
+    output: {
+      type: "positional",
+      description: "Output image path, for example screenshot.png",
+      required: true
+    },
+    "full-page": {
+      type: "boolean",
+      description: "Capture the full scrollable page",
+      required: false
+    },
+    "wait-for-timeout": {
+      type: "string",
+      description: "Milliseconds to wait before capture",
+      required: false
+    }
+  },
+  run({ args }) {
+    const appDir = resolve3(".");
+    ensurePlaywright(appDir);
+    const playwrightArgs = ["playwright", "screenshot", args.url, args.output];
+    if (args["full-page"]) playwrightArgs.push("--full-page");
+    if (args["wait-for-timeout"]) {
+      playwrightArgs.push("--wait-for-timeout", String(args["wait-for-timeout"]));
+    }
+    const result = spawnSync4("npx", playwrightArgs, {
+      cwd: appDir,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    process.exit(result.status ?? 1);
+  }
+});
+
+// src/cli/commands/test-accounts.ts
+import { defineCommand as defineCommand7 } from "citty";
+import * as p3 from "@clack/prompts";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
 import { join as join7 } from "path";
 import { homedir as homedir4 } from "os";
@@ -829,8 +903,8 @@ function saveAccounts(accounts) {
   writeFileSync4(ACCOUNTS_PATH, JSON.stringify(accounts, null, 2), { mode: 384 });
 }
 function sessionCookie() {
-  const token = readFileSync4(SESSION_PATH2, "utf-8").trim();
-  return `${SESSION_COOKIE2}=${encodeURIComponent(token)}`;
+  const token2 = readFileSync4(SESSION_PATH2, "utf-8").trim();
+  return `${SESSION_COOKIE2}=${encodeURIComponent(token2)}`;
 }
 async function fetchRemoteAccounts() {
   const res = await fetch(`${AUTH_URL4}/api/auth/test-accounts`, {
@@ -852,7 +926,7 @@ async function deleteRemote(id) {
     throw new Error(data.error ?? `DELETE returned ${res.status}`);
   }
 }
-var create = defineCommand6({
+var create = defineCommand7({
   meta: {
     name: "create",
     description: "Create a test account"
@@ -922,7 +996,7 @@ var create = defineCommand6({
 Saved to ${ACCOUNTS_PATH}`);
   }
 });
-var list = defineCommand6({
+var list = defineCommand7({
   meta: {
     name: "list",
     description: "List your test accounts"
@@ -957,7 +1031,7 @@ var list = defineCommand6({
     }
   }
 });
-var del = defineCommand6({
+var del = defineCommand7({
   meta: {
     name: "delete",
     description: "Delete a test account by --email or --id"
@@ -1014,7 +1088,7 @@ var del = defineCommand6({
     console.log(`Test account deleted${targetEmail ? `: ${targetEmail}` : `: ${targetId}`}`);
   }
 });
-var clear = defineCommand6({
+var clear = defineCommand7({
   meta: {
     name: "clear",
     description: "Delete all your test accounts (or those matching --label)"
@@ -1048,11 +1122,11 @@ var clear = defineCommand6({
     }
     if (!args.yes) {
       const subject = args.label ? `${targets.length} test account(s) labeled '${args.label}'` : `all ${targets.length} test account(s)`;
-      const confirmed = await p2.confirm({
+      const confirmed = await p3.confirm({
         message: `Delete ${subject}? This is not reversible.`,
         initialValue: false
       });
-      if (p2.isCancel(confirmed) || !confirmed) {
+      if (p3.isCancel(confirmed) || !confirmed) {
         console.log("Cancelled.");
         return;
       }
@@ -1080,7 +1154,7 @@ Failed:`);
     }
   }
 });
-var test_accounts_default = defineCommand6({
+var test_accounts_default = defineCommand7({
   meta: {
     name: "test-accounts",
     description: "Manage test accounts for development"
@@ -1094,12 +1168,12 @@ var test_accounts_default = defineCommand6({
 });
 
 // src/cli/commands/deploy.ts
-import { defineCommand as defineCommand7 } from "citty";
+import { defineCommand as defineCommand8 } from "citty";
 import { execSync as execSync2 } from "child_process";
 import { readFileSync as readFileSync5, readdirSync, existsSync as existsSync7 } from "fs";
 import { parse as parseToml2 } from "smol-toml";
-import { join as join8, resolve as resolve3, dirname } from "path";
-import * as p3 from "@clack/prompts";
+import { join as join8, resolve as resolve4, dirname } from "path";
+import * as p4 from "@clack/prompts";
 
 // src/server/rooms/binding-manifest.ts
 var AUTO_PROVISION_SENTINEL = "auto";
@@ -1359,7 +1433,7 @@ function sanitizeAppName(raw) {
 
 // src/cli/commands/deploy.ts
 var DEPLOY_URL = process.env.DEEPSPACE_DEPLOY_URL ?? ENVS.prod.deploy;
-var deploy_default = defineCommand7({
+var deploy_default = defineCommand8({
   meta: {
     name: "deploy",
     description: "Build and deploy your DeepSpace app"
@@ -1372,30 +1446,30 @@ var deploy_default = defineCommand7({
     }
   },
   async run({ args }) {
-    const appDir = resolve3(args.dir ?? ".");
-    p3.intro("Deploying DeepSpace app");
+    const appDir = resolve4(args.dir ?? ".");
+    p4.intro("Deploying DeepSpace app");
     const wranglerPath = join8(appDir, "wrangler.toml");
     if (!existsSync7(wranglerPath)) {
-      p3.cancel("No wrangler.toml found. Are you in a DeepSpace app directory?");
+      p4.cancel("No wrangler.toml found. Are you in a DeepSpace app directory?");
       process.exit(1);
     }
     const wranglerConfig = parseToml2(readFileSync5(wranglerPath, "utf-8"));
     const nameRes = resolveAppName(wranglerConfig.name);
     if (!nameRes.ok) {
-      p3.cancel(`wrangler.toml: ${nameRes.reason}`);
+      p4.cancel(`wrangler.toml: ${nameRes.reason}`);
       process.exit(1);
     }
-    if (nameRes.warning) p3.log.warn(nameRes.warning);
+    if (nameRes.warning) p4.log.warn(nameRes.warning);
     const appName = nameRes.name;
-    p3.log.info(`App: ${appName}`);
-    let token;
+    p4.log.info(`App: ${appName}`);
+    let token2;
     try {
-      token = await ensureToken();
+      token2 = await ensureToken();
     } catch (err) {
-      p3.cancel(err.message);
+      p4.cancel(err.message);
       process.exit(1);
     }
-    const s = p3.spinner();
+    const s = createSpinner();
     s.start("Building...");
     try {
       execSync2("npx vite build", { cwd: appDir, stdio: "pipe" });
@@ -1407,25 +1481,25 @@ var deploy_default = defineCommand7({
     s.stop("Built");
     const deployConfigPath = join8(appDir, ".wrangler", "deploy", "config.json");
     if (!existsSync7(deployConfigPath)) {
-      p3.cancel("Build output config not found at .wrangler/deploy/config.json");
+      p4.cancel("Build output config not found at .wrangler/deploy/config.json");
       process.exit(1);
     }
     const deployConfig = JSON.parse(readFileSync5(deployConfigPath, "utf-8"));
-    const outputWranglerPath = resolve3(dirname(deployConfigPath), deployConfig.configPath);
+    const outputWranglerPath = resolve4(dirname(deployConfigPath), deployConfig.configPath);
     if (!existsSync7(outputWranglerPath)) {
-      p3.cancel(`Output wrangler.json not found at ${outputWranglerPath}`);
+      p4.cancel(`Output wrangler.json not found at ${outputWranglerPath}`);
       process.exit(1);
     }
     const outputConfig = JSON.parse(readFileSync5(outputWranglerPath, "utf-8"));
     const workerDir = dirname(outputWranglerPath);
     const workerBundlePath = join8(workerDir, outputConfig.main);
-    const clientDir = outputConfig.assets?.directory ? resolve3(workerDir, outputConfig.assets.directory) : null;
+    const clientDir = outputConfig.assets?.directory ? resolve4(workerDir, outputConfig.assets.directory) : null;
     if (!existsSync7(workerBundlePath)) {
-      p3.cancel(`Worker bundle not found at ${workerBundlePath}`);
+      p4.cancel(`Worker bundle not found at ${workerBundlePath}`);
       process.exit(1);
     }
     if (!clientDir || !existsSync7(clientDir)) {
-      p3.cancel(`Client assets not found at ${clientDir}`);
+      p4.cancel(`Client assets not found at ${clientDir}`);
       process.exit(1);
     }
     s.start("Collecting assets...");
@@ -1442,19 +1516,19 @@ var deploy_default = defineCommand7({
       sqlite: sqliteClasses.has(b.class_name)
     }));
     if (doManifest?.length) {
-      p3.log.info(`DO manifest: ${doManifest.length} binding(s)`);
+      p4.log.info(`DO manifest: ${doManifest.length} binding(s)`);
     }
     const customBindings = bindingManifestFromOutputConfig(outputConfig);
     const validation = validateBindingManifest(customBindings);
     if (!validation.valid) {
-      p3.cancel(
+      p4.cancel(
         `Invalid binding(s) in wrangler.toml:
 ` + validation.errors.map((e) => `  \u2022 ${e.reason}`).join("\n")
       );
       process.exit(1);
     }
     if (customBindings.length) {
-      p3.log.info(
+      p4.log.info(
         `Custom bindings: ${customBindings.map((b) => `${b.name} (${b.type})`).join(", ")}`
       );
     }
@@ -1466,7 +1540,7 @@ var deploy_default = defineCommand7({
         try {
           userSecrets = parseDevVars(customSection);
         } catch (err) {
-          p3.cancel(`.dev.vars: ${err.message}`);
+          p4.cancel(`.dev.vars: ${err.message}`);
           process.exit(1);
         }
       }
@@ -1478,20 +1552,20 @@ var deploy_default = defineCommand7({
     ]);
     for (const name of userSecretNames) {
       if (RESERVED_BINDING_NAMES.has(name)) {
-        p3.cancel(
+        p4.cancel(
           `.dev.vars: "${name}" is a reserved binding name and cannot be used as an app secret.`
         );
         process.exit(1);
       }
       if (declaredBindingNames.has(name)) {
-        p3.cancel(
+        p4.cancel(
           `.dev.vars: "${name}" collides with a binding declared in wrangler.toml \u2014 rename one or the other.`
         );
         process.exit(1);
       }
     }
     if (userSecretNames.length) {
-      p3.log.info(`App secrets (from .dev.vars): ${userSecretNames.join(", ")}`);
+      p4.log.info(`App secrets (from .dev.vars): ${userSecretNames.join(", ")}`);
     }
     s.start(`Deploying to ${appName}.app.space...`);
     const form = new FormData();
@@ -1508,13 +1582,13 @@ var deploy_default = defineCommand7({
     }
     const res = await fetch(`${DEPLOY_URL}/api/deploy/${appName}`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${token}` },
+      headers: { Authorization: `Bearer ${token2}` },
       body: form
     });
     const body = await res.json().catch(() => ({}));
     if (!res.ok || !body.success) {
       s.stop("Deploy failed");
-      p3.cancel(body.error ?? `Deployment error (${res.status})`);
+      p4.cancel(body.error ?? `Deployment error (${res.status})`);
       process.exit(1);
     }
     if (body.url) {
@@ -1522,15 +1596,15 @@ var deploy_default = defineCommand7({
       const ok = await waitForAssetsReady(body.url, 9e4);
       if (!ok) {
         s.stop("Deployed (edge propagation still in progress after 90s)");
-        p3.log.warn("First requests may briefly hit the assets transitional page; retry in a minute.");
-        p3.log.success(`Live at: ${body.url}`);
-        p3.outro("Done");
+        p4.log.warn("First requests may briefly hit the assets transitional page; retry in a minute.");
+        p4.log.success(`Live at: ${body.url}`);
+        p4.outro("Done");
         return;
       }
     }
     s.stop("Deployed!");
-    p3.log.success(`Live at: ${body.url}`);
-    p3.outro("Done");
+    p4.log.success(`Live at: ${body.url}`);
+    p4.outro("Done");
   }
 });
 async function waitForAssetsReady(url, timeoutMs) {
@@ -1573,13 +1647,13 @@ function collectAssets(dir) {
 }
 
 // src/cli/commands/undeploy.ts
-import { defineCommand as defineCommand8 } from "citty";
+import { defineCommand as defineCommand9 } from "citty";
 import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
 import { join as join9 } from "path";
 import { parse as parseToml3 } from "smol-toml";
-import * as p4 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 var DEPLOY_URL2 = process.env.DEEPSPACE_DEPLOY_URL ?? ENVS.prod.deploy;
-var undeploy_default = defineCommand8({
+var undeploy_default = defineCommand9({
   meta: {
     name: "undeploy",
     description: "Remove a deployed DeepSpace app"
@@ -1601,37 +1675,37 @@ var undeploy_default = defineCommand8({
       }
     }
     if (!appName) {
-      p4.cancel("Provide an app name or run from a DeepSpace app directory.");
+      p5.cancel("Provide an app name or run from a DeepSpace app directory.");
       process.exit(1);
     }
-    let token;
+    let token2;
     try {
-      token = await ensureToken();
+      token2 = await ensureToken();
     } catch (err) {
-      p4.cancel(err.message);
+      p5.cancel(err.message);
       process.exit(1);
     }
-    p4.intro(`Undeploying ${appName}`);
-    const s = p4.spinner();
+    p5.intro(`Undeploying ${appName}`);
+    const s = createSpinner();
     s.start("Removing...");
     const res = await fetch(`${DEPLOY_URL2}/api/deploy/${appName}`, {
       method: "DELETE",
-      headers: { Authorization: `Bearer ${token}` }
+      headers: { Authorization: `Bearer ${token2}` }
     });
     const body = await res.json().catch(() => ({}));
     if (!res.ok || !body.success) {
       s.stop("Failed");
-      p4.cancel(body.error ?? `Undeploy error (${res.status})`);
+      p5.cancel(body.error ?? `Undeploy error (${res.status})`);
       process.exit(1);
     }
     s.stop("Removed");
-    p4.outro(`${appName}.app.space has been taken down`);
+    p5.outro(`${appName}.app.space has been taken down`);
   }
 });
 
 // src/cli/commands/whoami.ts
-import { defineCommand as defineCommand9 } from "citty";
-var whoami_default = defineCommand9({
+import { defineCommand as defineCommand10 } from "citty";
+var whoami_default = defineCommand10({
   meta: {
     name: "whoami",
     description: "Show the currently logged-in user"
@@ -1685,16 +1759,16 @@ var whoami_default = defineCommand9({
 });
 
 // src/cli/commands/add.ts
-import { defineCommand as defineCommand10 } from "citty";
+import { defineCommand as defineCommand11 } from "citty";
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve4, join as join10 } from "path";
+import { resolve as resolve5, join as join10 } from "path";
 import { execSync as execSync3 } from "child_process";
 function findScript(from) {
   const candidate = join10(from, ".deepspace", "scripts", "add-feature.cjs");
   if (existsSync9(candidate)) return candidate;
   return null;
 }
-var add_default = defineCommand10({
+var add_default = defineCommand11({
   meta: {
     name: "add",
     description: "Add a feature to your DeepSpace app"
@@ -1723,7 +1797,7 @@ var add_default = defineCommand10({
     }
   },
   run({ args }) {
-    const appDir = resolve4(args.dir ?? ".");
+    const appDir = resolve5(args.dir ?? ".");
     const script = findScript(appDir);
     if (!script) {
       console.error("No .deepspace/scripts/add-feature.cjs found.");
@@ -1748,15 +1822,15 @@ var add_default = defineCommand10({
 });
 
 // src/cli/commands/domain.ts
-import { defineCommand as defineCommand11 } from "citty";
+import { defineCommand as defineCommand12 } from "citty";
 import { execSync as execSync4 } from "child_process";
 
 // src/cli/lib/app-context.ts
 import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
-import { join as join11, resolve as resolve5 } from "path";
+import { join as join11, resolve as resolve6 } from "path";
 import { parse as parseToml4 } from "smol-toml";
 function detectAppName(cwd = process.cwd()) {
-  const wranglerPath = join11(resolve5(cwd), "wrangler.toml");
+  const wranglerPath = join11(resolve6(cwd), "wrangler.toml");
   if (!existsSync10(wranglerPath)) return null;
   try {
     const cfg = parseToml4(readFileSync7(wranglerPath, "utf-8"));
@@ -1776,11 +1850,11 @@ function requireAppName(explicit, cwd) {
 
 // src/cli/commands/domain.ts
 var API_URL = process.env.DEEPSPACE_API_URL ?? ENVS.prod.api;
-async function api(token, path, init) {
+async function api(token2, path, init) {
   const res = await fetch(`${API_URL}${path}`, {
     ...init,
     headers: {
-      Authorization: `Bearer ${token}`,
+      Authorization: `Bearer ${token2}`,
       "Content-Type": "application/json",
       ...init?.headers ?? {}
     }
@@ -1796,6 +1870,18 @@ async function api(token, path, init) {
   }
   return JSON.parse(text);
 }
+function scrubInternal(value) {
+  if (Array.isArray(value)) return value.map(scrubInternal);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k === "costCents") continue;
+      out[k] = scrubInternal(v);
+    }
+    return out;
+  }
+  return value;
+}
 function fmtCents(cents) {
   if (cents === null || cents === void 0) return "\u2014";
   return `$${(cents / 100).toFixed(2)}`;
@@ -1809,15 +1895,15 @@ async function confirm2(message) {
     throw new Error(`${message} \u2014 pass --yes to confirm non-interactively`);
   }
   process.stdout.write(`${message} [y/N] `);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     process.stdin.setEncoding("utf-8");
     process.stdin.once("data", (data) => {
       const answer = data.toString().trim().toLowerCase();
-      resolve6(answer === "y" || answer === "yes");
+      resolve7(answer === "y" || answer === "yes");
     });
   });
 }
-var search = defineCommand11({
+var search = defineCommand12({
   meta: { name: "search", description: "Search for available domains" },
   args: {
     query: { type: "positional", description: "Domain or keyword", required: true },
@@ -1825,14 +1911,14 @@ var search = defineCommand11({
     json: { type: "boolean", description: "Emit JSON instead of a table" }
   },
   async run({ args }) {
-    const token = await ensureToken();
+    const token2 = await ensureToken();
     const limit = parseInt(args.limit ?? "10", 10) || 10;
     const result = await api(
-      token,
+      token2,
       `/api/domains/search?q=${encodeURIComponent(args.query)}&limit=${limit}`
     );
     if (args.json) {
-      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      process.stdout.write(JSON.stringify(scrubInternal(result), null, 2) + "\n");
       return;
     }
     if (result.domains.length === 0) {
@@ -1847,20 +1933,20 @@ var search = defineCommand11({
     }
   }
 });
-var buy = defineCommand11({
+var buy = defineCommand12({
   meta: { name: "buy", description: "Buy a domain and attach it to an app" },
   args: {
     domain: { type: "positional", description: "Domain to buy", required: true },
     app: { type: "string", description: "App to attach (defaults to ./wrangler.toml)" },
     yes: { type: "boolean", description: "Skip the confirmation prompt", default: false },
-    "no-open": { type: "boolean", description: "Do not open browser; print Stripe URL", default: false },
-    "no-wait": { type: "boolean", description: "Exit after creating session; do not poll until active", default: false },
+    open: { type: "boolean", description: "Open browser at Stripe URL (use --no-open to print URL only)", default: true },
+    wait: { type: "boolean", description: "Poll until provisioning completes (use --no-wait to exit after session creation)", default: true },
     json: { type: "boolean", description: "Emit JSON to stdout", default: false }
   },
   async run({ args }) {
-    const token = await ensureToken();
+    const token2 = await ensureToken();
     const appName = requireAppName(args.app);
-    const priceCheck = await api(token, "/api/domains/check", {
+    const priceCheck = await api(token2, "/api/domains/check", {
       method: "POST",
       body: JSON.stringify({ domains: [args.domain] })
     });
@@ -1881,7 +1967,7 @@ var buy = defineCommand11({
       }
     }
     const checkout = await api(
-      token,
+      token2,
       "/api/domains/checkout",
       {
         method: "POST",
@@ -1889,14 +1975,14 @@ var buy = defineCommand11({
       }
     );
     if (args.json) {
-      process.stdout.write(JSON.stringify({ ...checkout, expectedTime, registrar: result.registrar }, null, 2) + "\n");
+      process.stdout.write(JSON.stringify(scrubInternal({ ...checkout, expectedTime, registrar: result.registrar }), null, 2) + "\n");
     } else {
       console.log(`Stripe Checkout: ${checkout.url}`);
     }
-    if (!args["no-open"] && process.stdin.isTTY) {
+    if (args.open && process.stdin.isTTY) {
       openBrowser2(checkout.url);
     }
-    if (args["no-wait"]) return;
+    if (!args.wait) return;
     const timeoutMs = result.registrar === "cloudflare" ? 5 * 60 * 1e3 : 60 * 60 * 1e3;
     if (!args.json) {
       console.log(`Waiting for payment & provisioning (up to ${expectedTime}). Press Ctrl-C anytime \u2014`);
@@ -1908,7 +1994,7 @@ var buy = defineCommand11({
       await new Promise((r) => setTimeout(r, 5e3));
       try {
         const detail = await api(
-          token,
+          token2,
           `/api/domains/${checkout.purchaseId}`
         );
         if (detail.domain.status !== lastStatus) {
@@ -1917,7 +2003,7 @@ var buy = defineCommand11({
         }
         if (detail.domain.status === "active") {
           if (args.json) {
-            process.stdout.write(JSON.stringify({ ...checkout, status: "active", domain: args.domain }, null, 2) + "\n");
+            process.stdout.write(JSON.stringify(scrubInternal({ ...checkout, status: "active", domain: args.domain }), null, 2) + "\n");
           } else {
             console.log(`\u2713 ${args.domain} is live and pointing at ${appName}`);
           }
@@ -1936,16 +2022,16 @@ var buy = defineCommand11({
     process.exit(1);
   }
 });
-var list2 = defineCommand11({
+var list2 = defineCommand12({
   meta: { name: "list", description: "List your domains" },
   args: {
     json: { type: "boolean", description: "Emit JSON" }
   },
   async run({ args }) {
-    const token = await ensureToken();
-    const result = await api(token, "/api/domains");
+    const token2 = await ensureToken();
+    const result = await api(token2, "/api/domains");
     if (args.json) {
-      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      process.stdout.write(JSON.stringify(scrubInternal(result), null, 2) + "\n");
       return;
     }
     if (result.domains.length === 0) {
@@ -1960,22 +2046,22 @@ var list2 = defineCommand11({
     }
   }
 });
-var status = defineCommand11({
+var status = defineCommand12({
   meta: { name: "status", description: "Show details for one domain" },
   args: {
     domain: { type: "positional", description: "Domain", required: true },
     json: { type: "boolean" }
   },
   async run({ args }) {
-    const token = await ensureToken();
-    const all = await api(token, "/api/domains");
+    const token2 = await ensureToken();
+    const all = await api(token2, "/api/domains");
     const found = all.domains.find((d) => d.domain === args.domain);
     if (!found) {
       console.error(`No domain ${args.domain} in your account`);
       process.exit(1);
     }
     if (args.json) {
-      process.stdout.write(JSON.stringify(found, null, 2) + "\n");
+      process.stdout.write(JSON.stringify(scrubInternal(found), null, 2) + "\n");
       return;
     }
     console.log(`Domain:        ${found.domain}`);
@@ -1988,7 +2074,7 @@ var status = defineCommand11({
     console.log(`Charged:       ${fmtCents(found.chargedCents)}/yr`);
   }
 });
-var attach = defineCommand11({
+var attach = defineCommand12({
   meta: { name: "attach", description: "Re-point a domain at a different app" },
   args: {
     domain: { type: "positional", description: "Domain to re-point", required: true },
@@ -1996,16 +2082,16 @@ var attach = defineCommand11({
     json: { type: "boolean" }
   },
   async run({ args }) {
-    const token = await ensureToken();
+    const token2 = await ensureToken();
     const targetApp = requireAppName(args.app);
-    const all = await api(token, "/api/domains");
+    const all = await api(token2, "/api/domains");
     const found = all.domains.find((d) => d.domain === args.domain);
     if (!found) {
       console.error(`No domain ${args.domain} in your account`);
       process.exit(1);
     }
     const result = await api(
-      token,
+      token2,
       `/api/domains/${found.id}/reattach`,
       {
         method: "POST",
@@ -2019,7 +2105,7 @@ var attach = defineCommand11({
     console.log(`\u2713 ${args.domain} now points at ${targetApp}`);
   }
 });
-var detach = defineCommand11({
+var detach = defineCommand12({
   meta: {
     name: "detach",
     description: "Stop routing the domain (keeps the registration; auto-renew unchanged)"
@@ -2029,8 +2115,8 @@ var detach = defineCommand11({
     yes: { type: "boolean", description: "Skip the confirmation prompt" }
   },
   async run({ args }) {
-    const token = await ensureToken();
-    const all = await api(token, "/api/domains");
+    const token2 = await ensureToken();
+    const all = await api(token2, "/api/domains");
     const found = all.domains.find((d) => d.domain === args.domain);
     if (!found) {
       console.error(`No domain ${args.domain} in your account`);
@@ -2045,11 +2131,11 @@ var detach = defineCommand11({
         return;
       }
     }
-    await api(token, `/api/domains/${found.id}`, { method: "DELETE" });
+    await api(token2, `/api/domains/${found.id}`, { method: "DELETE" });
     console.log(`\u2713 ${args.domain} detached. Use \`deepspace domain attach\` to re-route, or \`renew --auto off\` to stop auto-renewal.`);
   }
 });
-var renew = defineCommand11({
+var renew = defineCommand12({
   meta: { name: "renew", description: "Toggle auto-renewal at the registrar" },
   args: {
     domain: { type: "positional", description: "Domain", required: true },
@@ -2060,15 +2146,15 @@ var renew = defineCommand11({
       console.error('--auto must be "on" or "off"');
       process.exit(1);
     }
-    const token = await ensureToken();
-    const all = await api(token, "/api/domains");
+    const token2 = await ensureToken();
+    const all = await api(token2, "/api/domains");
     const found = all.domains.find((d) => d.domain === args.domain);
     if (!found) {
       console.error(`No domain ${args.domain} in your account`);
       process.exit(1);
     }
     const enabled = args.auto === "on";
-    await api(token, `/api/domains/${found.id}/auto-renew`, {
+    await api(token2, `/api/domains/${found.id}/auto-renew`, {
       method: "POST",
       body: JSON.stringify({ autoRenew: enabled })
     });
@@ -2083,13 +2169,13 @@ function openBrowser2(url) {
   } catch {
   }
 }
-var domain_default = defineCommand11({
+var domain_default = defineCommand12({
   meta: { name: "domain", description: "Buy and manage custom domains" },
   subCommands: { search, buy, list: list2, status, attach, detach, renew }
 });
 
 // src/cli/commands/integrations.ts
-import { defineCommand as defineCommand12 } from "citty";
+import { defineCommand as defineCommand13 } from "citty";
 
 // src/cli/commands/_invoke-impl.ts
 import { readFileSync as readFileSync8 } from "fs";
@@ -2263,7 +2349,7 @@ async function runInvoke(args) {
 }
 
 // src/cli/commands/integrations.ts
-var list3 = defineCommand12({
+var list3 = defineCommand13({
   meta: {
     name: "list",
     description: "List all available integrations"
@@ -2284,7 +2370,7 @@ var list3 = defineCommand12({
     }
   }
 });
-var info = defineCommand12({
+var info = defineCommand13({
   meta: {
     name: "info",
     description: "Print schema + example body for an integration endpoint"
@@ -2310,7 +2396,7 @@ var info = defineCommand12({
     }
   }
 });
-var invoke = defineCommand12({
+var invoke = defineCommand13({
   meta: {
     name: "invoke",
     description: "Invoke a platform integration as the logged-in user"
@@ -2363,7 +2449,7 @@ var invoke = defineCommand12({
     }
   }
 });
-var integrations_default = defineCommand12({
+var integrations_default = defineCommand13({
   meta: {
     name: "integrations",
     description: "List, inspect, and invoke platform integrations"
@@ -2376,8 +2462,8 @@ var integrations_default = defineCommand12({
 });
 
 // src/cli/commands/invoke.ts
-import { defineCommand as defineCommand13 } from "citty";
-var invoke_default = defineCommand13({
+import { defineCommand as defineCommand14 } from "citty";
+var invoke_default = defineCommand14({
   meta: {
     name: "invoke",
     description: "Invoke a platform integration as the logged-in user"
@@ -2449,13 +2535,256 @@ var invoke_default = defineCommand13({
   }
 });
 
+// src/cli/commands/managed-repos.ts
+import { defineCommand as defineCommand15 } from "citty";
+var API_URL3 = process.env.DEEPSPACE_API_URL ?? ENVS.prod.api;
+var SIMPLE_APP_ID = /^[a-z0-9][a-z0-9_.:-]{0,119}$/i;
+var SIMPLE_APP_NAME = /^[a-z0-9][a-z0-9_-]{0,119}$/i;
+async function api2(token2, path, init) {
+  const res = await fetch(`${API_URL3}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${token2}`,
+      "Content-Type": "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    let msg = text;
+    try {
+      msg = JSON.parse(text).error ?? text;
+    } catch {
+    }
+    throw new Error(`API ${path} (${res.status}): ${msg}`);
+  }
+  return JSON.parse(text);
+}
+function defaultAppId(appName) {
+  return `cli-${slugId(appName)}`;
+}
+function slugId(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+}
+function assertSimple(value, pattern, label) {
+  if (!pattern.test(value)) {
+    throw new Error(`${label} must start with a letter or number and contain only simple identifier characters.`);
+  }
+}
+function printQuota(quota) {
+  console.log(`Repo quota: ${quota.activeCount} / ${quota.limit} active (${quota.remaining} remaining)`);
+}
+function printRepo(repo) {
+  console.log(`${repo.fullName}`);
+  console.log(`  ID:       ${repo.id}`);
+  console.log(`  App:      ${repo.appName}`);
+  console.log(`  App ID:   ${repo.appId}`);
+  console.log(`  URL:      ${repo.htmlUrl}`);
+  console.log(`  Clone:    ${repo.cloneUrl}`);
+}
+async function confirm3(message) {
+  if (!process.stdin.isTTY) {
+    throw new Error(`${message} \u2014 pass --yes to confirm non-interactively`);
+  }
+  process.stdout.write(`${message} [y/N] `);
+  return new Promise((resolve7) => {
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (data) => {
+      const answer = data.toString().trim().toLowerCase();
+      resolve7(answer === "y" || answer === "yes");
+    });
+  });
+}
+var list4 = defineCommand15({
+  meta: {
+    name: "list",
+    description: "List your DeepSpace-managed repos and quota"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit JSON instead of human output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const token2 = await ensureToken();
+    const result = await api2(token2, "/api/github/repos");
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    printQuota(result.quota);
+    if (result.repos.length === 0) {
+      console.log("No DeepSpace-managed repos. Create one with `deepspace managed-repos create <app-name>`.");
+      return;
+    }
+    console.log("");
+    for (const repo of result.repos) {
+      printRepo(repo);
+    }
+  }
+});
+var create2 = defineCommand15({
+  meta: {
+    name: "create",
+    description: "Create a private DeepSpace-managed GitHub repo"
+  },
+  args: {
+    appName: {
+      type: "positional",
+      description: "Working app name for this repo",
+      required: true
+    },
+    appId: {
+      type: "string",
+      description: "Stable DeepSpace repo app id (defaults to cli-<app-name>)",
+      required: false
+    },
+    nameHint: {
+      type: "string",
+      description: "Repo-name hint (defaults to app name)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Emit JSON instead of human output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const appName = String(args.appName);
+    const appId = args.appId ? String(args.appId) : defaultAppId(appName);
+    const nameHint = args.nameHint ? String(args.nameHint) : void 0;
+    try {
+      assertSimple(appName, SIMPLE_APP_NAME, "appName");
+      assertSimple(appId, SIMPLE_APP_ID, "appId");
+      if (nameHint) assertSimple(nameHint, SIMPLE_APP_NAME, "nameHint");
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    const token2 = await ensureToken();
+    const result = await api2(token2, "/api/github/repos", {
+      method: "POST",
+      body: JSON.stringify({ appName, appId, ...nameHint ? { nameHint } : {} })
+    });
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    console.log(result.alreadyExists ? "Existing DeepSpace-managed repo:" : "Created DeepSpace-managed repo:");
+    printRepo(result.repo);
+  }
+});
+var token = defineCommand15({
+  meta: {
+    name: "token",
+    description: "Mint a short-lived GitHub token for a DeepSpace-managed repo"
+  },
+  args: {
+    repoId: {
+      type: "positional",
+      description: "Repo id from `deepspace managed-repos list`",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Emit JSON instead of human output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const jwt = await ensureToken();
+    const result = await api2(
+      jwt,
+      `/api/github/repos/${encodeURIComponent(String(args.repoId))}/agent-token`,
+      { method: "POST" }
+    );
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    console.log(`Repo:      ${result.repo.fullName}`);
+    console.log(`Expires:   ${result.token.expiresAt}`);
+    console.log(`Token:     ${result.token.token}`);
+    console.log("");
+    console.log(`Clone:     git clone https://x-access-token:${encodeURIComponent(result.token.token)}@github.com/${result.repo.fullName}.git`);
+  }
+});
+var remove = defineCommand15({
+  meta: {
+    name: "delete",
+    description: "Delete a DeepSpace-managed GitHub repo"
+  },
+  args: {
+    repoId: {
+      type: "positional",
+      description: "Repo id from `deepspace managed-repos list`",
+      required: true
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip the confirmation prompt",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Emit JSON instead of human output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!args.yes) {
+      try {
+        const ok = await confirm3(
+          "Delete this DeepSpace-managed GitHub repo? This removes the GitHub repository and counts against your daily delete quota."
+        );
+        if (!ok) {
+          console.log("Cancelled.");
+          return;
+        }
+      } catch (err) {
+        console.error(err.message);
+        process.exit(1);
+      }
+    }
+    const jwt = await ensureToken();
+    const result = await api2(
+      jwt,
+      `/api/github/repos/${encodeURIComponent(String(args.repoId))}`,
+      { method: "DELETE" }
+    );
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    console.log(`Deleted ${result.repo.fullName}`);
+    console.log(
+      `Delete quota: ${result.deletionQuota.deletedCount} / ${result.deletionQuota.limit} used today (${result.deletionQuota.remaining} remaining)`
+    );
+  }
+});
+var managed_repos_default = defineCommand15({
+  meta: {
+    name: "managed-repos",
+    description: "Create and manage DeepSpace-owned GitHub repos"
+  },
+  subCommands: {
+    list: list4,
+    create: create2,
+    token,
+    delete: remove
+  }
+});
+
 // src/cli/cli.ts
 var __dirname = dirname2(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(readFileSync9(join12(__dirname, "..", "package.json"), "utf-8"));
 if (process.platform === "linux" && !process.env.SSL_CERT_FILE && existsSync11("/etc/ssl/certs/ca-certificates.crt")) {
   process.env.SSL_CERT_FILE = "/etc/ssl/certs/ca-certificates.crt";
 }
-var create2 = defineCommand14({
+var create3 = defineCommand16({
   meta: {
     name: "create",
     description: "Create a new DeepSpace app"
@@ -2474,23 +2803,25 @@ var create2 = defineCommand14({
     execSync5(`npm create deepspace@latest${name}`, { stdio: "inherit" });
   }
 });
-var main = defineCommand14({
+var main = defineCommand16({
   meta: {
     name: "deepspace",
     version: pkg.version,
     description: "DeepSpace SDK CLI"
   },
   subCommands: {
-    create: create2,
+    create: create3,
     login: login_default,
     logout: logout_default,
     whoami: whoami_default,
     dev: dev_default,
     kill: kill_default,
     test: test_default,
+    screenshot: screenshot_default,
     "test-accounts": test_accounts_default,
     add: add_default,
     integrations: integrations_default,
+    "managed-repos": managed_repos_default,
     invoke: invoke_default,
     deploy: deploy_default,
     undeploy: undeploy_default,