@animaapp/cli 0.3.11 → 0.4.1

package/README.md

@@ -95,10 +95,13 @@ npx @animaapp/cli create -t p2c -p "E-commerce product page with cart"
 npx @animaapp/cli create -t l2c -u https://linear.app
 npx @animaapp/cli create -t f2c --file-key <key> --nodes 42:15
 
-# 3. Or bring YOUR OWN code: blank playground -> git push -> publish
-npx @animaapp/cli create -t blank --name "My project"
-npx @animaapp/cli get-git-token <sessionId>   # then: git clone <url>, add code, git push
+# 3. Or bring YOUR OWN code: import it in one step -> publish
+npx @animaapp/cli create -t import --from ./my-project
 npx @animaapp/cli publish <sessionId>
+
+# ...or start empty and push over git
+npx @animaapp/cli create -t empty --framework react --name "My project"
+npx @animaapp/cli get-git-token <sessionId>   # then: git clone <url>, add code, git push
 ```
 
 ---
@@ -142,21 +145,25 @@ by `mcp-config` and `--print-mcp-config`.
 ### `create` — a playground for your code, or AI-generated
 
 ```bash
-npx @animaapp/cli create -t blank --name "My project"   # EMPTY playground for your own code (instant)
+npx @animaapp/cli create -t import --from ./my-project              # import YOUR code (instant)
+npx @animaapp/cli create -t empty --framework react --name "My project"  # empty repo you push to (instant)
 npx @animaapp/cli create -t p2c -p "Analytics dashboard with a sidebar"
 npx @animaapp/cli create -t l2c -u https://stripe.com
 npx @animaapp/cli create -t f2c --file-key <key> --nodes 42:15
 ```
 
-`-t blank` is the upload path: it creates an empty playground and returns a
-`sessionId` — follow with `get-git-token <sessionId>`, `git clone`, add your
-code, and `git push`; then `publish <sessionId>` for a live URL. The other
-types are AI generation (3–7 min).
+`-t import` is the one-step upload path: your folder (or .zip) becomes the
+playground's first commit — small text-only projects are sent inline, larger
+or binary ones are zipped and uploaded via a presigned URL automatically.
+`-t empty` creates an empty repository instead: follow with `git clone` of the
+returned URL, add your code, and `git push`. Then `publish <sessionId>` for a
+live URL. The other types are AI generation (3–7 min).
 
 | Option | Values | Default |
 |--------|--------|---------|
-| `-t, --type` | `blank` (own code), `p2c` (prompt), `l2c` (URL), `f2c` (Figma) | _required_ |
-| `--name` | project name | _(blank)_ |
+| `-t, --type` | `import` (your code, with `--from`), `empty` (repo to push to), `p2c` (prompt), `l2c` (URL), `f2c` (Figma) | _required_ |
+| `--name` | project name | _(empty/import)_ |
+| `--from` | folder or .zip to import | _(import)_ |
 | `-p, --prompt` | free text | _(p2c)_ |
 | `-u, --url` | website URL | _(l2c)_ |
 | `--file-key` | Figma file key or URL | _(f2c)_ |
@@ -188,7 +195,12 @@ npx @animaapp/cli codegen --file-key <key-or-url> --nodes 42:15 -o ./components
 | `--language` | `typescript`, `javascript` | `typescript` (react) |
 | `--ui-library` | `shadcn`, `mui`, `antd`, `clean_react` | _(none)_ |
 
-### `publish` — deploy a session (1–3 min)
+### `publish` — deploy a session to a public URL (1–3 min)
+
+Publishing makes the playground **public to the world**. Sharing usually
+doesn't need it — the playground is already visible at its `playgroundUrl`.
+**Agents:** only publish when the human explicitly asked for a public site;
+otherwise share the playground URL and offer publishing as a follow-up.
 
 ```bash
 npx @animaapp/cli publish <sessionId>
