showpane 0.4.1 → 0.4.2

package/dist/index.js

@@ -1,16 +1,29 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { execSync, spawn } from "child_process";
+import { randomBytes, createHash } from "crypto";
 import { createInterface } from "readline";
-import { execSync, spawn, exec } from "child_process";
-import fs from "fs";
-import { randomBytes } from "crypto";
 import { createServer } from "net";
-import path from "path";
+import fs from "fs";
 import os from "os";
+import path from "path";
 import { fileURLToPath } from "url";
-var { chmodSync, mkdirSync, readFileSync, writeFileSync } = fs;
-var { resolve, dirname, join } = path;
+var {
+  chmodSync,
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  readlinkSync,
+  rmSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync
+} = fs;
+var { dirname, join, resolve } = path;
 var { homedir } = os;
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
@@ -19,14 +32,34 @@ var GREEN = "\x1B[32m";
 var BLUE = "\x1B[34m";
 var WHITE = "\x1B[37m";
 var RED = "\x1B[31m";
-function green(msg) {
-  console.log(`  ${GREEN}\u2713${RESET} ${msg}`);
+var API_BASE = "https://app.showpane.com";
+var SHOWPANE_HOME = join(homedir(), ".showpane");
+var TOOLCHAIN_DIR = join(SHOWPANE_HOME, "toolchains");
+var CURRENT_TOOLCHAIN_LINK = join(SHOWPANE_HOME, "current");
+var CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
+var SHOWPANE_SHARED_SKILL = "showpane-shared";
+var METADATA_DIRNAME = ".showpane";
+var PROJECT_METADATA_FILE = "project.json";
+var MANAGED_FILES_FILE = "managed-files.json";
+var StepCommandError = class extends Error {
+  output;
+  constructor(message, output = "") {
+    super(message);
+    this.name = "StepCommandError";
+    this.output = output;
+  }
+};
+function green(message) {
+  console.log(`  ${GREEN}\u2713${RESET} ${message}`);
 }
-function blue(msg) {
-  console.log(`  ${BLUE}\u2192${RESET} ${msg}`);
+function blue(message) {
+  console.log(`  ${BLUE}\u2192${RESET} ${message}`);
 }
-function error(msg) {
-  console.error(`  ${RED}\u2717${RESET} ${msg}`);
+function error(message) {
+  console.error(`  ${RED}\u2717${RESET} ${message}`);
+}
+function printCreateUsage() {
+  console.log("Usage: showpane [--yes --name <company>] [--no-open] [--verbose]");
 }
 function printBanner() {
   const banner = `
@@ -36,7 +69,7 @@ ${BOLD}${WHITE}  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2
   \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D
   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D${RESET}
-${DIM}  Client portals that close deals.${RESET}
+${DIM}  AI-powered client portals.${RESET}
 `;
   console.log(banner);
 }
@@ -45,183 +78,842 @@ function ask(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolveAnswer) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolveAnswer(answer.trim());
     });
   });
 }