@@ -201,6 +213,26 @@ npx @animaapp/cli publish <sessionId> --mode designSystem --package-name my-ds
 | `--package-name` | npm package name | _(designSystem)_ |
 | `--package-version` | npm package version | _(designSystem)_ |
 
+### `unpublish` — take a published playground offline
+
+```bash
+npx @animaapp/cli unpublish <sessionId>
+```
+
+The inverse of `publish`: clears the live URL so the deployed site stops being
+reachable. The playground, its code, and its content are untouched; publishing
+again reuses the same subdomain.
+
+### `update` — rename or change visibility (metadata only)
+
+```bash
+npx @animaapp/cli update <sessionId> --name "New name"
+npx @animaapp/cli update <sessionId> --privacy public    # anyone with the link
+npx @animaapp/cli update <sessionId> --privacy private   # team only
+```
+
+Never touches code or content — that's the git flow (`get-git-token`).
+
 ### `get-git-token` — read/edit a playground's code over git
 
 ```bash

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/create.ts
 import { Command } from "commander";
+import chalk2 from "chalk";
 
 // src/auth/store.ts
 import fs from "fs";
@@ -309,6 +310,7 @@ var ProgressReporter = class {
   start(message) {
     this.#startTime = Date.now();
     if (this.#mode === "pretty") {
+      this.#spinner?.stop();
       this.#spinner = ora(message).start();
     } else if (this.#verbose) {
       process.stderr.write(JSON.stringify({ status: "started", message }) + "\n");
@@ -428,6 +430,90 @@ function normalizeNodeId(nodeId) {
   return nodeId.replace(/-/g, ":");
 }
 
+// src/utils/projectSource.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative, extname } from "path";
+import AdmZip from "adm-zip";
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "out", "coverage", ".turbo", ".cache"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp4",
+  ".webm",
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".pdf",
+  ".wasm"
+]);
+var MAX_INLINE_FILES = 1e3;
+var MAX_INLINE_BYTES = 10 * 1024 * 1024;
+function walk(root, dir, out) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!SKIPPED_DIRS.has(entry.name)) walk(root, join(dir, entry.name), out);
+    } else if (entry.isFile()) {
+      out.push(relative(root, join(dir, entry.name)));
+    }
+  }
+}
+function zipFolder(root) {
+  const zip = new AdmZip();
+  zip.addLocalFolder(root, "", (entryPath) => {
+    const segments = entryPath.split(/[\\/]/);
+    return !segments.some((segment) => SKIPPED_DIRS.has(segment));
+  });
+  return zip.toBuffer();
+}
+function isProbablyBinary(path5, buffer) {
+  if (BINARY_EXTENSIONS.has(extname(path5).toLowerCase())) return true;
+  return buffer.includes(0);
+}
+function collectProjectSource(fromPath) {
+  const stats = statSync(fromPath);
+  if (stats.isFile()) {
+    if (extname(fromPath).toLowerCase() !== ".zip") {
+      throw new Error(`--from must be a folder or a .zip file, got: ${fromPath}`);
+    }
+    return { kind: "zip", buffer: readFileSync(fromPath), reason: "zip file given" };
+  }
+  const paths = [];
+  walk(fromPath, fromPath, paths);
+  if (paths.length === 0) {
+    throw new Error(`--from folder is empty: ${fromPath}`);
+  }
+  if (paths.length > MAX_INLINE_FILES) {
+    return { kind: "zip", buffer: zipFolder(fromPath), reason: `${paths.length} files exceeds the inline limit` };
+  }
+  const files = {};
+  let totalBytes = 0;
+  for (const path5 of paths) {
+    const buffer = readFileSync(join(fromPath, path5));
+    if (isProbablyBinary(path5, buffer)) {
+      return { kind: "zip", buffer: zipFolder(fromPath), reason: `binary file present (${path5})` };
+    }
+    totalBytes += buffer.length;
+    if (totalBytes > MAX_INLINE_BYTES) {
+      return { kind: "zip", buffer: zipFolder(fromPath), reason: "project exceeds the inline size limit" };
+    }
+    files[path5.split("\\").join("/")] = buffer.toString("utf8");
+  }
+  return { kind: "files", files, fileCount: paths.length };
+}
+
 // src/config/store.ts
 import fs3 from "fs";
 import path3 from "path";
@@ -485,7 +571,15 @@ function resolveApiUrl(flagValue) {
 
 // src/commands/create.ts
 var PLAYGROUND_BASE = "https://dev.animaapp.com/chat";
-var createCommand = new Command("create").description("Create a playground: AI-generated (p2c/l2c/f2c, 3-7 min) or blank for your own code (instant)").requiredOption("-t, --type <type>", "p2c, l2c, f2c, or blank (empty playground \u2014 push your own code with get-git-token)").option("-p, --prompt <prompt>", "Text prompt (p2c)").option("-u, --url <url>", "Website URL (l2c)").option("--file-key <key>", "Figma file key or URL (f2c)").option("--nodes <nodes>", "Figma node IDs, comma-separated (f2c)").option("--figma-token <token>", "Figma personal access token (f2c)").option("--framework <fw>", "html | react \u2014 the only supported frameworks (default: html)").option("--styling <style>", "tailwind | css | plain_css | css_modules | inline_styles", "tailwind").option("--language <lang>", "typescript | javascript").option("--ui-library <lib>", "mui | antd | shadcn | clean_react").option("--guidelines <text>", "Additional constraints (p2c only)").option("--name <name>", "Project name (blank only)").option("--json", "Output as JSON").option("--timeout <ms>", "Timeout in milliseconds", "600000").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL (overrides config / ANIMA_API_URL)").option("--log-file <path>", "Append a JSON debug log of each step to this file").action(async (opts) => {
+var createCommand = new Command("create").description(
+  "Create a playground: AI-generated (p2c/l2c/f2c, 3-7 min), empty for code you'll push (instant), or import your existing code (instant)"
+).requiredOption(
+  "-t, --type <type>",
+  "p2c, l2c, f2c, empty (empty repo you push to), or import (create FROM your code \u2014 use --from)"
+).option("-p, --prompt <prompt>", "Text prompt (p2c)").option("-u, --url <url>", "Website URL (l2c)").option("--file-key <key>", "Figma file key or URL (f2c)").option("--nodes <nodes>", "Figma node IDs, comma-separated (f2c)").option("--figma-token <token>", "Figma personal access token (f2c)").option(
+  "--framework <fw>",
+  "html | react \u2014 the only supported frameworks. REQUIRED for empty (declare react if you will push React code); detected from package.json for import"
+).option("--styling <style>", "tailwind | css | plain_css | css_modules | inline_styles", "tailwind").option("--language <lang>", "typescript | javascript").option("--ui-library <lib>", "mui | antd | shadcn | clean_react").option("--guidelines <text>", "Additional constraints (p2c only)").option("--name <name>", "Project name (empty/import only)").option("--from <path>", "Folder or .zip with your project (import only) \u2014 becomes the first commit").option("--json", "Output as JSON").option("--timeout <ms>", "Timeout in milliseconds", "600000").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL (overrides config / ANIMA_API_URL)").option("--log-file <path>", "Append a JSON debug log of each step to this file").action(async (opts) => {
   const mode = detectOutputMode(opts);
   initLogger(opts.logFile);
   const progress = new ProgressReporter(mode, opts.verbose);
@@ -495,40 +589,90 @@ var createCommand = new Command("create").description("Create a playground: AI-g
     const auth = resolveAuth();
     const figmaToken = type === "f2c" ? resolveFigmaToken(opts, auth.figmaToken) : void 0;
     const args = buildCreateArgs(type, opts);
-    progress.start(type === "blank" ? "Creating blank playground..." : `Creating ${type.toUpperCase()} playground...`);
+    const mcpConfig = { apiBaseUrl: resolveApiUrl(opts.apiUrl), token: auth.token, teamId: auth.teamId, figmaToken };
+    if (type === "import") {
+      progress.start("Collecting project files...");
+      const source = collectProjectSource(opts.from);
+      if (source.kind === "files") {
+        args.files = source.files;
+      } else {
+        progress.update(`Uploading project zip (${source.reason})...`);
+        const grant = await withMcp(
+          mcpConfig,
+          (client) => client.callTool("playground-get_zip_upload_url", {})
+        );
+        if (!grant.success || !grant.uploadUrl || !grant.zipUploadId) {
+          const message = grant.reason || grant.error || "Could not get a zip upload URL";
+          throw apiError(grant.nextSteps ? `${message}
+${grant.nextSteps}` : message, grant);
+        }
+        const putResponse = await fetch(grant.uploadUrl, {
+          method: "PUT",
+          body: new Uint8Array(source.buffer)
+        });
+        if (!putResponse.ok) {
+          throw apiError(`Zip upload failed: HTTP ${putResponse.status}`, { status: putResponse.status });
+        }
+        args.zipUploadId = grant.zipUploadId;
+      }
+    }
+    progress.start(
+      type === "empty" ? "Creating empty playground..." : type === "import" ? "Importing your project..." : `Creating ${type.toUpperCase()} playground...`
+    );
     const result = await withMcp(
-      { apiBaseUrl: resolveApiUrl(opts.apiUrl), token: auth.token, teamId: auth.teamId, figmaToken },
+      mcpConfig,
       (client) => client.callTool("playground-create", args, {
         timeoutMs: parseInt(opts.timeout, 10),
         onProgress: (p) => progress.update(p.message ?? `Generating (${Math.round(p.progress)}%)...`)
       })
     );
     if (!result.success || !result.sessionId) {
-      throw apiError(result.reason || result.error || "Generation failed", result);
+      const message = result.reason || result.error || "Generation failed";
+      throw apiError(result.nextSteps ? `${message}
+${result.nextSteps}` : message, result);
     }
     const playgroundUrl = result.playgroundUrl || `${PLAYGROUND_BASE}/${result.sessionId}`;
     progress.succeed("Playground created!");
     if (mode === "pretty") {
       printSessionResult({ sessionId: result.sessionId, playgroundUrl });
       if (result.gitRemoteUrl) {
-        console.log(`  git clone ${result.gitRemoteUrl}`);
+        console.log(`  ${chalk2.cyan(`git clone ${result.gitRemoteUrl}`)}`);
         console.log();
-        console.log(
-          `  Add your code, commit, and git push \u2014 the playground goes live. The URL embeds a token${result.expiresAt ? ` (expires ${result.expiresAt})` : ""}; when it expires, run anima get-git-token ${result.sessionId} and git remote set-url origin <new url>.`
-        );
+        console.log("  Commit and push to update the live playground.");
+        if (result.expiresAt) {
+          console.log(
+            `  The URL embeds a token that expires at ${result.expiresAt} and cannot be renewed;
+  run ${chalk2.cyan(`anima get-git-token ${result.sessionId}`)} and ${chalk2.cyan("git remote set-url origin <new url>")} to keep pushing.`
+          );
+        }
+        console.log("  Treat the URL as a secret \u2014 it grants access to this playground.");
         console.log();
-      } else if (type === "blank") {
+      } else if (type === "empty") {
         console.log(
           `  Next: anima get-git-token ${result.sessionId} \u2014 then git clone, add your code, and git push.`
         );
         console.log();
       }
+      if (type === "import" && result.fileCount !== void 0) {
+        console.log(`  ${result.fileCount} files committed (framework: ${result.framework ?? "detected server-side"}).`);
+        if (result.skippedFiles?.length) {
+          console.log(`  Skipped (blocked/hidden): ${result.skippedFiles.join(", ")}`);
+        }
+        if (result.notes) {
+          console.log(`  Note: ${result.notes}`);
+        }
+        console.log();
+      }
     } else {
       outputResult(mode, {
         success: true,
         sessionId: result.sessionId,
         playgroundUrl,
         ...result.gitRemoteUrl ? { gitRemoteUrl: result.gitRemoteUrl, access: result.access, expiresAt: result.expiresAt } : {},
+        ...result.framework ? { framework: result.framework } : {},
+        ...result.fileCount !== void 0 ? { fileCount: result.fileCount } : {},
+        ...result.skippedFiles?.length ? { skippedFiles: result.skippedFiles } : {},
+        ...result.notes ? { notes: result.notes } : {},
         ...result.nextSteps ? { nextSteps: result.nextSteps } : {}
       });
     }
@@ -546,8 +690,8 @@ var createCommand = new Command("create").description("Create a playground: AI-g
   }
 });
 function validateCreateOptions(type, opts) {
-  if (!["p2c", "l2c", "f2c", "blank"].includes(type)) {
-    throw validationError(`Invalid type "${type}". Must be p2c, l2c, f2c, or blank.`);
+  if (!["p2c", "l2c", "f2c", "empty", "import"].includes(type)) {
+    throw validationError(`Invalid type "${type}". Must be p2c, l2c, f2c, empty, or import.`);
   }
   if (type === "p2c" && !opts.prompt) {
     throw validationError("--prompt is required for p2c type");
@@ -558,6 +702,17 @@ function validateCreateOptions(type, opts) {
   if (type === "f2c" && !opts.fileKey) {
     throw validationError("--file-key is required for f2c type");
   }
+  if (type === "empty" && !opts.framework) {
+    throw validationError(
+      "--framework is required for type empty \u2014 html for plain HTML/CSS/JS, react for React (declare react if you will push React code)"
+    );
+  }
+  if (type === "import" && !opts.from) {
+    throw validationError("--from <folder|zip> is required for type import \u2014 the path to the project to import");
+  }
+  if (type !== "import" && opts.from) {
+    throw validationError("--from is only valid with -t import");
+  }
 }
 function resolveFigmaToken(opts, stored) {
   const figmaToken = opts.figmaToken || process.env.FIGMA_TOKEN || stored;
@@ -569,10 +724,14 @@ function resolveFigmaToken(opts, stored) {
   return figmaToken;
 }
 function buildCreateArgs(type, opts) {
-  const framework = opts.framework ?? "html";
-  if (type === "blank") {
-    return { type, framework, ...opts.name ? { name: opts.name } : {} };
+  if (type === "empty" || type === "import") {
+    return {
+      type,
+      ...opts.framework ? { framework: opts.framework } : {},
+      ...opts.name ? { name: opts.name } : {}
+    };
   }
+  const framework = opts.framework ?? "html";
   const language = opts.language ?? (framework === "react" ? "typescript" : void 0);
   const args = {
     type,
@@ -778,7 +937,7 @@ var codegenCommand = new Command3("codegen").description("Convert Figma design t
 
 // src/commands/getGitToken.ts
 import { Command as Command4 } from "commander";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // src/utils/playgroundUrl.ts
 function parsePlaygroundUrl(input) {
@@ -847,7 +1006,7 @@ var getGitTokenCommand = new Command4("get-git-token").description("Mint a short
     progress.succeed(`Git access granted (${grant.access === "rw" ? "read-write" : "read-only"})`);
     if (mode === "pretty") {
       console.log();
-      console.log(`  ${chalk2.cyan(`git clone ${grant.gitRemoteUrl}`)}`);
+      console.log(`  ${chalk3.cyan(`git clone ${grant.gitRemoteUrl}`)}`);
       console.log();
       if (grant.access === "rw") {
         console.log("  Commit and push to update the live playground.");
@@ -857,7 +1016,7 @@ var getGitTokenCommand = new Command4("get-git-token").description("Mint a short
       if (grant.expiresAt) {
         console.log(
           `  The URL embeds a token that expires at ${grant.expiresAt} and cannot be renewed;