+function parseCreateArgs(args) {
+  const options = {
+    noOpen: false,
+    verbose: false,
+    yes: false
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--yes") {
+      options.yes = true;
+      continue;
+    }
+    if (arg === "--no-open") {
+      options.noOpen = true;
+      continue;
+    }
+    if (arg === "--verbose") {
+      options.verbose = true;
+      continue;
+    }
+    if (arg === "--name") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("Missing value for --name.");
+      }
+      options.companyName = value.trim();
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (options.yes && !options.companyName) {
+    throw new Error("`--yes` requires `--name <company>` for a non-interactive install.");
+  }
+  return options;
+}
 function toSlug(name) {
   return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
+function run(command2, cwd, env) {
+  execSync(command2, {
+    cwd,
+    stdio: "inherit",
+    env: env ? { ...process.env, ...env } : process.env
+  });
+}
+function capture(command2, cwd, env) {
+  return execSync(command2, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    encoding: "utf8"
+  }).trim();
+}
+function getInstallerEnv(extraEnv) {
+  return {
+    ...process.env,
+    npm_config_audit: "false",
+    npm_config_fund: "false",
+    npm_config_loglevel: "error",
+    npm_config_progress: "false",
+    npm_config_update_notifier: "false",
+    PRISMA_HIDE_UPDATE_MESSAGE: "1",
+    ...extraEnv
+  };
+}
+function compareVersions(left, right) {
+  const leftParts = left.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const rightParts = right.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const maxLength = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftValue = leftParts[index] ?? 0;
+    const rightValue = rightParts[index] ?? 0;
+    if (leftValue === rightValue) continue;
+    return leftValue > rightValue ? 1 : -1;
+  }
+  return 0;
+}
+function maybePrintShowpaneUpdateMessage(currentVersion) {
+  try {
+    const latestVersion = capture("npm view showpane version", void 0, {
+      npm_config_update_notifier: "false",
+      npm_config_fund: "false",
+      npm_config_audit: "false"
+    });
+    if (!latestVersion || compareVersions(latestVersion, currentVersion) <= 0) {
+      return;
+    }
+    console.log();
+    blue(`Update available: showpane ${latestVersion} is out`);
+    console.log(`  ${DIM}Run: npx showpane@latest sync${RESET}`);
+    console.log();
+  } catch {
+  }
+}
+function getCommandOutput(errorLike) {
+  const error2 = errorLike;
+  const stdout = typeof error2?.stdout === "string" ? error2.stdout : error2?.stdout?.toString() ?? "";
+  const stderr = typeof error2?.stderr === "string" ? error2.stderr : error2?.stderr?.toString() ?? "";
+  return [stdout, stderr].filter(Boolean).join("\n").trim();
+}
+function runQuiet(command2, cwd, env) {
+  try {
+    execSync(command2, {
+      cwd,
+      env: env ? { ...process.env, ...env } : process.env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 20 * 1024 * 1024
+    });
+  } catch (errorLike) {
+    const output = getCommandOutput(errorLike);
+    throw new StepCommandError(
+      errorLike instanceof Error ? errorLike.message : String(errorLike),
+      output
+    );
+  }
+}
+function runInstallerCommand(command2, cwd, env, verbose) {
+  if (verbose) {
+    run(command2, cwd, env);
+    return;
+  }
+  runQuiet(command2, cwd, env);
+}
+function stepStart(label) {
+  blue(label);
+}
+function stepSuccess(label) {
+  green(label);
+}
+function stepFailure(label, errorLike, hint) {
+  error(`${label} failed.`);
+  const message = errorLike instanceof Error ? errorLike.message : String(errorLike);
+  const output = errorLike instanceof StepCommandError ? errorLike.output : getCommandOutput(errorLike);
+  if (output) {
+    console.error();
+    console.error(output.trimEnd());
+  } else if (message) {
+    console.error();
+    console.error(message.trim());
+  }
+  if (hint) {
+    console.error();
+    console.error(`Hint: ${hint}`);
+  }
+  process.exit(1);
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const command2 = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  execSync(`${command2} ${JSON.stringify(url)}`, { stdio: "ignore" });
+}
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function writeJson(filePath, value) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`);
+}
+function ensureDir(dirPath) {
+  mkdirSync(dirPath, { recursive: true });
+}
+function removePath(targetPath) {
+  if (!existsSync(targetPath)) return;
+  const stat = lstatSync(targetPath);
+  if (stat.isSymbolicLink() || stat.isFile()) {
+    unlinkSync(targetPath);
+    return;
+  }
+  rmSync(targetPath, { recursive: true, force: true });
+}
+function copyDirContents(sourceDir, targetDir) {
+  ensureDir(targetDir);
+  for (const entry of readdirSync(sourceDir)) {
+    cpSync(join(sourceDir, entry), join(targetDir, entry), { recursive: true });
+  }
+}
+function getBundledScaffoldPath(scaffoldRoot, relativePath) {
+  const baseName = path.basename(relativePath);
+  const bundledBaseName = baseName.startsWith(".") ? `__dot__${baseName.slice(1)}` : baseName;
+  return join(scaffoldRoot, dirname(relativePath), bundledBaseName);
+}
+function copyScaffoldFiles(scaffoldRoot, projectRoot, manifest) {
+  for (const relativePath of Object.keys(manifest.files)) {
+    const sourcePath = getBundledScaffoldPath(scaffoldRoot, relativePath);
+    const targetPath = join(projectRoot, relativePath);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    cpSync(sourcePath, targetPath);
+  }
+}
+function hashFile(filePath) {
+  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
+}
+function getPathSignature(filePath) {
+  if (!existsSync(filePath)) return null;
+  const stat = lstatSync(filePath);
+  if (!stat.isFile()) {
+    return "__NON_FILE__";
+  }
+  return hashFile(filePath);
+}
+function commandExists(command2) {
+  try {
+    if (process.platform === "win32") {
+      execSync(`where ${command2}`, { stdio: "ignore" });
+    } else {
+      execSync(`command -v ${command2}`, { stdio: "ignore", shell: "/bin/zsh" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 function findFreePort(startPort) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolvePort, rejectPort) => {
     const server = createServer();
     server.listen(startPort, () => {
-      server.close(() => resolve2(startPort));
+      server.close(() => resolvePort(startPort));
     });
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve2(findFreePort(startPort + 1));
+        resolvePort(findFreePort(startPort + 1));
       } else {
-        reject(err);
+        rejectPort(err);
       }
     });
   });
 }
-function run(cmd, cwd, env) {
-  execSync(cmd, {
-    cwd,
-    stdio: "inherit",
-    env: env ? { ...process.env, ...env } : process.env
+function getPackageRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+function getPackageVersion(packageRoot2) {
+  const packageJson = readJson(join(packageRoot2, "package.json"));
+  return packageJson.version;
+}
+function getLocalBundleRoot(packageRoot2) {
+  const bundleRoot = join(packageRoot2, "bundle");
+  if (!existsSync(join(bundleRoot, "scaffold")) || !existsSync(join(bundleRoot, "toolchain"))) {
+    throw new Error("CLI bundle assets are missing. Run `npm run build` before using the local package.");
+  }
+  return bundleRoot;
+}
+function getScaffoldManifest(bundleRoot) {
+  return readJson(join(bundleRoot, "meta", "scaffold-manifest.json"));
+}
+function getToolchainVersion(bundleRoot) {
+  return readFileSync(join(bundleRoot, "toolchain", "VERSION"), "utf8").trim();
+}
+function getManagedFilesPath(projectRoot) {
+  return join(projectRoot, METADATA_DIRNAME, MANAGED_FILES_FILE);
+}
+function getProjectMetadataPath(projectRoot) {
+  return join(projectRoot, METADATA_DIRNAME, PROJECT_METADATA_FILE);
+}
+function writeProjectState(projectRoot, showpaneVersion, scaffoldManifest, toolchainVersion) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const projectMetadata = {
+    schemaVersion: 1,
+    showpaneVersion,
+    scaffoldVersion: scaffoldManifest.scaffoldVersion,
+    toolchainVersion,
+    projectRoot,
+    installedAt: timestamp,
+    lastUpgradedAt: timestamp
+  };
+  writeJson(getProjectMetadataPath(projectRoot), projectMetadata);
+  writeJson(getManagedFilesPath(projectRoot), {
+    schemaVersion: 1,
+    showpaneVersion,
+    scaffoldVersion: scaffoldManifest.scaffoldVersion,
+    files: scaffoldManifest.files
   });
 }
-function openBrowser(url) {
-  const platform = process.platform;
-  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-  exec(`${cmd} ${url}`);
+function readManagedFiles(projectRoot) {
+  return readJson(
+    getManagedFilesPath(projectRoot)
+  );
+}
+function readProjectMetadata(projectRoot) {
+  return readJson(getProjectMetadataPath(projectRoot));
+}
+function writeUpdatedProjectState(projectRoot, previousMetadata, showpaneVersion, scaffoldManifest, toolchainVersion) {
+  writeJson(getProjectMetadataPath(projectRoot), {
+    ...previousMetadata,
+    showpaneVersion,
+    scaffoldVersion: scaffoldManifest.scaffoldVersion,
+    toolchainVersion,
+    lastUpgradedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeJson(getManagedFilesPath(projectRoot), {
+    schemaVersion: 1,
+    showpaneVersion,
+    scaffoldVersion: scaffoldManifest.scaffoldVersion,
+    files: scaffoldManifest.files
+  });
+}
+function detectProjectRoot(explicitProjectPath) {
+  const candidatePaths = [
+    explicitProjectPath ? resolve(explicitProjectPath) : null,
+    resolve(process.cwd()),
+    resolve(process.cwd(), "app")
+  ].filter(Boolean);
+  const configPath = join(SHOWPANE_HOME, "config.json");
+  if (existsSync(configPath)) {
+    const config = readJson(configPath);
+    if (config.app_path) {
+      candidatePaths.push(resolve(config.app_path));
+    }
+  }
+  for (const candidate of candidatePaths) {
+    if (existsSync(join(candidate, "package.json")) && existsSync(join(candidate, "prisma", "schema.prisma")) && existsSync(getProjectMetadataPath(candidate)) && existsSync(getManagedFilesPath(candidate))) {
+      return candidate;
+    }
+  }
+  throw new Error("Could not find a Showpane project root. Run the command from the project directory or pass --project <path>.");
+}
+function parseEnvFile(filePath) {
+  const env = {};
+  if (!existsSync(filePath)) return env;
+  for (const rawLine of readFileSync(filePath, "utf8").split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex === -1) continue;
+    const key = line.slice(0, separatorIndex).trim();
+    let value = line.slice(separatorIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+  return env;
+}
+function cleanupEmptyParents(projectRoot, relativePath) {
+  let currentDir = dirname(join(projectRoot, relativePath));
+  while (currentDir.startsWith(projectRoot) && currentDir !== projectRoot) {
+    if (readdirSync(currentDir).length > 0) break;
+    rmSync(currentDir, { recursive: true, force: true });
+    currentDir = dirname(currentDir);
+  }
+}
+function buildUpgradePlan(projectRoot, currentManifest, targetManifest) {
+  const plan = {
+    additions: [],
+    updates: [],
+    deletions: [],
+    conflicts: []
+  };
+  const allPaths = /* @__PURE__ */ new Set([
+    ...Object.keys(currentManifest),
+    ...Object.keys(targetManifest)
+  ]);
+  for (const relativePath of [...allPaths].sort()) {
+    const currentRecordedHash = currentManifest[relativePath];
+    const targetHash = targetManifest[relativePath];
+    const absolutePath = join(projectRoot, relativePath);
+    const currentHash = getPathSignature(absolutePath);
+    const existsNow = currentHash !== null;
+    const locallyModifiedManagedFile = currentRecordedHash !== void 0 && currentHash !== currentRecordedHash;
+    const collidingUnmanagedFile = currentRecordedHash === void 0 && targetHash !== void 0 && existsNow && currentHash !== targetHash;
+    if (locallyModifiedManagedFile || collidingUnmanagedFile) {
+      plan.conflicts.push(relativePath);
+      continue;
+    }
+    if (targetHash === void 0) {
+      if (existsNow) {
+        plan.deletions.push(relativePath);
+      }
+      continue;
+    }
+    if (!existsNow) {
+      plan.additions.push(relativePath);
+      continue;
+    }
+    if (currentHash !== targetHash) {
+      plan.updates.push(relativePath);
+    }
+  }
+  return plan;
+}
+function applyUpgradePlan(projectRoot, scaffoldSource, plan) {
+  for (const relativePath of plan.deletions) {
+    removePath(join(projectRoot, relativePath));
+    cleanupEmptyParents(projectRoot, relativePath);
+  }
+  for (const relativePath of [...plan.additions, ...plan.updates]) {
+    const sourcePath = getBundledScaffoldPath(scaffoldSource, relativePath);
+    const targetPath = join(projectRoot, relativePath);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    cpSync(sourcePath, targetPath);
+  }
+}
+function installDependencies(projectRoot, verbose) {
+  if (existsSync(join(projectRoot, "package-lock.json"))) {
+    if (verbose === void 0) {
+      run("npm ci", projectRoot, getInstallerEnv());
+    } else {
+      runInstallerCommand("npm ci", projectRoot, getInstallerEnv(), verbose);
+    }
+  } else {
+    if (verbose === void 0) {
+      run("npm install", projectRoot, getInstallerEnv());
+    } else {
+      runInstallerCommand("npm install", projectRoot, getInstallerEnv(), verbose);
+    }
+  }
+}
+function generateLocalDatabase(projectRoot, databaseUrl, verbose) {
+  const env = getInstallerEnv({
+    DATABASE_URL: databaseUrl
+  });
+  if (verbose === void 0) {
+    run("npm run prisma:db-push", projectRoot, env);
+  } else {
+    runInstallerCommand("npm run prisma:db-push", projectRoot, env, verbose);
+  }
+}
+function seedProject(projectRoot, databaseUrl, verbose) {
+  const env = getInstallerEnv({
+    DATABASE_URL: databaseUrl
+  });
+  if (verbose === void 0) {
+    run("npx tsx prisma/seed.ts", projectRoot, env);
+  } else {
+    runInstallerCommand("npx tsx prisma/seed.ts", projectRoot, env, verbose);
+  }
+}
+function maybeRunPostUpgradeSteps(projectRoot, changedPaths) {
+  const dependenciesChanged = changedPaths.some(
+    (relativePath) => ["package.json", "package-lock.json"].includes(relativePath)
+  );
+  const prismaChanged = changedPaths.some((relativePath) => relativePath.startsWith("prisma/"));
+  if (dependenciesChanged) {
+    blue("Refreshing project dependencies");
+    installDependencies(projectRoot);
+  }
+  if (prismaChanged) {
+    const env = parseEnvFile(join(projectRoot, ".env"));
+    if (env.DATABASE_URL?.startsWith("file:")) {
+      blue("Applying local SQLite schema updates");
+      run("npm run prisma:db-push", projectRoot, getInstallerEnv({
+        DATABASE_URL: env.DATABASE_URL
+      }));
+    } else {
+      blue("Refreshing Prisma client");
+      run("npm run prisma:generate", projectRoot, getInstallerEnv());
+    }
+  }
+}
+function tryInitializeGitRepo(projectRoot, announce = true) {
+  if (!commandExists("git")) {
+    blue("Git not found; skipped repository initialization");
+    return;
+  }
+  try {
+    execSync("git init -q -b main", { cwd: projectRoot, stdio: "ignore" });
+  } catch {
+    execSync("git init -q", { cwd: projectRoot, stdio: "ignore" });
+    try {
+      execSync("git branch -M main", { cwd: projectRoot, stdio: "ignore" });
+    } catch {
+    }
+  }
+  try {
+    run("git add .", projectRoot);
+    execSync('git commit -m "Initial Showpane scaffold"', {
+      cwd: projectRoot,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: "Showpane",
+        GIT_AUTHOR_EMAIL: "showpane@local.invalid",
+        GIT_COMMITTER_NAME: "Showpane",
+        GIT_COMMITTER_EMAIL: "showpane@local.invalid"
+      }
+    });
+    if (announce) {
+      green("Git repository initialized");
+    }
+  } catch {
+    if (announce) {
+      blue("Initialized git repository without an initial commit");
+    }
+  }
+}
+function installSharedSkillProjection(toolchainRoot) {
+  const sharedSource = join(toolchainRoot, "skills", "shared");
+  const sharedTarget = join(CLAUDE_SKILLS_DIR, SHOWPANE_SHARED_SKILL);
+  removePath(sharedTarget);
+  symlinkSync(
+    sharedSource,
+    sharedTarget,
+    process.platform === "win32" ? "junction" : "dir"
+  );
+}
+function printCreateSuccessCard(projectRoot, projectName, url) {
+  console.log();
+  console.log(`  ${GREEN}Showpane is ready${RESET}`);
+  console.log();
+  console.log(`  ${BOLD}Project:${RESET} ${projectRoot}`);
+  console.log(`  ${BOLD}App:${RESET}     ${url}`);
+  console.log(`  ${BOLD}Demo:${RESET}    example / demo-only-password`);
+  console.log();
+  console.log(`  ${BOLD}Next:${RESET}`);
+  console.log(`    ${DIM}cd ${projectName} && claude${RESET}`);
+  console.log();
+  console.log(`  ${BOLD}Try:${RESET}`);
+  console.log(`    ${DIM}Create a portal for my call with Acme Health${RESET}`);
+  console.log();
+}
+function startDevServer(projectRoot, databaseUrl, noOpen, verbose) {
+  return new Promise(async (resolveStart, rejectStart) => {
+    const port = await findFreePort(3e3);
+    const url = `http://localhost:${port}`;
+    const devServer = spawn("npm", ["run", "dev"], {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, PORT: String(port), DATABASE_URL: databaseUrl }
+    });
+    let ready = false;
+    let bufferedOutput = "";
+    const readyPattern = /ready in/i;
+    const handleChunk = (target) => (chunk) => {
+      const text = chunk.toString();
+      if (verbose) {
+        target.write(text);
+      } else if (ready) {
+        target.write(text);
+      } else {
+        bufferedOutput += text;
+        if (bufferedOutput.length > 1e5) {
+          bufferedOutput = bufferedOutput.slice(-1e5);
+        }
+      }
+      if (!ready && readyPattern.test(text)) {
+        ready = true;
+        stepSuccess("Start app");
+        if (!noOpen) {
+          blue(`Opening ${url}`);
+          try {
+            openBrowser(url);
+          } catch {
+          }
+        }
+        resolveStart({ devServer, url });
+      }
+    };
+    devServer.stdout?.on("data", handleChunk(process.stdout));
+    devServer.stderr?.on("data", handleChunk(process.stderr));
+    devServer.on("error", (errorLike) => {
+      rejectStart(new StepCommandError(
+        errorLike instanceof Error ? errorLike.message : String(errorLike),
+        bufferedOutput.trim()
+      ));
+    });
+    devServer.on("close", (code) => {
+      if (ready) {
+        return;
+      }
+      const message = code === null ? "Dev server exited before becoming ready." : `Dev server exited with code ${code} before becoming ready.`;
+      rejectStart(new StepCommandError(message, bufferedOutput.trim()));
+    });
+  });
 }