-  re-run this command and ${chalk2.cyan("git remote set-url origin <new url>")} to keep pushing.`
+  re-run this command and ${chalk3.cyan("git remote set-url origin <new url>")} to keep pushing.`
         );
       }
       console.log("  Treat the URL as a secret \u2014 it grants access to this playground.");
@@ -890,7 +1049,7 @@ import { Command as Command6 } from "commander";
 
 // src/commands/login.ts
 import { Command as Command5 } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import open from "open";
 
 // src/auth/device.ts
@@ -1123,9 +1282,9 @@ var loginCommand = new Command5("login").description("Log in via the device flow
           console.log();
           printInfo("To connect, open the verification page and enter this code:");
           console.log();
-          console.log(`    ${chalk3.cyan.underline(info.verificationUri)}`);
+          console.log(`    ${chalk4.cyan.underline(info.verificationUri)}`);
           console.log();
-          console.log(`    ${chalk3.bold.white(info.userCode)}`);
+          console.log(`    ${chalk4.bold.white(info.userCode)}`);
           console.log();
           printInfo(`Waiting for approval\u2026 (code expires in ${Math.round(info.expiresInSeconds / 60)} minutes)`);
         } else {
@@ -1233,7 +1392,7 @@ var mcpConfigCommand = new Command6("mcp-config").description("Print an MCP serv
 
 // src/commands/auth.ts
 import { Command as Command7 } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var DEFAULT_API_URL2 = "https://public-api.animaapp.com";
 var authCommand = new Command7("auth").description("Manage authentication").option("--token <token>", "Store Anima API token").option("--figma-token <token>", "Store Figma personal access token").option("--team-id <teamId>", "Team ID to associate with token").option("--status", "Show current auth status").option("--logout", "Clear stored credentials (alias for `anima logout`)").option("--json", "Output as JSON").option("--api-url <url>", "API base URL", DEFAULT_API_URL2).action(async (opts) => {
   const mode = detectOutputMode(opts);
@@ -1322,12 +1481,12 @@ var authCommand = new Command7("auth").description("Manage authentication").opti
     if (mode === "pretty") {
       console.log();
       printInfo("Auth commands:");
-      console.log(`  ${chalk4.cyan("anima login")}                    Log in (device flow \u2014 approve on any browser)`);
-      console.log(`  ${chalk4.cyan("anima logout")}                   Clear all credentials`);
-      console.log(`  ${chalk4.cyan("anima auth --status")}            Check auth status`);
-      console.log(`  ${chalk4.cyan("anima auth --figma-token <T>")}   Save Figma token (needed for codegen/f2c)`);
+      console.log(`  ${chalk5.cyan("anima login")}                    Log in (device flow \u2014 approve on any browser)`);
+      console.log(`  ${chalk5.cyan("anima logout")}                   Clear all credentials`);
+      console.log(`  ${chalk5.cyan("anima auth --status")}            Check auth status`);
+      console.log(`  ${chalk5.cyan("anima auth --figma-token <T>")}   Save Figma token (needed for codegen/f2c)`);
       console.log();
-      console.log(`  Figma token: ${chalk4.cyan.underline("https://www.figma.com")} > Settings > Personal access tokens`);
+      console.log(`  Figma token: ${chalk5.cyan.underline("https://www.figma.com")} > Settings > Personal access tokens`);
       console.log();
     } else {
       outputResult(mode, {
@@ -1365,9 +1524,91 @@ var logoutCommand = new Command8("logout").description("Clear all stored credent
   }
 });
 
-// src/commands/config.ts
+// src/commands/unpublish.ts
 import { Command as Command9 } from "commander";
-var configCommand = new Command9("config").description(
+var unpublishCommand = new Command9("unpublish").description("Take a published playground offline (clears its live URL; code and playground stay intact)").argument("<sessionId>", "Session ID of the published playground").option("--json", "Output as JSON").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL (overrides config / ANIMA_API_URL)").option("--log-file <path>", "Append a JSON debug log of each step to this file").action(async (sessionId, opts) => {
+  const mode = detectOutputMode(opts);
+  initLogger(opts.logFile);
+  const progress = new ProgressReporter(mode, opts.verbose);
+  try {
+    const auth = resolveAuth();
+    progress.start("Unpublishing...");
+    const result = await withMcp(
+      { apiBaseUrl: resolveApiUrl(opts.apiUrl), token: auth.token, teamId: auth.teamId },
+      (client) => client.callTool("playground-unpublish", { sessionId })
+    );
+    if (!result.success) {
+      throw apiError(result.reason || result.error || "Unpublish failed", result);
+    }
+    progress.succeed("Unpublished");
+    if (mode === "pretty") {
+      printSuccess(result.message || `Playground ${sessionId} is no longer publicly reachable.`);
+    } else {
+      outputResult(mode, { success: true, sessionId, ...result.message ? { message: result.message } : {} });
+    }
+  } catch (err) {
+    progress.fail("Failed");
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        printError(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command10 } from "commander";
+var updateCommand = new Command10("update").description("Update a playground's metadata: display name and/or visibility (never touches code)").argument("<sessionId>", "Session ID of the playground").option("--name <name>", "New display name").option("--privacy <privacy>", "public (anyone with the link) | private (team only)").option("--json", "Output as JSON").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL (overrides config / ANIMA_API_URL)").option("--log-file <path>", "Append a JSON debug log of each step to this file").action(async (sessionId, opts) => {
+  const mode = detectOutputMode(opts);
+  initLogger(opts.logFile);
+  const progress = new ProgressReporter(mode, opts.verbose);
+  try {
+    if (!opts.name && !opts.privacy) {
+      throw validationError("Nothing to update \u2014 pass --name and/or --privacy");
+    }
+    if (opts.privacy && !["public", "private"].includes(opts.privacy)) {
+      throw validationError(`Invalid privacy "${opts.privacy}". Must be public or private.`);
+    }
+    const auth = resolveAuth();
+    progress.start("Updating...");
+    const result = await withMcp(
+      { apiBaseUrl: resolveApiUrl(opts.apiUrl), token: auth.token, teamId: auth.teamId },
+      (client) => client.callTool("playground-metadata-update", {
+        sessionId,
+        ...opts.name ? { name: opts.name } : {},
+        ...opts.privacy ? { privacy: opts.privacy } : {}
+      })
+    );
+    if (!result.success) {
+      throw apiError(result.reason || result.error || "Update failed", result);
+    }
+    progress.succeed("Updated");
+    if (mode === "pretty") {
+      printSuccess(result.message || `Playground ${sessionId} updated.`);
+    } else {
+      outputResult(mode, { success: true, sessionId, ...result.message ? { message: result.message } : {} });
+    }
+  } catch (err) {
+    progress.fail("Failed");
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        printError(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command11 } from "commander";
+var configCommand = new Command11("config").description(
   `Store CLI preferences (keys: ${configKeys().join(", ")})`
 );
 configCommand.command("set <key> <value>").description("Set a config value").option("--json", "Output as JSON").action((key, value, opts) => {
@@ -1433,40 +1674,52 @@ function assertUrl(value) {
 }
 
 // src/index.ts
-var program = new Command10().name("anima").description(
-  `Anima CLI - Generate production-ready apps from prompts, URLs, or Figma designs.
+var program = new Command12().name("anima").description(
+  `Anima CLI \u2014 host, edit, and publish your work on Anima. Every playground is a
+real git repository; each command runs an Anima tool for you.
+
+THE MAIN FLOW (build something and put it on Anima):
+  1. npx @animaapp/cli login                                   # once; a human approves
+  2. npx @animaapp/cli create -t import --from ./my-project    # your code \u2192 a live playground
+     (or: create -t empty --framework html \u2014 an empty repo you push to)
+  3. The response includes a rw gitRemoteUrl \u2014 git clone, edit, commit, push:
+     every push updates the live playground.
+  4. Share the playgroundUrl with your human. That IS sharing \u2014 the playground
+     is visible at its URL. Do NOT run publish unless the human explicitly
+     asked for a public site; offer it as a follow-up question instead.
 
 AUTHENTICATION:
-  Run: npx @animaapp/cli login
-  Approve in a browser on any device \u2014 the CLI receives a scoped agent token
-  (stored in ~/.config/anima/). CI/automation can set ANIMA_API_TOKEN instead.
+  npx @animaapp/cli login            # device flow \u2014 a human approves on any device
+  npx @animaapp/cli login --invite <url>   # redeem a pre-approved invite link (no approval step)
+  Credentials live in ~/.config/anima/; logout removes everything.
 
 TIMING (important for AI agents):
-  create        \u2192 3-7 minutes (keep the default 600000ms timeout)
-  publish       \u2192 1-3 minutes
-  codegen       \u2192 2-5 minutes
-  get-git-token \u2192 seconds
-  The --timeout default is 600000ms (10 min). Do NOT reduce it.
+  create -t empty|import \u2192 seconds
+  create -t p2c|l2c|f2c  \u2192 3-7 minutes AI generation (keep the default 600000ms timeout)
+  publish/unpublish      \u2192 1-3 minutes
+  get-git-token / update \u2192 seconds
 
 COMMANDS:
-  login          Log in via the device flow (no browser needed on this machine)
-  logout         Clear all stored credentials from this machine
+  login          Connect (device flow, or --invite to redeem an invite link)
+  logout         Full local reset \u2014 clears credentials and CLI config
+  create         Make a playground: import your code, empty repo, or AI-generated (p2c/l2c/f2c)
+  get-git-token  Fresh git access to an existing playground (or after token expiry)
+  update         Rename a playground or set visibility public/private (metadata only)
+  publish        Deploy to a public live URL \u2014 ONLY when the human asked for it
+  unpublish      Take a published playground offline (inverse of publish)
   mcp-config     Print an MCP server config from stored credentials (no new login)
-  create         Create app from prompt, URL, or Figma design
-  publish        Deploy playground to live URL or npm package
-  codegen        Convert Figma design to code files (no playground)
-  get-git-token  Mint a git remote URL for a playground; clone/edit/push with git
+  codegen        Convert Figma design to local code files (no playground)
   config         Store CLI preferences (e.g. a default API URL)
   auth           Inspect or manage credentials (status / figma token)
 
-EXAMPLES:
-  npx @animaapp/cli login
-  npx @animaapp/cli create -t p2c -p "SaaS dashboard with sidebar and analytics"
-  npx @animaapp/cli create -t l2c -u https://stripe.com
-  npx @animaapp/cli create -t f2c --file-key abc --nodes 42:15
-  npx @animaapp/cli publish abc123xyz
-  npx @animaapp/cli codegen --file-key abc --nodes 42:15 -o ./components
-  npx @animaapp/cli get-git-token https://dev.animaapp.com/chat/abc123xyz
+EXAMPLES (headless flow):
+  npx @animaapp/cli login --invite https://public-api.animaapp.com/invite/<code>.md
+  npx @animaapp/cli create -t import --from ./my-project
+  npx @animaapp/cli create -t empty --framework react --name "My app"
+  npx @animaapp/cli get-git-token <sessionId>
+  npx @animaapp/cli update <sessionId> --privacy public
+  npx @animaapp/cli publish <sessionId>        # only on explicit request
+  npx @animaapp/cli unpublish <sessionId>
 
 OUTPUT: JSON to stdout when piped (for AI tools), pretty text in terminals.
   Progress is streamed to stderr via --verbose when in JSON mode.`
@@ -1475,6 +1728,8 @@ program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(createCommand);
 program.addCommand(publishCommand);
+program.addCommand(unpublishCommand);
+program.addCommand(updateCommand);
 program.addCommand(codegenCommand);
 program.addCommand(getGitTokenCommand);
 program.addCommand(mcpConfigCommand);