-async function main() {
-  if (process.argv.includes("--version")) {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
-    console.log(pkg.version);
-    process.exit(0);
+function installSkillProjection(toolchainRoot) {
+  removePath(join(CLAUDE_SKILLS_DIR, "showpane"));
+  installSharedSkillProjection(toolchainRoot);
+  const installedSkills = [];
+  const skillsRoot = join(toolchainRoot, "skills");
+  const skillDirs = readdirSync(skillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("portal-"));
+  for (const skillDir of skillDirs) {
+    const skillMdPath = join(skillsRoot, skillDir.name, "SKILL.md");
+    if (!existsSync(skillMdPath)) continue;
+    const skillNameMatch = readFileSync(skillMdPath, "utf8").match(/^name:\s*(.+)$/m);
+    const skillName = skillNameMatch?.[1]?.trim() || skillDir.name;
+    const targetDir = join(CLAUDE_SKILLS_DIR, skillName);
+    removePath(targetDir);
+    mkdirSync(targetDir, { recursive: true });
+    symlinkSync(skillMdPath, join(targetDir, "SKILL.md"));
+    installedSkills.push(skillName);
+  }
+  return installedSkills;
+}
+function syncToolchain(bundleRoot, showpaneVersion, announce = true) {
+  const sourceToolchain = join(bundleRoot, "toolchain");
+  const targetToolchain = join(TOOLCHAIN_DIR, showpaneVersion);
+  ensureDir(TOOLCHAIN_DIR);
+  ensureDir(SHOWPANE_HOME);
+  ensureDir(CLAUDE_SKILLS_DIR);
+  removePath(targetToolchain);
+  copyDirContents(sourceToolchain, targetToolchain);
+  const helperBinDir = join(SHOWPANE_HOME, "bin");
+  ensureDir(helperBinDir);
+  removePath(join(helperBinDir, "showpane-config"));
+  symlinkSync(
+    join(targetToolchain, "bin", "showpane-config"),
+    join(helperBinDir, "showpane-config")
+  );
+  removePath(CURRENT_TOOLCHAIN_LINK);
+  symlinkSync(
+    targetToolchain,
+    CURRENT_TOOLCHAIN_LINK,
+    process.platform === "win32" ? "junction" : "dir"
+  );
+  const installedSkills = installSkillProjection(targetToolchain);
+  if (announce) {
+    green(`Toolchain synced to v${showpaneVersion}`);
+    green(`${installedSkills.length} Claude Code skills installed`);
+  }
+  return {
+    installedSkills,
+    toolchainRoot: targetToolchain,
+    toolchainVersion: getToolchainVersion(bundleRoot)
+  };
+}
+function extractBundleForVersion(version) {
+  const tempRoot = fs.mkdtempSync(join(os.tmpdir(), "showpane-upgrade-"));
+  const packResult = capture(`npm pack showpane@${version} --json`, tempRoot);
+  const packJson = JSON.parse(packResult);
+  const tarballName = packJson.at(-1)?.filename;
+  if (!tarballName) {
+    throw new Error(`Could not download showpane@${version}`);
+  }
+  run(
+    `tar -xzf ${JSON.stringify(join(tempRoot, tarballName))} -C ${JSON.stringify(tempRoot)}`,
+    tempRoot
+  );
+  return {
+    bundleRoot: join(tempRoot, "package", "bundle"),
+    cleanup() {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  };
+}
+async function createProject(args) {
+  const packageRoot2 = getPackageRoot();
+  const bundleRoot = getLocalBundleRoot(packageRoot2);
+  const showpaneVersion = getPackageVersion(packageRoot2);
+  const scaffoldManifest = getScaffoldManifest(bundleRoot);
+  let options;
+  try {
+    options = parseCreateArgs(args);
+  } catch (errorLike) {
+    printBanner();
+    console.log();
+    error(errorLike instanceof Error ? errorLike.message : String(errorLike));
+    printCreateUsage();
+    process.exit(1);
   }
   printBanner();
-  const companyName = await ask(`  ${BOLD}What's your company name?${RESET} `);
+  const companyName = options.companyName ?? await ask(`  ${BOLD}What's your company name?${RESET} `);
   if (!companyName) {
     error("Company name is required.");
     process.exit(1);
   }
   const slug = toSlug(companyName);
   const dirName = `showpane-${slug}`;
+  const projectRoot = resolve(process.cwd(), dirName);
+  if (existsSync(projectRoot)) {
+    error(`Target directory already exists: ${dirName}/`);
+    process.exit(1);
+  }
   console.log();
   blue(`Setting up ${BOLD}${companyName}${RESET} portal as ${DIM}${dirName}/${RESET}`);
   console.log();
+  stepStart("Create project");
   try {
-    run(
-      `git clone --depth 1 https://github.com/twillcocks/showpane.git ${dirName}`
-    );
-    green("Cloned repository");
-  } catch {
-    error("Failed to clone repository. Check your internet connection and try again.");
-    process.exit(1);
+    copyScaffoldFiles(join(bundleRoot, "scaffold"), projectRoot, scaffoldManifest);
+    stepSuccess("Project created");
+  } catch (errorLike) {
+    stepFailure("Create project", errorLike);
   }
-  const appDir = resolve(process.cwd(), dirName, "app");
+  stepStart("Install dependencies");
   try {
-    run("npm install", appDir);
-    green("Dependencies installed");
-  } catch {
-    error("Failed to install dependencies.");
-    process.exit(1);
+    installDependencies(projectRoot, options.verbose);
+    stepSuccess("Dependencies installed");
+  } catch (errorLike) {
+    stepFailure(
+      "Install dependencies",
+      errorLike,
+      "Check your Node.js version and network connection, then try again."
+    );
   }
   const authSecret = randomBytes(32).toString("hex");
   const databaseUrl = "file:./dev.db";
-  const envContent = `DATABASE_URL="${databaseUrl}"
+  writeFileSync(
+    join(projectRoot, ".env"),
+    `DATABASE_URL="${databaseUrl}"
 AUTH_SECRET="${authSecret}"
-`;
-  writeFileSync(resolve(appDir, ".env"), envContent);
-  green("Environment configured");
+`
+  );
+  stepStart("Configure database");
   try {
-    run("npx prisma db push --schema prisma/schema.local.prisma", appDir, {
-      DATABASE_URL: databaseUrl
-    });
-    green("Database ready");
-  } catch {
-    error("Failed to set up the database. Check Prisma schema and try again.");
-    process.exit(1);
+    generateLocalDatabase(projectRoot, databaseUrl, options.verbose);
+    seedProject(projectRoot, databaseUrl, options.verbose);
+    stepSuccess("Database configured");
+  } catch (errorLike) {
+    stepFailure(
+      "Configure database",
+      errorLike,
+      "Check Prisma setup and the generated .env file, then retry the install."
+    );
   }
+  stepStart("Install Claude skills");
+  let toolchainInfo;
   try {
-    run("npx tsx prisma/seed.ts", appDir, {
-      DATABASE_URL: databaseUrl
-    });
-    green("Example portal seeded");
-  } catch {
-    blue("Skipped example portal (seed failed \u2014 not a problem)");
+    toolchainInfo = syncToolchain(bundleRoot, showpaneVersion, false);
+    writeProjectState(
+      projectRoot,
+      showpaneVersion,
+      scaffoldManifest,
+      toolchainInfo.toolchainVersion
+    );
+    tryInitializeGitRepo(projectRoot, false);
+    stepSuccess("Claude skills installed");
+  } catch (errorLike) {
+    stepFailure(
+      "Install Claude skills",
+      errorLike,
+      "Check permissions for ~/.showpane and ~/.claude/skills, then try again."
+    );
   }
-  const skillsSource = path.resolve(process.cwd(), dirName, "skills");
-  const skillsTarget = path.join(os.homedir(), ".claude", "skills");
-  const oldSymlink = path.join(skillsTarget, "showpane");
+  stepStart("Start app");
+  let serverStart;
   try {
-    const stat = fs.lstatSync(oldSymlink);
-    if (stat.isSymbolicLink()) fs.unlinkSync(oldSymlink);
-  } catch {
-  }
-  fs.mkdirSync(skillsTarget, { recursive: true });
-  const skillDirs = fs.readdirSync(skillsSource, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("portal-"));
-  const installedSkills = [];
-  for (const dir of skillDirs) {
-    const skillMdPath = path.join(skillsSource, dir.name, "SKILL.md");
-    if (!fs.existsSync(skillMdPath)) continue;
-    const skillContent = fs.readFileSync(skillMdPath, "utf-8");
-    const nameMatch = skillContent.match(/^name:\s*(.+)$/m);
-    const skillName = nameMatch?.[1]?.trim() || dir.name;
-    const targetDir = path.join(skillsTarget, skillName);
-    try {
-      const stat = fs.lstatSync(targetDir);
-      if (stat.isSymbolicLink()) fs.unlinkSync(targetDir);
-    } catch {
-    }
-    fs.mkdirSync(targetDir, { recursive: true });
-    const skillFile = path.join(targetDir, "SKILL.md");
-    try {
-      fs.unlinkSync(skillFile);
-    } catch {
-    }
-    fs.symlinkSync(skillMdPath, skillFile);
-    installedSkills.push(skillName);
-    const prefixedDir = path.join(skillsTarget, `showpane-${skillName}`);
-    try {
-      if (fs.existsSync(prefixedDir) && fs.lstatSync(path.join(prefixedDir, "SKILL.md")).isSymbolicLink()) {
-        const linkDest = fs.readlinkSync(path.join(prefixedDir, "SKILL.md"));
-        if (linkDest.includes("showpane") || linkDest.includes("portal")) {
-          fs.rmSync(prefixedDir, { recursive: true });
-        }
-      }
-    } catch {
-    }
+    serverStart = await startDevServer(
+      projectRoot,
+      databaseUrl,
+      options.noOpen,
+      options.verbose
+    );
+  } catch (errorLike) {
+    stepFailure(
+      "Start app",
+      errorLike,
+      `Run ${BOLD}cd ${dirName} && npm run dev${RESET} for more detail.`
+    );
   }
-  green(`${installedSkills.length} Claude Code skills installed`);
-  const port = await findFreePort(3e3);
-  green(`Server starting on port ${port}`);
-  const url = `http://localhost:${port}`;
-  blue(`Opening ${url}`);
-  console.log();
-  console.log(`  ${GREEN}Ready!${RESET} ${installedSkills.length} Claude Code skills installed.`);
-  console.log();
-  console.log(`  Open Claude Code and create your first portal:`);
-  console.log(`    ${DIM}cd ${dirName}/app${RESET}`);
-  console.log(`    ${BOLD}claude${RESET}`);
-  console.log(`    ${DIM}> Create a portal for my call with [client name]${RESET}`);
-  console.log();
-  console.log(`  Available skills: /portal-create, /portal-deploy, /portal-list, ...`);
-  console.log();
-  console.log(`  ${DIM}Don't have Claude Code? Install from https://claude.ai/code${RESET}`);
-  console.log();
-  const devServer = spawn("npm", ["run", "dev"], {
-    cwd: appDir,
-    stdio: "inherit",
-    env: { ...process.env, PORT: String(port), DATABASE_URL: databaseUrl }
-  });
-  setTimeout(() => {
-    openBrowser(url);
-  }, 3e3);
-  devServer.on("close", (code) => {
+  printCreateSuccessCard(projectRoot, dirName, serverStart.url);
+  serverStart.devServer.on("close", (code) => {
     if (code !== 0) {
       error(`Dev server exited with code ${code}`);
     }
     process.exit(code ?? 1);
   });
   process.on("SIGINT", () => {
-    devServer.kill("SIGINT");
+    serverStart.devServer.kill("SIGINT");
   });
   process.on("SIGTERM", () => {
-    devServer.kill("SIGTERM");
+    serverStart.devServer.kill("SIGTERM");
   });
 }
-var API_BASE = "https://app.showpane.com";
+async function syncCurrentToolchain() {
+  const packageRoot2 = getPackageRoot();
+  const bundleRoot = getLocalBundleRoot(packageRoot2);
+  const showpaneVersion = getPackageVersion(packageRoot2);
+  printBanner();
+  maybePrintShowpaneUpdateMessage(showpaneVersion);
+  console.log();
+  blue(`Syncing Showpane toolchain v${showpaneVersion}`);
+  console.log();
+  syncToolchain(bundleRoot, showpaneVersion);
+}
+function parseUpgradeArgs(args) {
+  const getArg = (flag) => {
+    const index = args.indexOf(flag);
+    return index !== -1 ? args[index + 1] : void 0;
+  };
+  return {
+    targetVersion: getArg("--to"),
+    projectPath: getArg("--project"),
+    dryRun: args.includes("--dry-run")
+  };
+}
+async function upgradeProject(args) {
+  const packageRoot2 = getPackageRoot();
+  const currentCliVersion = getPackageVersion(packageRoot2);
+  const { targetVersion, projectPath, dryRun } = parseUpgradeArgs(args);
+  const resolvedTargetVersion = targetVersion || currentCliVersion;
+  const projectRoot = detectProjectRoot(projectPath);
+  printBanner();
+  maybePrintShowpaneUpdateMessage(currentCliVersion);
+  console.log();
+  blue(`Preparing upgrade for ${DIM}${projectRoot}${RESET}`);
+  console.log();
+  const bundleSource = resolvedTargetVersion === currentCliVersion ? { bundleRoot: getLocalBundleRoot(packageRoot2), cleanup() {
+  } } : extractBundleForVersion(resolvedTargetVersion);
+  try {
+    const targetBundleRoot = bundleSource.bundleRoot;
+    const scaffoldManifest = getScaffoldManifest(targetBundleRoot);
+    const currentManagedFiles = readManagedFiles(projectRoot).files;
+    const projectMetadata = readProjectMetadata(projectRoot);
+    const plan = buildUpgradePlan(projectRoot, currentManagedFiles, scaffoldManifest.files);
+    if (plan.conflicts.length > 0) {
+      error(`Upgrade blocked by ${plan.conflicts.length} modified managed file(s).`);
+      for (const relativePath of plan.conflicts) {
+        console.error(`    ${relativePath}`);
+      }
+      process.exit(1);
+    }
+    console.log(`  Additions: ${plan.additions.length}`);
+    console.log(`  Updates:   ${plan.updates.length}`);
+    console.log(`  Deletions: ${plan.deletions.length}`);
+    console.log(`  Conflicts: ${plan.conflicts.length}`);
+    console.log();
+    if (dryRun) {
+      green(`Dry run complete for showpane@${resolvedTargetVersion}`);
+      process.exit(0);
+    }
+    applyUpgradePlan(projectRoot, join(targetBundleRoot, "scaffold"), plan);
+    maybeRunPostUpgradeSteps(projectRoot, [
+      ...plan.additions,
+      ...plan.updates,
+      ...plan.deletions
+    ]);
+    const toolchainInfo = syncToolchain(targetBundleRoot, resolvedTargetVersion);
+    writeUpdatedProjectState(
+      projectRoot,
+      projectMetadata,
+      resolvedTargetVersion,
+      scaffoldManifest,
+      toolchainInfo.toolchainVersion
+    );
+    green(`Project upgraded to showpane@${resolvedTargetVersion}`);
+  } finally {
+    bundleSource.cleanup();
+  }
+}
 async function login() {
   printBanner();
   blue("Authenticating with Showpane...");
@@ -237,11 +929,11 @@ async function login() {
   blue(`Opened ${verificationUrl}`);
   console.log();
   blue("Waiting for authorization...");
-  const POLL_INTERVAL = 2e3;
-  const TIMEOUT = 10 * 60 * 1e3;
+  const pollInterval = 2e3;
+  const timeoutMs = 10 * 60 * 1e3;
   const start = Date.now();
-  while (Date.now() - start < TIMEOUT) {
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+  while (Date.now() - start < timeoutMs) {
+    await new Promise((resolveLater) => setTimeout(resolveLater, pollInterval));
     const pollRes = await fetch(`${API_BASE}/api/cli/poll?code=${code}`);
     if (pollRes.status === 410) {
       error("Code expired. Please try again.");
@@ -251,43 +943,58 @@ async function login() {
       throw new Error(`Poll failed (${pollRes.status})`);
     }
     const data = await pollRes.json();
-    if (data.status === "approved") {
-      const configDir = join(homedir(), ".showpane");
-      mkdirSync(configDir, { recursive: true });
-      const configPath = join(configDir, "config.json");
-      writeFileSync(
-        configPath,
-        JSON.stringify(
-          {
-            accessToken: data.accessToken,
-            accessTokenExpiresAt: data.tokenExpiresAt,
-            orgSlug: data.orgSlug,
-            portalUrl: data.portalUrl,
-            vercelProjectId: data.vercelProjectId,
-            app_path: join(process.cwd(), "app"),
-            deploy_mode: "cloud"
-          },
-          null,
-          2
-        )
-      );
-      chmodSync(configPath, 384);
-      console.log();
-      green(`Authenticated! Connected to ${BOLD}${data.orgSlug}${RESET}`);
-      console.log();
-      return;
-    }
+    if (data.status !== "approved") continue;
+    const configDir = join(homedir(), ".showpane");
+    mkdirSync(configDir, { recursive: true });
+    const configPath = join(configDir, "config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify(
+        {
+          accessToken: data.accessToken,
+          accessTokenExpiresAt: data.tokenExpiresAt,
+          orgSlug: data.orgSlug,
+          portalUrl: data.portalUrl,
+          vercelProjectId: data.vercelProjectId,
+          app_path: process.cwd(),
+          deploy_mode: "cloud"
+        },
+        null,
+        2
+      )
+    );
+    chmodSync(configPath, 384);
+    console.log();
+    green(`Authenticated! Connected to ${BOLD}${data.orgSlug}${RESET}`);
+    console.log();
+    return;
   }
   error("Authentication timed out. Please try again.");
   process.exit(1);
 }
-if (process.argv[2] === "login") {
+var command = process.argv[2];
+var packageRoot = getPackageRoot();
+if (process.argv.includes("--version")) {
+  console.log(getPackageVersion(packageRoot));
+  process.exit(0);
+}
+if (command === "login") {
   login().catch((err) => {
     error(String(err));
     process.exit(1);
   });
+} else if (command === "sync") {
+  syncCurrentToolchain().catch((err) => {
+    error(String(err));
+    process.exit(1);
+  });
+} else if (command === "upgrade") {
+  upgradeProject(process.argv.slice(3)).catch((err) => {
+    error(String(err));
+    process.exit(1);
+  });
 } else {
-  main().catch((err) => {
+  createProject(process.argv.slice(2)).catch((err) => {
     error(String(err));
     process.exit(1);
   });