@stacksolo/cli 0.1.4 → 0.1.5

package/dist/index.js

@@ -4172,132 +4172,132 @@ function validateProject(project, errors) {
   }
   checkDuplicateNames(project, errors);
 }
-function validateBucket(bucket, path27, errors) {
+function validateBucket(bucket, path28, errors) {
   if (!bucket.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidBucketName(bucket.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "bucket name must be 3-63 chars, lowercase alphanumeric with hyphens/underscores",
       value: bucket.name
     });
   }
   if (bucket.storageClass && !["STANDARD", "NEARLINE", "COLDLINE", "ARCHIVE"].includes(bucket.storageClass)) {
     errors.push({
-      path: `${path27}.storageClass`,
+      path: `${path28}.storageClass`,
       message: "storageClass must be STANDARD, NEARLINE, COLDLINE, or ARCHIVE",
       value: bucket.storageClass
     });
   }
 }
-function validateSecret(secret, path27, errors) {
+function validateSecret(secret, path28, errors) {
   if (!secret.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(secret.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: secret.name
     });
   }
 }
-function validateTopic(topic, path27, errors) {
+function validateTopic(topic, path28, errors) {
   if (!topic.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(topic.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: topic.name
     });
   }
 }
-function validateQueue(queue, path27, errors) {
+function validateQueue(queue, path28, errors) {
   if (!queue.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(queue.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: queue.name
     });
   }
 }
-function validateCron(cron, path27, errors) {
+function validateCron(cron, path28, errors) {
   if (!cron.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   }
   if (!cron.schedule) {
-    errors.push({ path: `${path27}.schedule`, message: "schedule is required" });
+    errors.push({ path: `${path28}.schedule`, message: "schedule is required" });
   } else if (!isValidCronExpression(cron.schedule)) {
     errors.push({
-      path: `${path27}.schedule`,
+      path: `${path28}.schedule`,
       message: "schedule must be a valid cron expression",
       value: cron.schedule
     });
   }
   if (!cron.target) {
-    errors.push({ path: `${path27}.target`, message: "target is required" });
+    errors.push({ path: `${path28}.target`, message: "target is required" });
   }
 }
-function validateNetwork(network, path27, errors) {
+function validateNetwork(network, path28, errors) {
   if (!network.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(network.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: network.name
     });
   }
   if (network.containers) {
     network.containers.forEach((container, i) => {
-      validateContainer(container, `${path27}.containers[${i}]`, errors);
+      validateContainer(container, `${path28}.containers[${i}]`, errors);
     });
   }
   if (network.functions) {
     network.functions.forEach((fn, i) => {
-      validateFunction(fn, `${path27}.functions[${i}]`, errors);
+      validateFunction(fn, `${path28}.functions[${i}]`, errors);
     });
   }
   if (network.databases) {
     network.databases.forEach((db, i) => {
-      validateDatabase(db, `${path27}.databases[${i}]`, errors);
+      validateDatabase(db, `${path28}.databases[${i}]`, errors);
     });
   }
   if (network.caches) {
     network.caches.forEach((cache2, i) => {
-      validateCache(cache2, `${path27}.caches[${i}]`, errors);
+      validateCache(cache2, `${path28}.caches[${i}]`, errors);
     });
   }
 }
-function validateContainer(container, path27, errors) {
+function validateContainer(container, path28, errors) {
   if (!container.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(container.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: container.name
     });
   }
   if (container.memory && !isValidMemoryFormat(container.memory)) {
     errors.push({
-      path: `${path27}.memory`,
+      path: `${path28}.memory`,
       message: "memory must be in format like 256Mi, 1Gi, 2Gi",
       value: container.memory
     });
   }
   if (container.env) {
-    validateEnvReferences(container.env, `${path27}.env`, errors);
+    validateEnvReferences(container.env, `${path28}.env`, errors);
   }
 }
-function validateFunction(fn, path27, errors) {
+function validateFunction(fn, path28, errors) {
   if (!fn.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(fn.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: fn.name
     });
@@ -4305,21 +4305,21 @@ function validateFunction(fn, path27, errors) {
   const validRuntimes = ["nodejs20", "nodejs18", "python311", "python310", "go121", "go120"];
   if (fn.runtime && !validRuntimes.includes(fn.runtime)) {
     errors.push({
-      path: `${path27}.runtime`,
+      path: `${path28}.runtime`,
       message: `runtime must be one of: ${validRuntimes.join(", ")}`,
       value: fn.runtime
     });
   }
   if (fn.env) {
-    validateEnvReferences(fn.env, `${path27}.env`, errors);
+    validateEnvReferences(fn.env, `${path28}.env`, errors);
   }
 }
-function validateDatabase(db, path27, errors) {
+function validateDatabase(db, path28, errors) {
   if (!db.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(db.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: db.name
     });
@@ -4327,36 +4327,36 @@ function validateDatabase(db, path27, errors) {
   const validVersions = ["POSTGRES_15", "POSTGRES_14", "MYSQL_8_0", "MYSQL_5_7"];
   if (db.databaseVersion && !validVersions.includes(db.databaseVersion)) {
     errors.push({
-      path: `${path27}.databaseVersion`,
+      path: `${path28}.databaseVersion`,
       message: `databaseVersion must be one of: ${validVersions.join(", ")}`,
       value: db.databaseVersion
     });
   }
 }
-function validateCache(cache2, path27, errors) {
+function validateCache(cache2, path28, errors) {
   if (!cache2.name) {
-    errors.push({ path: `${path27}.name`, message: "name is required" });
+    errors.push({ path: `${path28}.name`, message: "name is required" });
   } else if (!isValidResourceName(cache2.name)) {
     errors.push({
-      path: `${path27}.name`,
+      path: `${path28}.name`,
       message: "name must be lowercase alphanumeric with hyphens, 1-63 chars",
       value: cache2.name
     });
   }
   if (cache2.tier && !["BASIC", "STANDARD_HA"].includes(cache2.tier)) {
     errors.push({
-      path: `${path27}.tier`,
+      path: `${path28}.tier`,
       message: "tier must be BASIC or STANDARD_HA",
       value: cache2.tier
     });
   }
 }
-function validateEnvReferences(env, path27, errors) {
+function validateEnvReferences(env, path28, errors) {
   for (const [key, value] of Object.entries(env)) {
     if (value.startsWith("@")) {
       if (!isValidReference(value)) {
         errors.push({
-          path: `${path27}.${key}`,
+          path: `${path28}.${key}`,
           message: "invalid reference format. Expected @type/name or @type/name.property",
           value
         });
@@ -4366,15 +4366,15 @@ function validateEnvReferences(env, path27, errors) {
 }
 function checkDuplicateNames(project, errors) {
   const seen = /* @__PURE__ */ new Map();
-  const check = (name, path27) => {
+  const check = (name, path28) => {
     if (seen.has(name)) {
       errors.push({
-        path: path27,
+        path: path28,
         message: `duplicate resource name "${name}" (also defined at ${seen.get(name)})`,
         value: name
       });
     } else {
-      seen.set(name, path27);
+      seen.set(name, path28);
     }
   };
   project.buckets?.forEach((b, i) => check(b.name, `project.buckets[${i}]`));
@@ -4384,15 +4384,15 @@ function checkDuplicateNames(project, errors) {
   project.crons?.forEach((c, i) => check(c.name, `project.crons[${i}]`));
   project.networks?.forEach((network, ni) => {
     const networkSeen = /* @__PURE__ */ new Map();
-    const checkNetwork = (name, path27) => {
+    const checkNetwork = (name, path28) => {
       if (networkSeen.has(name)) {
         errors.push({
-          path: path27,
+          path: path28,
           message: `duplicate resource name "${name}" in network "${network.name}" (also at ${networkSeen.get(name)})`,
           value: name
         });
       } else {
-        networkSeen.set(name, path27);
+        networkSeen.set(name, path28);
       }
     };
     network.containers?.forEach((c, i) => checkNetwork(c.name, `project.networks[${ni}].containers[${i}]`));
@@ -5569,11 +5569,11 @@ function buildDependencyGraph(resources) {
 function detectCycles(graph) {
   const visited = /* @__PURE__ */ new Set();
   const recursionStack = /* @__PURE__ */ new Set();
-  const path27 = [];
+  const path28 = [];
   function dfs(nodeId) {
     visited.add(nodeId);
     recursionStack.add(nodeId);
-    path27.push(nodeId);
+    path28.push(nodeId);
     const node = graph.get(nodeId);
     if (node) {
       for (const depId of node.dependencies) {
@@ -5581,20 +5581,20 @@ function detectCycles(graph) {
           if (dfs(depId))
             return true;
         } else if (recursionStack.has(depId)) {
-          const cycleStart = path27.indexOf(depId);
-          path27.push(depId);
+          const cycleStart = path28.indexOf(depId);
+          path28.push(depId);
           return true;
         }
       }
     }
-    path27.pop();
+    path28.pop();
     recursionStack.delete(nodeId);
     return false;
   }
   for (const nodeId of graph.keys()) {
     if (!visited.has(nodeId)) {
       if (dfs(nodeId)) {
-        return path27;
+        return path28;
       }
     }
   }
@@ -5649,18 +5649,18 @@ function prefixBucketName(projectName, bucketName) {
   const truncated = bucketName.slice(0, remaining);
   return `${truncated}-${hash}`;
 }
-function prefixRoutePath(projectName, path27) {
-  if (path27 === "/*" || path27 === "/") {
+function prefixRoutePath(projectName, path28) {
+  if (path28 === "/*" || path28 === "/") {
     return `/${projectName}/*`;
   }
-  const normalized = path27.startsWith("/") ? path27 : `/${path27}`;
+  const normalized = path28.startsWith("/") ? path28 : `/${path28}`;
   return `/${projectName}${normalized}`;
 }
 function relativeSourceDir(sourceProjectPath, sourceDir, outputDir) {
-  const path27 = __require("path");
-  const relativeToSource = path27.relative(outputDir, sourceProjectPath);
+  const path28 = __require("path");
+  const relativeToSource = path28.relative(outputDir, sourceProjectPath);
   const normalized = sourceDir.startsWith("./") ? sourceDir.slice(2) : sourceDir;
-  return path27.join(relativeToSource, normalized);
+  return path28.join(relativeToSource, normalized);
 }
 function simpleHash(str) {
   let hash = 0;
@@ -6142,9 +6142,9 @@ function validateMergedConfig(config) {
   const warnings = [];
   const baseResult = validateConfig(config);
   const project = config.project;
-  const checkNameLength = (name, path27) => {
+  const checkNameLength = (name, path28) => {
     if (name.length > 50) {
-      warnings.push(`${path27}: name "${name}" is ${name.length} chars (max 63). Consider shorter names.`);
+      warnings.push(`${path28}: name "${name}" is ${name.length} chars (max 63). Consider shorter names.`);
     }
   };
   for (const bucket of project.buckets || []) {
@@ -6182,9 +6182,9 @@ function validateMergedConfig(config) {
       }
     }
   }
-  for (const [path27, backends] of routePaths) {
+  for (const [path28, backends] of routePaths) {
     if (backends.length > 1) {
-      warnings.push(`Route path "${path27}" is used by multiple backends: ${backends.join(", ")}`);
+      warnings.push(`Route path "${path28}" is used by multiple backends: ${backends.join(", ")}`);
     }
   }
   return {
@@ -13355,9 +13355,9 @@ import * as path15 from "path";
 
 // src/api-client.ts
 var API_BASE = process.env.STACKSOLO_API_URL || "http://localhost:4000";
-async function callApi(path27, method = "GET", body) {
+async function callApi(path28, method = "GET", body) {
   try {
-    const response = await fetch(`${API_BASE}${path27}`, {
+    const response = await fetch(`${API_BASE}${path28}`, {
       method,
       headers: {
         "Content-Type": "application/json"
@@ -13391,7 +13391,7 @@ var api = {
   },
   patterns: {
     list: () => callApi("/trpc/patterns.list"),
-    detect: (path27) => callApi(`/trpc/patterns.detect?input=${encodeURIComponent(JSON.stringify({ path: path27 }))}`)
+    detect: (path28) => callApi(`/trpc/patterns.detect?input=${encodeURIComponent(JSON.stringify({ path: path28 }))}`)
   },
   deployments: {
     deploy: (projectId) => callApi("/trpc/deployments.deploy", "POST", { projectId }),
@@ -14168,9 +14168,9 @@ var listCommand = new Command11("list").description("List all registered project
 // src/commands/infra/events.ts
 import { Command as Command12 } from "commander";
 import chalk13 from "chalk";
-function drawTableLine(columns, char = "-", join26 = "+") {
+function drawTableLine(columns, char = "-", join27 = "+") {
   const segments = columns.map((col) => char.repeat(col.width + 2));
-  return join26 + segments.join(join26) + join26;
+  return join27 + segments.join(join27) + join27;
 }
 function drawTableRow(columns, values) {
   const cells = columns.map((col, i) => {
@@ -14660,10 +14660,10 @@ async function getGcpProjectId(explicitProject) {
     return explicitProject;
   }
   try {
-    const fs22 = await import("fs/promises");
-    const path27 = await import("path");
-    const configPath = path27.join(process.cwd(), ".stacksolo", "stacksolo.config.json");
-    const configData = await fs22.readFile(configPath, "utf-8");
+    const fs23 = await import("fs/promises");
+    const path28 = await import("path");
+    const configPath = path28.join(process.cwd(), ".stacksolo", "stacksolo.config.json");
+    const configData = await fs23.readFile(configPath, "utf-8");
     const config = JSON.parse(configData);
     if (config.project?.gcpProjectId) {
       return config.project.gcpProjectId;
@@ -15531,11 +15531,11 @@ var buildCommand = new Command16("build").description("Build and push container
 
 // src/commands/dev/dev.ts
 import { Command as Command17 } from "commander";
-import chalk18 from "chalk";
-import ora8 from "ora";
-import { spawn as spawn6, execSync as execSync2 } from "child_process";
-import * as fs19 from "fs/promises";
-import * as path22 from "path";
+import chalk19 from "chalk";
+import ora9 from "ora";
+import { spawn as spawn7, execSync as execSync2 } from "child_process";
+import * as fs20 from "fs/promises";
+import * as path23 from "path";
 
 // src/generators/k8s/namespace.ts
 function generateNamespace(projectName) {
@@ -16910,17 +16910,300 @@ function generateK8sManifests(options) {
   };
 }
 async function writeK8sManifests(manifests, outputDir) {
-  const fs22 = await import("fs/promises");
-  const path27 = await import("path");
-  await fs22.mkdir(outputDir, { recursive: true });
+  const fs23 = await import("fs/promises");
+  const path28 = await import("path");
+  await fs23.mkdir(outputDir, { recursive: true });
   for (const manifest of manifests) {
-    const filePath = path27.join(outputDir, manifest.filename);
-    await fs22.writeFile(filePath, manifest.content, "utf-8");
+    const filePath = path28.join(outputDir, manifest.filename);
+    await fs23.writeFile(filePath, manifest.content, "utf-8");
   }
 }
 
 // src/commands/dev/dev.ts
 init_plugin_loader_service();
+
+// src/services/local-dev.service.ts
+import { spawn as spawn6 } from "child_process";
+import chalk18 from "chalk";
+import ora8 from "ora";
+import * as path22 from "path";
+import * as fs19 from "fs/promises";
+var COLORS = [
+  chalk18.cyan,
+  chalk18.magenta,
+  chalk18.yellow,
+  chalk18.green,
+  chalk18.blue,
+  chalk18.red
+];
+var LocalPortAllocator = class {
+  functionPort = 8081;
+  uiPort = 3e3;
+  containerPort = 9e3;
+  nextFunctionPort() {
+    return this.functionPort++;
+  }
+  nextUiPort() {
+    return this.uiPort++;
+  }
+  nextContainerPort() {
+    return this.containerPort++;
+  }
+};
+function collectServices(config, projectRoot) {
+  const services = [];
+  const portAllocator = new LocalPortAllocator();
+  let colorIndex = 0;
+  for (const network of config.project.networks || []) {
+    for (const func of network.functions || []) {
+      const sourceDir = func.sourceDir?.replace(/^\.\//, "") || `functions/${func.name}`;
+      services.push({
+        name: func.name,
+        type: "function",
+        sourceDir: path22.join(projectRoot, sourceDir),
+        port: portAllocator.nextFunctionPort(),
+        color: COLORS[colorIndex++ % COLORS.length]
+      });
+    }
+    for (const ui of network.uis || []) {
+      const sourceDir = ui.sourceDir?.replace(/^\.\//, "") || `apps/${ui.name}`;
+      services.push({
+        name: ui.name,
+        type: "ui",
+        sourceDir: path22.join(projectRoot, sourceDir),
+        port: portAllocator.nextUiPort(),
+        color: COLORS[colorIndex++ % COLORS.length]
+      });
+    }
+    for (const container of network.containers || []) {
+      const sourceDir = container.sourceDir?.replace(/^\.\//, "") || `containers/${container.name}`;
+      services.push({
+        name: container.name,
+        type: "container",
+        sourceDir: path22.join(projectRoot, sourceDir),
+        port: container.port || portAllocator.nextContainerPort(),
+        color: COLORS[colorIndex++ % COLORS.length]
+      });
+    }
+  }
+  return services;
+}
+async function hasPackageJson(sourceDir) {
+  try {
+    await fs19.access(path22.join(sourceDir, "package.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasNodeModules(sourceDir) {
+  try {
+    await fs19.access(path22.join(sourceDir, "node_modules"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasDevScript(sourceDir) {
+  try {
+    const pkgPath = path22.join(sourceDir, "package.json");
+    const content = await fs19.readFile(pkgPath, "utf-8");
+    const pkg2 = JSON.parse(content);
+    return Boolean(pkg2.scripts?.dev);
+  } catch {
+    return false;
+  }
+}
+function streamWithPrefix(stream, prefix, color) {
+  stream.on("data", (data) => {
+    const lines = data.toString().split("\n").filter(Boolean);
+    for (const line of lines) {
+      console.log(`${color(`[${prefix}]`)} ${line}`);
+    }
+  });
+}
+function spawnService(service, manager) {
+  const env = {
+    ...process.env,
+    PORT: String(service.port),
+    NODE_ENV: "development",
+    // Firebase emulator connection vars
+    FIRESTORE_EMULATOR_HOST: "localhost:8080",
+    FIREBASE_AUTH_EMULATOR_HOST: "localhost:9099",
+    PUBSUB_EMULATOR_HOST: "localhost:8085"
+  };
+  const args = service.type === "ui" ? ["run", "dev", "--", "--port", String(service.port)] : ["run", "dev"];
+  const proc = spawn6("npm", args, {
+    cwd: service.sourceDir,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: true
+  });
+  if (proc.stdout) {
+    streamWithPrefix(proc.stdout, service.name, service.color);
+  }
+  if (proc.stderr) {
+    streamWithPrefix(proc.stderr, service.name, service.color);
+  }
+  proc.on("error", (err) => {
+    console.log(service.color(`[${service.name}]`), chalk18.red(`Error: ${err.message}`));
+  });
+  proc.on("exit", (code) => {
+    if (!manager.isShuttingDown) {
+      console.log(
+        service.color(`[${service.name}]`),
+        code === 0 ? chalk18.gray("Exited") : chalk18.red(`Exited with code ${code}`)
+      );
+    }
+    manager.processes.delete(service.name);
+  });
+  return proc;
+}
+async function startFirebaseEmulators(manager) {
+  const spinner = ora8("Starting Firebase emulators...").start();
+  try {
+    const proc = spawn6(
+      "firebase",
+      ["emulators:start", "--only", "firestore,auth", "--project", "demo-local"],
+      {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: true
+      }
+    );
+    const color = chalk18.yellow;
+    if (proc.stdout) {
+      streamWithPrefix(proc.stdout, "firebase", color);
+    }
+    if (proc.stderr) {
+      streamWithPrefix(proc.stderr, "firebase", color);
+    }
+    proc.on("error", () => {
+      spinner.fail("Firebase CLI not found. Skipping emulators.");
+    });
+    await new Promise((resolve7) => setTimeout(resolve7, 3e3));
+    spinner.succeed("Firebase emulators starting");
+    return proc;
+  } catch {
+    spinner.warn("Firebase emulators not available");
+    return null;
+  }
+}
+function shutdown(manager) {
+  manager.isShuttingDown = true;
+  console.log(chalk18.gray("\n  Shutting down services...\n"));
+  for (const [name, proc] of manager.processes) {
+    try {
+      console.log(chalk18.gray(`  Stopping ${name}...`));
+      proc.kill("SIGTERM");
+    } catch {
+    }
+  }
+  setTimeout(() => {
+    for (const [, proc] of manager.processes) {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+    }
+    process.exit(0);
+  }, 5e3);
+}
+async function startLocalEnvironment(options) {
+  console.log(chalk18.bold("\n  StackSolo Local Development\n"));
+  const projectRoot = process.cwd();
+  const configPath = path22.join(projectRoot, ".stacksolo", "stacksolo.config.json");
+  let config;
+  try {
+    const content = await fs19.readFile(configPath, "utf-8");
+    config = JSON.parse(content);
+  } catch {
+    console.log(chalk18.red(`  Config not found: .stacksolo/stacksolo.config.json`));
+    console.log(chalk18.gray(`  Run 'stacksolo init' first.
+`));
+    process.exit(1);
+  }
+  const services = collectServices(config, projectRoot);
+  if (services.length === 0) {
+    console.log(chalk18.yellow("  No services found in config.\n"));
+    return;
+  }
+  const validServices = [];
+  const missingDeps = [];
+  const missingDevScript = [];
+  for (const service of services) {
+    if (!await hasPackageJson(service.sourceDir)) {
+      console.log(chalk18.yellow(`  Warning: ${service.name} has no package.json at ${service.sourceDir}, skipping`));
+      continue;
+    }
+    if (!await hasDevScript(service.sourceDir)) {
+      missingDevScript.push(service);
+      continue;
+    }
+    validServices.push(service);
+    if (!await hasNodeModules(service.sourceDir)) {
+      missingDeps.push(service);
+    }
+  }
+  if (missingDevScript.length > 0) {
+    console.log(chalk18.red('\n  Error: Some services are missing "dev" script in package.json:\n'));
+    for (const svc of missingDevScript) {
+      console.log(chalk18.red(`    \u2717 ${svc.name}`));
+      console.log(chalk18.gray(`      Add a "dev" script to ${path22.relative(projectRoot, svc.sourceDir)}/package.json`));
+    }
+    console.log(chalk18.gray("\n  See: https://stacksolo.dev/reference/cli/#local-mode---local\n"));
+  }
+  if (validServices.length === 0) {
+    console.log(chalk18.yellow("  No runnable services found.\n"));
+    console.log(chalk18.gray("  Run `stacksolo scaffold` to generate service code.\n"));
+    return;
+  }
+  if (missingDeps.length > 0) {
+    console.log(chalk18.yellow("\n  Warning: Some services are missing node_modules:"));
+    for (const svc of missingDeps) {
+      console.log(chalk18.yellow(`    \u2022 ${svc.name}: Run \`cd ${path22.relative(projectRoot, svc.sourceDir)} && npm install\``));
+    }
+    console.log(chalk18.gray("\n  Or run: stacksolo install\n"));
+  }
+  const manager = {
+    processes: /* @__PURE__ */ new Map(),
+    services: validServices,
+    isShuttingDown: false
+  };
+  if (options.includeEmulators !== false) {
+    const emulatorProc = await startFirebaseEmulators(manager);
+    if (emulatorProc) {
+      manager.processes.set("firebase-emulator", emulatorProc);
+    }
+  }
+  const spinner = ora8("Starting services...").start();
+  for (const service of validServices) {
+    const proc = spawnService(service, manager);
+    if (proc) {
+      manager.processes.set(service.name, proc);
+    }
+  }
+  spinner.succeed(`Started ${validServices.length} service(s)`);
+  console.log(chalk18.bold("\n  Services running:\n"));
+  for (const service of validServices) {
+    const url = `http://localhost:${service.port}`;
+    console.log(`    ${service.color("\u25CF")} ${service.name.padEnd(20)} ${chalk18.cyan(url)}`);
+  }
+  if (options.includeEmulators !== false) {
+    console.log(chalk18.bold("\n  Emulators:\n"));
+    console.log(`    ${chalk18.yellow("\u25CF")} Firebase UI          ${chalk18.cyan("http://localhost:4000")}`);
+    console.log(`    ${chalk18.yellow("\u25CF")} Firestore            ${chalk18.gray("localhost:8080")}`);
+    console.log(`    ${chalk18.yellow("\u25CF")} Firebase Auth        ${chalk18.gray("localhost:9099")}`);
+  }
+  console.log(chalk18.bold("\n  Commands:\n"));
+  console.log(chalk18.gray("    Press Ctrl+C to stop all services"));
+  console.log("");
+  process.on("SIGINT", () => shutdown(manager));
+  process.on("SIGTERM", () => shutdown(manager));
+  await new Promise(() => {
+  });
+}
+
+// src/commands/dev/dev.ts
 function getKernelConfig(config) {
   if (config.project.kernel) {
     return {
@@ -16948,8 +17231,14 @@ var webAdminProcess = null;
 var isShuttingDown = false;
 var K8S_OUTPUT_DIR = ".stacksolo/k8s";
 var CONFIG_FILE = ".stacksolo/stacksolo.config.json";
-var devCommand = new Command17("dev").description("Start local Kubernetes development environment").option("--stop", "Stop and tear down the environment").option("--status", "Show status of running pods with health").option("--health", "Check health of all services").option("--ports", "Show port-forward status").option("--restart [service]", "Restart port-forwards or specific service pod").option("--service-names", "List service names for use with other commands").option("--routes", "Show gateway routes and services").option("--describe [resource]", "Describe K8s resources (pods, services, all)").option("--logs [service]", "Tail logs (all pods or specific service)").option("--rebuild", "Force regenerate manifests before starting").option("--no-emulators", "Skip Firebase/Pub/Sub emulators").action(async (options) => {
+var devCommand = new Command17("dev").description("Start local development environment").option("--local", "Run services locally without Docker/K8s").option("--stop", "Stop and tear down the environment").option("--status", "Show status of running pods with health").option("--health", "Check health of all services").option("--ports", "Show port-forward status").option("--restart [service]", "Restart port-forwards or specific service pod").option("--service-names", "List service names for use with other commands").option("--routes", "Show gateway routes and services").option("--describe [resource]", "Describe K8s resources (pods, services, all)").option("--logs [service]", "Tail logs (all pods or specific service)").option("--rebuild", "Force regenerate manifests before starting").option("--no-emulators", "Skip Firebase/Pub/Sub emulators").action(async (options) => {
   try {
+    if (options.local) {
+      await startLocalEnvironment({
+        includeEmulators: options.emulators !== false
+      });
+      return;
+    }
     if (options.stop) {
       await stopEnvironment();
       return;
@@ -16994,38 +17283,38 @@ var devCommand = new Command17("dev").description("Start local Kubernetes develo
       includeEmulators: options.emulators !== false
     });
   } catch (error) {
-    console.error(chalk18.red(`
+    console.error(chalk19.red(`
   Error: ${error instanceof Error ? error.message : error}
 `));
     process.exit(1);
   }
 });
 async function checkPrerequisites() {
-  const spinner = ora8("Checking prerequisites...").start();
+  const spinner = ora9("Checking prerequisites...").start();
   try {
     execSync2("kubectl version --client --short 2>/dev/null || kubectl version --client", {
       stdio: "pipe"
     });
   } catch {
     spinner.fail("kubectl not found");
-    console.log(chalk18.gray("\n  Install OrbStack: brew install orbstack"));
-    console.log(chalk18.gray("  Or install kubectl: brew install kubectl\n"));
+    console.log(chalk19.gray("\n  Install OrbStack: brew install orbstack"));
+    console.log(chalk19.gray("  Or install kubectl: brew install kubectl\n"));
     throw new Error("kubectl is required but not found");
   }
   try {
     execSync2("kubectl cluster-info 2>/dev/null", { stdio: "pipe" });
   } catch {
     spinner.fail("Kubernetes cluster not available");
-    console.log(chalk18.gray("\n  If using OrbStack, enable Kubernetes in preferences"));
-    console.log(chalk18.gray("  Settings \u2192 Kubernetes \u2192 Enable Kubernetes\n"));
+    console.log(chalk19.gray("\n  If using OrbStack, enable Kubernetes in preferences"));
+    console.log(chalk19.gray("  Settings \u2192 Kubernetes \u2192 Enable Kubernetes\n"));
     throw new Error("Kubernetes cluster not available");
   }
   spinner.succeed("Prerequisites met");
 }
 async function loadConfig2() {
-  const configPath = path22.resolve(process.cwd(), CONFIG_FILE);
+  const configPath = path23.resolve(process.cwd(), CONFIG_FILE);
   try {
-    const content = await fs19.readFile(configPath, "utf-8");
+    const content = await fs20.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -17043,9 +17332,9 @@ async function validateSourceDirs(config) {
     const kernelService = getPluginService(validateKernelConfig.serviceName);
     const pluginSourcePath = kernelService ? getServiceSourcePath(kernelService) : null;
     if (!pluginSourcePath) {
-      const kernelDir = path22.join(projectRoot, "containers", validateKernelConfig.name);
+      const kernelDir = path23.join(projectRoot, "containers", validateKernelConfig.name);
       try {
-        await fs19.access(kernelDir);
+        await fs20.access(kernelDir);
       } catch {
         warnings.push(`Kernel directory not found: containers/${validateKernelConfig.name}/`);
       }
@@ -17053,17 +17342,17 @@ async function validateSourceDirs(config) {
   }
   for (const network of config.project.networks || []) {
     for (const func of network.functions || []) {
-      const funcDir = path22.join(projectRoot, "functions", func.name);
+      const funcDir = path23.join(projectRoot, "functions", func.name);
       try {
-        await fs19.access(funcDir);
+        await fs20.access(funcDir);
       } catch {
         warnings.push(`Function directory not found: functions/${func.name}/`);
       }
     }
     for (const ui of network.uis || []) {
-      const uiDir = path22.join(projectRoot, "ui", ui.name);
+      const uiDir = path23.join(projectRoot, "ui", ui.name);
       try {
-        await fs19.access(uiDir);
+        await fs20.access(uiDir);
       } catch {
         warnings.push(`UI directory not found: ui/${ui.name}/`);
       }
@@ -17077,7 +17366,7 @@ async function startWebAdmin(config) {
     return null;
   }
   const port = webAdmin.port || 3e3;
-  const spinner = ora8(`Starting web admin on port ${port}...`).start();
+  const spinner = ora9(`Starting web admin on port ${port}...`).start();
   try {
     const webAdminService = getPluginService("web-admin");
     let appDir = null;
@@ -17088,9 +17377,9 @@ async function startWebAdmin(config) {
       }
     }
     if (!appDir) {
-      const nodeModulesPath = path22.join(process.cwd(), "node_modules", "@stacksolo", "plugin-web-admin", "app");
+      const nodeModulesPath = path23.join(process.cwd(), "node_modules", "@stacksolo", "plugin-web-admin", "app");
       try {
-        await fs19.access(nodeModulesPath);
+        await fs20.access(nodeModulesPath);
         appDir = nodeModulesPath;
       } catch {
       }
@@ -17099,16 +17388,16 @@ async function startWebAdmin(config) {
       spinner.warn("Web admin not found - install @stacksolo/plugin-web-admin or add to plugins");
       return null;
     }
-    const buildDir = path22.join(appDir, "build");
+    const buildDir = path23.join(appDir, "build");
     let useDevMode = false;
     try {
-      await fs19.access(buildDir);
+      await fs20.access(buildDir);
     } catch {
       useDevMode = true;
     }
     const projectPath = process.cwd();
     if (useDevMode) {
-      webAdminProcess = spawn6("npm", ["run", "dev", "--", "--port", String(port)], {
+      webAdminProcess = spawn7("npm", ["run", "dev", "--", "--port", String(port)], {
         cwd: appDir,
         env: {
           ...process.env,
@@ -17119,7 +17408,7 @@ async function startWebAdmin(config) {
         detached: false
       });
     } else {
-      webAdminProcess = spawn6("node", ["build"], {
+      webAdminProcess = spawn7("node", ["build"], {
         cwd: appDir,
         env: {
           ...process.env,
@@ -17154,20 +17443,20 @@ async function buildKernelImage(config) {
     const sourcePath = getServiceSourcePath(kernelService);
     if (sourcePath) {
       kernelDir = sourcePath;
-      console.log(chalk18.gray(`  Using ${kernelType} kernel from plugin: ${kernelDir}`));
+      console.log(chalk19.gray(`  Using ${kernelType} kernel from plugin: ${kernelDir}`));
     } else {
-      kernelDir = path22.join(process.cwd(), "containers", kernelName);
+      kernelDir = path23.join(process.cwd(), "containers", kernelName);
     }
   } else {
-    kernelDir = path22.join(process.cwd(), "containers", kernelName);
+    kernelDir = path23.join(process.cwd(), "containers", kernelName);
   }
   try {
-    await fs19.access(kernelDir);
+    await fs20.access(kernelDir);
   } catch {
-    console.log(chalk18.gray(`  ${kernelType.toUpperCase()} kernel directory not found: ${kernelDir}`));
+    console.log(chalk19.gray(`  ${kernelType.toUpperCase()} kernel directory not found: ${kernelDir}`));
     return false;
   }
-  const spinner = ora8(`Building ${kernelType} kernel image from ${kernelDir}...`).start();
+  const spinner = ora9(`Building ${kernelType} kernel image from ${kernelDir}...`).start();
   try {
     execSync2("npm install", { cwd: kernelDir, stdio: "pipe" });
     execSync2("npm run build", { cwd: kernelDir, stdio: "pipe" });
@@ -17176,32 +17465,32 @@ async function buildKernelImage(config) {
     return true;
   } catch (error) {
     spinner.fail(`Failed to build ${kernelType} kernel image`);
-    console.log(chalk18.gray(`    Error: ${error instanceof Error ? error.message : error}`));
+    console.log(chalk19.gray(`    Error: ${error instanceof Error ? error.message : error}`));
     return false;
   }
 }
 async function startEnvironment(options) {
-  console.log(chalk18.bold("\n  StackSolo Dev Environment\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev Environment\n"));
   await checkPrerequisites();
-  const spinner = ora8("Loading configuration...").start();
+  const spinner = ora9("Loading configuration...").start();
   const config = await loadConfig2();
   const projectName = config.project.name;
   const namespace = sanitizeNamespaceName(projectName);
   spinner.succeed(`Project: ${projectName}`);
-  const pluginSpinner = ora8("Loading plugins...").start();
+  const pluginSpinner = ora9("Loading plugins...").start();
   await loadPlugins(config.project.plugins);
   pluginSpinner.succeed("Plugins loaded");
   const warnings = await validateSourceDirs(config);
   if (warnings.length > 0) {
-    console.log(chalk18.yellow("\n  Warnings:"));
+    console.log(chalk19.yellow("\n  Warnings:"));
     for (const warning of warnings) {
-      console.log(chalk18.yellow(`    \u2022 ${warning}`));
+      console.log(chalk19.yellow(`    \u2022 ${warning}`));
     }
     console.log("");
   }
   await buildKernelImage(config);
-  const genSpinner = ora8("Generating Kubernetes manifests...").start();
-  const outputDir = path22.resolve(process.cwd(), K8S_OUTPUT_DIR);
+  const genSpinner = ora9("Generating Kubernetes manifests...").start();
+  const outputDir = path23.resolve(process.cwd(), K8S_OUTPUT_DIR);
   const result = generateK8sManifests({
     config,
     projectRoot: process.cwd(),
@@ -17211,10 +17500,10 @@ async function startEnvironment(options) {
   genSpinner.succeed(`Generated ${result.manifests.length} manifests to ${K8S_OUTPUT_DIR}/`);
   if (result.warnings.length > 0) {
     for (const warning of result.warnings) {
-      console.log(chalk18.yellow(`    \u26A0 ${warning}`));
+      console.log(chalk19.yellow(`    \u26A0 ${warning}`));
     }
   }
-  const applySpinner = ora8("Applying Kubernetes manifests...").start();
+  const applySpinner = ora9("Applying Kubernetes manifests...").start();
   try {
     execSync2(`kubectl apply -f ${outputDir}/namespace.yaml`, { stdio: "pipe" });
     execSync2(`kubectl apply -f ${outputDir}`, { stdio: "pipe" });
@@ -17223,7 +17512,7 @@ async function startEnvironment(options) {
     applySpinner.fail("Failed to apply manifests");
     throw error;
   }
-  const readySpinner = ora8("Waiting for pods to be ready...").start();
+  const readySpinner = ora9("Waiting for pods to be ready...").start();
   try {
     execSync2(
       `kubectl wait --for=condition=ready pod --all -n ${namespace} --timeout=120s`,
@@ -17233,7 +17522,7 @@ async function startEnvironment(options) {
   } catch {
     readySpinner.warn("Some pods may not be ready yet");
   }
-  const portForwardSpinner = ora8("Setting up port forwarding...").start();
+  const portForwardSpinner = ora9("Setting up port forwarding...").start();
   const portMappings = await setupPortForwarding(namespace, config);
   portForwardSpinner.succeed("Port forwarding active");
   const webAdminPort = await startWebAdmin(config);
@@ -17246,7 +17535,7 @@ async function startEnvironment(options) {
       protocol: "http"
     });
   }
-  console.log(chalk18.bold("\n  Services running:\n"));
+  console.log(chalk19.bold("\n  Services running:\n"));
   try {
     const podStatus = execSync2(
       `kubectl get pods -n ${namespace} -o wide --no-headers`,
@@ -17256,25 +17545,25 @@ async function startEnvironment(options) {
       const parts = line.split(/\s+/);
       const name = parts[0];
       const status = parts[2];
-      const statusColor = status === "Running" ? chalk18.green : chalk18.yellow;
+      const statusColor = status === "Running" ? chalk19.green : chalk19.yellow;
       console.log(`    ${statusColor("\u25CF")} ${name.padEnd(30)} ${statusColor(status)}`);
     }
   } catch {
-    console.log(chalk18.gray("    Unable to get pod status"));
+    console.log(chalk19.gray("    Unable to get pod status"));
   }
-  console.log(chalk18.bold("\n  Access:\n"));
+  console.log(chalk19.bold("\n  Access:\n"));
   for (const mapping of portMappings) {
     const url = mapping.protocol === "http" ? `http://localhost:${mapping.localPort}` : `localhost:${mapping.localPort}`;
-    console.log(`    ${chalk18.cyan(mapping.name.padEnd(20))} ${url}`);
+    console.log(`    ${chalk19.cyan(mapping.name.padEnd(20))} ${url}`);
   }
-  console.log(chalk18.bold("\n  Commands:\n"));
-  console.log(chalk18.gray("    stacksolo dev --logs       Tail all logs"));
-  console.log(chalk18.gray("    stacksolo dev --status     Show pod status"));
-  console.log(chalk18.gray("    stacksolo dev --stop       Stop environment"));
+  console.log(chalk19.bold("\n  Commands:\n"));
+  console.log(chalk19.gray("    stacksolo dev --logs       Tail all logs"));
+  console.log(chalk19.gray("    stacksolo dev --status     Show pod status"));
+  console.log(chalk19.gray("    stacksolo dev --stop       Stop environment"));
   console.log("");
   const cleanup = async () => {
     isShuttingDown = true;
-    console.log(chalk18.gray("\n  Shutting down...\n"));
+    console.log(chalk19.gray("\n  Shutting down...\n"));
     if (webAdminProcess) {
       try {
         webAdminProcess.kill("SIGTERM");
@@ -17289,20 +17578,20 @@ async function startEnvironment(options) {
     }
     try {
       execSync2(`kubectl delete namespace ${namespace}`, { stdio: "pipe" });
-      console.log(chalk18.green("  Environment stopped\n"));
+      console.log(chalk19.green("  Environment stopped\n"));
     } catch {
     }
     process.exit(0);
   };
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
-  console.log(chalk18.gray("  Press Ctrl+C to stop\n"));
+  console.log(chalk19.gray("  Press Ctrl+C to stop\n"));
   await new Promise(() => {
   });
 }
 function startPortForwardWithRestart(namespace, service, localPort, targetPort, _name) {
   const startForward = () => {
-    const proc = spawn6(
+    const proc = spawn7(
       "kubectl",
       ["port-forward", "-n", namespace, `svc/${service}`, `${localPort}:${targetPort}`],
       { stdio: "pipe", detached: false }
@@ -17420,18 +17709,18 @@ async function setupPortForwarding(namespace, config) {
   return portMappings;
 }
 async function stopEnvironment() {
-  console.log(chalk18.bold("\n  Stopping StackSolo Dev Environment\n"));
+  console.log(chalk19.bold("\n  Stopping StackSolo Dev Environment\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   const projectName = config.project.name;
-  const nsSpinner = ora8(`Deleting namespace ${namespace}...`).start();
+  const nsSpinner = ora9(`Deleting namespace ${namespace}...`).start();
   try {
     execSync2(`kubectl delete namespace ${namespace}`, { stdio: "pipe" });
     nsSpinner.succeed("Namespace deleted");
   } catch {
     nsSpinner.warn("Namespace may not exist or already deleted");
   }
-  const imgSpinner = ora8("Cleaning up Docker images...").start();
+  const imgSpinner = ora9("Cleaning up Docker images...").start();
   try {
     const images = execSync2(
       `docker images --format "{{.Repository}}:{{.Tag}}" | grep -E "^(${namespace}-|${projectName}-)" || true`,
@@ -17455,149 +17744,149 @@ async function stopEnvironment() {
   console.log("");
 }
 async function showStatus() {
-  console.log(chalk18.bold("\n  StackSolo Dev Status\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev Status\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   try {
-    console.log(chalk18.bold("  Pods:\n"));
+    console.log(chalk19.bold("  Pods:\n"));
     const pods = execSync2(`kubectl get pods -n ${namespace} -o wide`, { encoding: "utf-8" });
     console.log(pods.split("\n").map((l) => "    " + l).join("\n"));
-    console.log(chalk18.bold("\n  Services:\n"));
+    console.log(chalk19.bold("\n  Services:\n"));
     const services = execSync2(`kubectl get services -n ${namespace}`, { encoding: "utf-8" });
     console.log(services.split("\n").map((l) => "    " + l).join("\n"));
-    console.log(chalk18.bold("\n  Ingress:\n"));
+    console.log(chalk19.bold("\n  Ingress:\n"));
     const ingress = execSync2(`kubectl get ingress -n ${namespace}`, { encoding: "utf-8" });
     console.log(ingress.split("\n").map((l) => "    " + l).join("\n"));
   } catch {
-    console.log(chalk18.yellow(`  No resources found in namespace ${namespace}`));
-    console.log(chalk18.gray('  Run "stacksolo dev" to start the environment\n'));
+    console.log(chalk19.yellow(`  No resources found in namespace ${namespace}`));
+    console.log(chalk19.gray('  Run "stacksolo dev" to start the environment\n'));
   }
   console.log("");
 }
 async function showRoutes() {
-  console.log(chalk18.bold("\n  StackSolo Gateway Routes\n"));
+  console.log(chalk19.bold("\n  StackSolo Gateway Routes\n"));
   const config = await loadConfig2();
   const kernelConfig = getKernelConfig(config);
   if (kernelConfig) {
     const label = kernelConfig.type === "nats" ? "Kernel (NATS)" : "Kernel (GCP)";
     const detail = kernelConfig.type === "nats" ? `Source: containers/${kernelConfig.name}/` : "Type: GCP-native (Cloud Run + Pub/Sub)";
-    console.log(chalk18.bold(`  ${label}:
+    console.log(chalk19.bold(`  ${label}:
 `));
-    console.log(`    ${chalk18.cyan("\u25CF")} ${kernelConfig.name}`);
-    console.log(chalk18.gray(`      ${detail}`));
+    console.log(`    ${chalk19.cyan("\u25CF")} ${kernelConfig.name}`);
+    console.log(chalk19.gray(`      ${detail}`));
     console.log("");
   }
   for (const network of config.project.networks || []) {
-    console.log(chalk18.bold(`  Network: ${network.name}
+    console.log(chalk19.bold(`  Network: ${network.name}
 `));
     if (network.functions && network.functions.length > 0) {
-      console.log(chalk18.bold("    Functions:"));
+      console.log(chalk19.bold("    Functions:"));
       for (const func of network.functions) {
-        console.log(`      ${chalk18.green("\u03BB")} ${func.name}`);
-        console.log(chalk18.gray(`        Source: functions/${func.name}/`));
+        console.log(`      ${chalk19.green("\u03BB")} ${func.name}`);
+        console.log(chalk19.gray(`        Source: functions/${func.name}/`));
       }
       console.log("");
     }
     if (network.containers && network.containers.length > 0) {
-      console.log(chalk18.bold("    Containers:"));
+      console.log(chalk19.bold("    Containers:"));
       for (const container of network.containers) {
-        console.log(`      ${chalk18.blue("\u25FC")} ${container.name}`);
-        console.log(chalk18.gray(`        Source: containers/${container.name}/`));
+        console.log(`      ${chalk19.blue("\u25FC")} ${container.name}`);
+        console.log(chalk19.gray(`        Source: containers/${container.name}/`));
       }
       console.log("");
     }
     if (network.uis && network.uis.length > 0) {
-      console.log(chalk18.bold("    UIs:"));
+      console.log(chalk19.bold("    UIs:"));
       for (const ui of network.uis) {
-        console.log(`      ${chalk18.magenta("\u25C6")} ${ui.name}`);
-        console.log(chalk18.gray(`        Source: ui/${ui.name}/`));
+        console.log(`      ${chalk19.magenta("\u25C6")} ${ui.name}`);
+        console.log(chalk19.gray(`        Source: ui/${ui.name}/`));
       }
       console.log("");
     }
     if (network.loadBalancer?.routes && network.loadBalancer.routes.length > 0) {
-      console.log(chalk18.bold("    Gateway Routes:"));
-      console.log(chalk18.gray("      Path                    \u2192 Backend"));
-      console.log(chalk18.gray("      " + "\u2500".repeat(50)));
+      console.log(chalk19.bold("    Gateway Routes:"));
+      console.log(chalk19.gray("      Path                    \u2192 Backend"));
+      console.log(chalk19.gray("      " + "\u2500".repeat(50)));
       for (const route of network.loadBalancer.routes) {
         const pathPadded = route.path.padEnd(24);
-        console.log(`      ${chalk18.yellow(pathPadded)} \u2192 ${route.backend}`);
+        console.log(`      ${chalk19.yellow(pathPadded)} \u2192 ${route.backend}`);
       }
       console.log("");
     }
   }
-  console.log(chalk18.bold("  Emulators:\n"));
-  console.log(`    ${chalk18.yellow("Firebase UI")}      http://localhost:4000`);
-  console.log(`    ${chalk18.yellow("Firestore")}        localhost:8080`);
-  console.log(`    ${chalk18.yellow("Firebase Auth")}    localhost:9099`);
-  console.log(`    ${chalk18.yellow("Pub/Sub")}          localhost:8085`);
+  console.log(chalk19.bold("  Emulators:\n"));
+  console.log(`    ${chalk19.yellow("Firebase UI")}      http://localhost:4000`);
+  console.log(`    ${chalk19.yellow("Firestore")}        localhost:8080`);
+  console.log(`    ${chalk19.yellow("Firebase Auth")}    localhost:9099`);
+  console.log(`    ${chalk19.yellow("Pub/Sub")}          localhost:8085`);
   console.log("");
-  console.log(chalk18.bold("  Local Access:\n"));
-  console.log(`    ${chalk18.cyan("Gateway:")}          http://localhost:8000`);
+  console.log(chalk19.bold("  Local Access:\n"));
+  console.log(`    ${chalk19.cyan("Gateway:")}          http://localhost:8000`);
   const routesKernelConfig = getKernelConfig(config);
   if (routesKernelConfig) {
     const label = routesKernelConfig.type === "nats" ? "Kernel HTTP" : "GCP Kernel";
-    console.log(`    ${chalk18.cyan(`${label}:`)}${" ".repeat(14 - label.length)}http://localhost:${routesKernelConfig.httpPort}`);
+    console.log(`    ${chalk19.cyan(`${label}:`)}${" ".repeat(14 - label.length)}http://localhost:${routesKernelConfig.httpPort}`);
     if (routesKernelConfig.natsPort) {
-      console.log(`    ${chalk18.cyan("Kernel NATS:")}      localhost:${routesKernelConfig.natsPort}`);
+      console.log(`    ${chalk19.cyan("Kernel NATS:")}      localhost:${routesKernelConfig.natsPort}`);
     }
   }
   console.log("");
 }
 async function describeResources(resource) {
-  console.log(chalk18.bold("\n  StackSolo Dev - Resource Details\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev - Resource Details\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   try {
     const indent = (text) => text.split("\n").map((l) => "    " + l).join("\n");
     if (resource === "all" || resource === "pods") {
-      console.log(chalk18.bold.cyan("  \u2550\u2550\u2550 Pods \u2550\u2550\u2550\n"));
+      console.log(chalk19.bold.cyan("  \u2550\u2550\u2550 Pods \u2550\u2550\u2550\n"));
       const pods = execSync2(`kubectl describe pods -n ${namespace}`, { encoding: "utf-8" });
       console.log(indent(pods));
     }
     if (resource === "all" || resource === "services") {
-      console.log(chalk18.bold.cyan("\n  \u2550\u2550\u2550 Services \u2550\u2550\u2550\n"));
+      console.log(chalk19.bold.cyan("\n  \u2550\u2550\u2550 Services \u2550\u2550\u2550\n"));
       const services = execSync2(`kubectl describe services -n ${namespace}`, { encoding: "utf-8" });
       console.log(indent(services));
     }
     if (resource === "all" || resource === "deployments") {
-      console.log(chalk18.bold.cyan("\n  \u2550\u2550\u2550 Deployments \u2550\u2550\u2550\n"));
+      console.log(chalk19.bold.cyan("\n  \u2550\u2550\u2550 Deployments \u2550\u2550\u2550\n"));
       const deployments = execSync2(`kubectl describe deployments -n ${namespace}`, { encoding: "utf-8" });
       console.log(indent(deployments));
     }
     if (resource === "all" || resource === "ingress") {
-      console.log(chalk18.bold.cyan("\n  \u2550\u2550\u2550 Ingress \u2550\u2550\u2550\n"));
+      console.log(chalk19.bold.cyan("\n  \u2550\u2550\u2550 Ingress \u2550\u2550\u2550\n"));
       try {
         const ingress = execSync2(`kubectl describe ingress -n ${namespace}`, { encoding: "utf-8" });
         console.log(indent(ingress));
       } catch {
-        console.log(chalk18.gray("    No ingress resources found"));
+        console.log(chalk19.gray("    No ingress resources found"));
       }
     }
     if (resource === "all" || resource === "configmaps") {
-      console.log(chalk18.bold.cyan("\n  \u2550\u2550\u2550 ConfigMaps \u2550\u2550\u2550\n"));
+      console.log(chalk19.bold.cyan("\n  \u2550\u2550\u2550 ConfigMaps \u2550\u2550\u2550\n"));
       const configmaps = execSync2(`kubectl describe configmaps -n ${namespace}`, { encoding: "utf-8" });
       console.log(indent(configmaps));
     }
     if (!["all", "pods", "services", "deployments", "ingress", "configmaps"].includes(resource)) {
-      console.log(chalk18.bold.cyan(`  \u2550\u2550\u2550 ${resource} \u2550\u2550\u2550
+      console.log(chalk19.bold.cyan(`  \u2550\u2550\u2550 ${resource} \u2550\u2550\u2550
 `));
       try {
         const podDesc = execSync2(`kubectl describe pod/${resource} -n ${namespace} 2>/dev/null || kubectl describe deployment/${resource} -n ${namespace} 2>/dev/null || kubectl describe service/${resource} -n ${namespace}`, { encoding: "utf-8" });
         console.log(indent(podDesc));
       } catch {
-        console.log(chalk18.yellow(`    Resource '${resource}' not found`));
-        console.log(chalk18.gray("\n    Available options: all, pods, services, deployments, ingress, configmaps"));
-        console.log(chalk18.gray("    Or specify a resource name like: --describe api"));
+        console.log(chalk19.yellow(`    Resource '${resource}' not found`));
+        console.log(chalk19.gray("\n    Available options: all, pods, services, deployments, ingress, configmaps"));
+        console.log(chalk19.gray("    Or specify a resource name like: --describe api"));
       }
     }
   } catch {
-    console.log(chalk18.yellow(`  No resources found in namespace ${namespace}`));
-    console.log(chalk18.gray('  Run "stacksolo dev" to start the environment\n'));
+    console.log(chalk19.yellow(`  No resources found in namespace ${namespace}`));
+    console.log(chalk19.gray('  Run "stacksolo dev" to start the environment\n'));
   }
   console.log("");
 }
 async function checkHealth() {
-  console.log(chalk18.bold("\n  StackSolo Dev - Health Check\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev - Health Check\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   const healthChecks = [];
@@ -17618,7 +17907,7 @@ async function checkHealth() {
       functionPort++;
     }
   }
-  console.log(chalk18.bold("  Pod Status:\n"));
+  console.log(chalk19.bold("  Pod Status:\n"));
   try {
     const podOutput = execSync2(
       `kubectl get pods -n ${namespace} -o jsonpath='{range .items[*]}{.metadata.name}|{.status.phase}|{.status.conditions[?(@.type=="Ready")].status}{"\\n"}{end}'`,
@@ -17628,16 +17917,16 @@ async function checkHealth() {
       if (!line) continue;
       const [name, phase, ready] = line.split("|");
       const isHealthy = phase === "Running" && ready === "True";
-      const icon = isHealthy ? chalk18.green("\u2713") : chalk18.red("\u2717");
-      const status = isHealthy ? chalk18.green("Healthy") : chalk18.yellow(phase);
+      const icon = isHealthy ? chalk19.green("\u2713") : chalk19.red("\u2717");
+      const status = isHealthy ? chalk19.green("Healthy") : chalk19.yellow(phase);
       console.log(`    ${icon} ${name.padEnd(40)} ${status}`);
     }
   } catch {
-    console.log(chalk18.yellow("    Unable to get pod status"));
+    console.log(chalk19.yellow("    Unable to get pod status"));
   }
-  console.log(chalk18.bold("\n  HTTP Endpoints:\n"));
+  console.log(chalk19.bold("\n  HTTP Endpoints:\n"));
   for (const check of healthChecks) {
-    const spinner = ora8({ text: `Checking ${check.name}...`, indent: 4 }).start();
+    const spinner = ora9({ text: `Checking ${check.name}...`, indent: 4 }).start();
     try {
       const response = await Promise.race([
         fetch(`http://localhost:${check.port}${check.path}`),
@@ -17646,27 +17935,27 @@ async function checkHealth() {
         )
       ]);
       if (response.ok) {
-        spinner.succeed(`${check.name.padEnd(25)} ${chalk18.green("OK")} (port ${check.port})`);
+        spinner.succeed(`${check.name.padEnd(25)} ${chalk19.green("OK")} (port ${check.port})`);
       } else {
-        spinner.warn(`${check.name.padEnd(25)} ${chalk18.yellow(`HTTP ${response.status}`)} (port ${check.port})`);
+        spinner.warn(`${check.name.padEnd(25)} ${chalk19.yellow(`HTTP ${response.status}`)} (port ${check.port})`);
       }
     } catch (error) {
       const errMsg = error instanceof Error ? error.message : "Unknown error";
       if (errMsg.includes("ECONNREFUSED")) {
-        spinner.fail(`${check.name.padEnd(25)} ${chalk18.red("Connection refused")} (port ${check.port})`);
+        spinner.fail(`${check.name.padEnd(25)} ${chalk19.red("Connection refused")} (port ${check.port})`);
       } else if (errMsg.includes("Timeout")) {
-        spinner.fail(`${check.name.padEnd(25)} ${chalk18.red("Timeout")} (port ${check.port})`);
+        spinner.fail(`${check.name.padEnd(25)} ${chalk19.red("Timeout")} (port ${check.port})`);
       } else {
-        spinner.fail(`${check.name.padEnd(25)} ${chalk18.red(errMsg)} (port ${check.port})`);
+        spinner.fail(`${check.name.padEnd(25)} ${chalk19.red(errMsg)} (port ${check.port})`);
       }
     }
   }
-  console.log(chalk18.bold("\n  Tip:\n"));
-  console.log(chalk18.gray('    If ports show "Connection refused", try: stacksolo dev --restart'));
-  console.log(chalk18.gray("    This will restart all port-forwards\n"));
+  console.log(chalk19.bold("\n  Tip:\n"));
+  console.log(chalk19.gray('    If ports show "Connection refused", try: stacksolo dev --restart'));
+  console.log(chalk19.gray("    This will restart all port-forwards\n"));
 }
 async function showPorts() {
-  console.log(chalk18.bold("\n  StackSolo Dev - Port Forward Status\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev - Port Forward Status\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   const expectedPorts = [];
@@ -17702,9 +17991,9 @@ async function showPorts() {
       uiPort++;
     }
   }
-  console.log(chalk18.bold("  Expected Port Forwards:\n"));
-  console.log(chalk18.gray("    Name                          Port     Service                Status"));
-  console.log(chalk18.gray("    " + "\u2500".repeat(75)));
+  console.log(chalk19.bold("  Expected Port Forwards:\n"));
+  console.log(chalk19.gray("    Name                          Port     Service                Status"));
+  console.log(chalk19.gray("    " + "\u2500".repeat(75)));
   for (const mapping of expectedPorts) {
     let status;
     try {
@@ -17714,22 +18003,22 @@ async function showPorts() {
           (_, reject) => setTimeout(() => reject(new Error("Timeout")), 500)
         )
       ]);
-      status = chalk18.green("\u25CF Active");
+      status = chalk19.green("\u25CF Active");
     } catch (error) {
       const errMsg = error instanceof Error ? error.message : "";
       if (errMsg.includes("ECONNREFUSED")) {
-        status = chalk18.red("\u25CB Not listening");
+        status = chalk19.red("\u25CB Not listening");
       } else if (errMsg.includes("Timeout")) {
-        status = chalk18.yellow("\u25CB No response");
+        status = chalk19.yellow("\u25CB No response");
       } else {
-        status = chalk18.blue("\u25CF TCP only");
+        status = chalk19.blue("\u25CF TCP only");
       }
     }
     console.log(
       `    ${mapping.name.padEnd(30)} ${String(mapping.port).padEnd(8)} ${mapping.service.padEnd(22)} ${status}`
     );
   }
-  console.log(chalk18.bold("\n  Active Port-Forward Processes:\n"));
+  console.log(chalk19.bold("\n  Active Port-Forward Processes:\n"));
   try {
     const psOutput = execSync2(`ps aux | grep 'kubectl port-forward' | grep -v grep | grep ${namespace}`, {
       encoding: "utf-8"
@@ -17738,21 +18027,21 @@ async function showPorts() {
       for (const line of psOutput.trim().split("\n")) {
         const match = line.match(/port-forward.*svc\/([^\s]+)\s+(\d+:\d+)/);
         if (match) {
-          console.log(chalk18.gray(`    kubectl port-forward svc/${match[1]} ${match[2]}`));
+          console.log(chalk19.gray(`    kubectl port-forward svc/${match[1]} ${match[2]}`));
         }
       }
     } else {
-      console.log(chalk18.yellow("    No active port-forward processes found"));
+      console.log(chalk19.yellow("    No active port-forward processes found"));
     }
   } catch {
-    console.log(chalk18.yellow("    No active port-forward processes found"));
+    console.log(chalk19.yellow("    No active port-forward processes found"));
   }
-  console.log(chalk18.bold("\n  Commands:\n"));
-  console.log(chalk18.gray("    stacksolo dev --restart       Restart all port-forwards"));
-  console.log(chalk18.gray("    stacksolo dev --health        Check endpoint health\n"));
+  console.log(chalk19.bold("\n  Commands:\n"));
+  console.log(chalk19.gray("    stacksolo dev --restart       Restart all port-forwards"));
+  console.log(chalk19.gray("    stacksolo dev --health        Check endpoint health\n"));
 }
 async function showServiceNames() {
-  console.log(chalk18.bold("\n  StackSolo Dev - Service Names\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev - Service Names\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   const services = [];
@@ -17795,15 +18084,15 @@ async function showServiceNames() {
   if (hasGateway) {
     services.push({ name: "gateway", type: "gateway", k8sName: "gateway" });
   }
-  console.log(chalk18.gray("    Name                     Type         K8s Service Name"));
-  console.log(chalk18.gray("    " + "\u2500".repeat(60)));
+  console.log(chalk19.gray("    Name                     Type         K8s Service Name"));
+  console.log(chalk19.gray("    " + "\u2500".repeat(60)));
   for (const svc of services) {
-    const typeColor = svc.type === "kernel" ? chalk18.magenta : svc.type === "gcp-kernel" ? chalk18.magenta : svc.type === "function" ? chalk18.green : svc.type === "container" ? chalk18.blue : svc.type === "ui" ? chalk18.cyan : svc.type === "gateway" ? chalk18.yellow : chalk18.gray;
+    const typeColor = svc.type === "kernel" ? chalk19.magenta : svc.type === "gcp-kernel" ? chalk19.magenta : svc.type === "function" ? chalk19.green : svc.type === "container" ? chalk19.blue : svc.type === "ui" ? chalk19.cyan : svc.type === "gateway" ? chalk19.yellow : chalk19.gray;
     console.log(
       `    ${svc.name.padEnd(25)} ${typeColor(svc.type.padEnd(12))} ${svc.k8sName}`
     );
   }
-  console.log(chalk18.bold("\n  Running Pods:\n"));
+  console.log(chalk19.bold("\n  Running Pods:\n"));
   try {
     const pods = execSync2(`kubectl get pods -n ${namespace} --no-headers -o custom-columns=NAME:.metadata.name`, {
       encoding: "utf-8"
@@ -17811,30 +18100,30 @@ async function showServiceNames() {
     for (const pod of pods.trim().split("\n")) {
       if (pod) {
         const serviceName = pod.replace(/-[a-z0-9]+-[a-z0-9]+$/, "");
-        console.log(`    ${chalk18.gray("\u25CF")} ${serviceName.padEnd(25)} ${chalk18.gray(pod)}`);
+        console.log(`    ${chalk19.gray("\u25CF")} ${serviceName.padEnd(25)} ${chalk19.gray(pod)}`);
       }
     }
   } catch {
-    console.log(chalk18.yellow("    No pods found"));
+    console.log(chalk19.yellow("    No pods found"));
   }
-  console.log(chalk18.bold("\n  Usage:\n"));
-  console.log(chalk18.gray("    stacksolo dev --restart <name>    Restart a specific service"));
-  console.log(chalk18.gray("    stacksolo dev --logs <name>       Tail logs for a service"));
-  console.log(chalk18.gray("    stacksolo dev --describe <name>   Describe a service\n"));
+  console.log(chalk19.bold("\n  Usage:\n"));
+  console.log(chalk19.gray("    stacksolo dev --restart <name>    Restart a specific service"));
+  console.log(chalk19.gray("    stacksolo dev --logs <name>       Tail logs for a service"));
+  console.log(chalk19.gray("    stacksolo dev --describe <name>   Describe a service\n"));
 }
 async function restartService(service) {
-  console.log(chalk18.bold("\n  StackSolo Dev - Restart\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev - Restart\n"));
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
   if (service) {
-    const spinner = ora8(`Restarting pod: ${service}...`).start();
+    const spinner = ora9(`Restarting pod: ${service}...`).start();
     try {
       execSync2(
         `kubectl delete pod -n ${namespace} -l app.kubernetes.io/name=${service} --grace-period=5`,
         { stdio: "pipe" }
       );
       spinner.succeed(`Pod ${service} restarted`);
-      const waitSpinner = ora8(`Waiting for ${service} to be ready...`).start();
+      const waitSpinner = ora9(`Waiting for ${service} to be ready...`).start();
       try {
         execSync2(
           `kubectl wait --for=condition=ready pod -n ${namespace} -l app.kubernetes.io/name=${service} --timeout=60s`,
@@ -17846,19 +18135,19 @@ async function restartService(service) {
       }
     } catch (error) {
       spinner.fail(`Failed to restart ${service}`);
-      console.log(chalk18.gray(`    Error: ${error instanceof Error ? error.message : error}`));
-      console.log(chalk18.gray("\n    Available services:"));
+      console.log(chalk19.gray(`    Error: ${error instanceof Error ? error.message : error}`));
+      console.log(chalk19.gray("\n    Available services:"));
       try {
         const pods = execSync2(`kubectl get pods -n ${namespace} -o name`, { encoding: "utf-8" });
         for (const pod of pods.trim().split("\n")) {
           const podName = pod.replace("pod/", "").replace(/-[a-z0-9]+-[a-z0-9]+$/, "");
-          console.log(chalk18.gray(`      ${podName}`));
+          console.log(chalk19.gray(`      ${podName}`));
         }
       } catch {
       }
     }
   } else {
-    const killSpinner = ora8("Stopping existing port-forwards...").start();
+    const killSpinner = ora9("Stopping existing port-forwards...").start();
     try {
       execSync2(`pkill -f "kubectl port-forward.*${namespace}"`, { stdio: "pipe" });
       killSpinner.succeed("Port-forwards stopped");
@@ -17867,21 +18156,21 @@ async function restartService(service) {
     }
     await new Promise((resolve7) => setTimeout(resolve7, 500));
     console.log("");
-    const spinner = ora8("Restarting port-forwards...").start();
+    const spinner = ora9("Restarting port-forwards...").start();
     portForwardProcesses.length = 0;
     const portMappings = await setupPortForwarding(namespace, config);
     spinner.succeed("Port-forwards restarted");
-    console.log(chalk18.bold("\n  Active Forwards:\n"));
+    console.log(chalk19.bold("\n  Active Forwards:\n"));
     for (const mapping of portMappings) {
       const url = mapping.protocol === "http" ? `http://localhost:${mapping.localPort}` : `localhost:${mapping.localPort}`;
-      console.log(`    ${chalk18.cyan(mapping.name.padEnd(20))} ${url}`);
+      console.log(`    ${chalk19.cyan(mapping.name.padEnd(20))} ${url}`);
     }
-    console.log(chalk18.bold("\n  Tip:\n"));
-    console.log(chalk18.gray("    Run: stacksolo dev --health  to verify endpoints\n"));
-    console.log(chalk18.gray("  Press Ctrl+C to stop\n"));
+    console.log(chalk19.bold("\n  Tip:\n"));
+    console.log(chalk19.gray("    Run: stacksolo dev --health  to verify endpoints\n"));
+    console.log(chalk19.gray("  Press Ctrl+C to stop\n"));
     const cleanup = async () => {
       isShuttingDown = true;
-      console.log(chalk18.gray("\n  Stopping port-forwards...\n"));
+      console.log(chalk19.gray("\n  Stopping port-forwards...\n"));
       for (const proc of portForwardProcesses) {
         try {
           proc.kill("SIGTERM");
@@ -17900,10 +18189,10 @@ async function restartService(service) {
 async function tailLogs(service) {
   const config = await loadConfig2();
   const namespace = sanitizeNamespaceName(config.project.name);
-  console.log(chalk18.bold("\n  StackSolo Dev Logs\n"));
-  console.log(chalk18.gray("  Press Ctrl+C to stop\n"));
+  console.log(chalk19.bold("\n  StackSolo Dev Logs\n"));
+  console.log(chalk19.gray("  Press Ctrl+C to stop\n"));
   const args = service ? ["logs", "-f", "-n", namespace, "-l", `app.kubernetes.io/name=${service}`] : ["logs", "-f", "-n", namespace, "--all-containers", "-l", "app.kubernetes.io/managed-by=stacksolo"];
-  const child = spawn6("kubectl", args, { stdio: "inherit" });
+  const child = spawn7("kubectl", args, { stdio: "inherit" });
   process.on("SIGINT", () => {
     child.kill("SIGINT");
     process.exit(0);
@@ -17915,10 +18204,10 @@ async function tailLogs(service) {
 
 // src/commands/dev/install.ts
 import { Command as Command18 } from "commander";
-import chalk19 from "chalk";
-import ora9 from "ora";
-import * as path23 from "path";
-import * as fs20 from "fs/promises";
+import chalk20 from "chalk";
+import ora10 from "ora";
+import * as path24 from "path";
+import * as fs21 from "fs/promises";
 import { exec as exec14 } from "child_process";
 import { promisify as promisify14 } from "util";
 var execAsync14 = promisify14(exec14);
@@ -17926,13 +18215,13 @@ var STACKSOLO_DIR10 = ".stacksolo";
 var CONFIG_FILENAME8 = "stacksolo.config.json";
 var installCommand = new Command18("install").description("Install dependencies for all resources").option("-p, --parallel", "Install dependencies in parallel").action(async (options) => {
   const cwd = process.cwd();
-  console.log(chalk19.cyan("\n  StackSolo Install\n"));
-  const configPath = path23.join(cwd, STACKSOLO_DIR10, CONFIG_FILENAME8);
+  console.log(chalk20.cyan("\n  StackSolo Install\n"));
+  const configPath = path24.join(cwd, STACKSOLO_DIR10, CONFIG_FILENAME8);
   let config;
   try {
     config = parseConfig(configPath);
   } catch {
-    console.log(chalk19.red("  No config found. Run `stacksolo init` first.\n"));
+    console.log(chalk20.red("  No config found. Run `stacksolo init` first.\n"));
     return;
   }
   const directories = [];
@@ -17941,7 +18230,7 @@ var installCommand = new Command18("install").description("Install dependencies
       const sourceDir = fn.sourceDir?.replace(/^\.\//, "") || `functions/${fn.name}`;
       directories.push({
         name: fn.name,
-        path: path23.join(cwd, sourceDir),
+        path: path24.join(cwd, sourceDir),
         type: "function"
       });
     }
@@ -17949,7 +18238,7 @@ var installCommand = new Command18("install").description("Install dependencies
       const sourceDir = container.sourceDir?.replace(/^\.\//, "") || `containers/${container.name}`;
       directories.push({
         name: container.name,
-        path: path23.join(cwd, sourceDir),
+        path: path24.join(cwd, sourceDir),
         type: "container"
       });
     }
@@ -17957,33 +18246,33 @@ var installCommand = new Command18("install").description("Install dependencies
       const sourceDir = ui.sourceDir?.replace(/^\.\//, "") || `apps/${ui.name}`;
       directories.push({
         name: ui.name,
-        path: path23.join(cwd, sourceDir),
+        path: path24.join(cwd, sourceDir),
         type: "ui"
       });
     }
   }
   if (directories.length === 0) {
-    console.log(chalk19.yellow("  No resources found in config.\n"));
+    console.log(chalk20.yellow("  No resources found in config.\n"));
     return;
   }
-  console.log(chalk19.gray(`  Found ${directories.length} resource(s) to install:
+  console.log(chalk20.gray(`  Found ${directories.length} resource(s) to install:
 `));
   const validDirs = [];
   for (const dir of directories) {
     try {
-      await fs20.access(path23.join(dir.path, "package.json"));
+      await fs21.access(path24.join(dir.path, "package.json"));
       validDirs.push(dir);
-      console.log(chalk19.gray(`    - ${dir.name} (${dir.type})`));
+      console.log(chalk20.gray(`    - ${dir.name} (${dir.type})`));
     } catch {
     }
   }
   if (validDirs.length === 0) {
-    console.log(chalk19.yellow("  No resources with package.json found.\n"));
+    console.log(chalk20.yellow("  No resources with package.json found.\n"));
     return;
   }
   console.log("");
   const installDir = async (dir) => {
-    const spinner = ora9(`Installing ${dir.name}...`).start();
+    const spinner = ora10(`Installing ${dir.name}...`).start();
     try {
       await execAsync14("npm install", { cwd: dir.path, timeout: 12e4 });
       spinner.succeed(`Installed ${dir.name}`);
@@ -18006,34 +18295,34 @@ var installCommand = new Command18("install").description("Install dependencies
   const failed = results.filter((r) => !r.success).length;
   console.log("");
   if (failed === 0) {
-    console.log(chalk19.green(`  \u2713 Installed dependencies for ${succeeded} resource(s)
+    console.log(chalk20.green(`  \u2713 Installed dependencies for ${succeeded} resource(s)
 `));
   } else {
-    console.log(chalk19.yellow(`  Installed ${succeeded}, failed ${failed}
+    console.log(chalk20.yellow(`  Installed ${succeeded}, failed ${failed}
 `));
   }
 });
 
 // src/commands/dev/serve.ts
 import { Command as Command19 } from "commander";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 var serveCommand = new Command19("serve").description("Start the StackSolo API server").option("-p, --port <port>", "Port to listen on", "3000").option("--host <host>", "Host to bind to", "localhost").action(async (options) => {
-  console.log(chalk20.bold("\n  StackSolo Server\n"));
+  console.log(chalk21.bold("\n  StackSolo Server\n"));
   const port = parseInt(options.port, 10);
   const host = options.host;
-  console.log(chalk20.gray(`  Starting API server on ${host}:${port}...`));
+  console.log(chalk21.gray(`  Starting API server on ${host}:${port}...`));
   try {
     const { startServer } = await import("@stacksolo/api");
     await startServer({ port, host });
   } catch (error) {
-    const { spawn: spawn7 } = await import("child_process");
-    const path27 = await import("path");
+    const { spawn: spawn8 } = await import("child_process");
+    const path28 = await import("path");
     const { fileURLToPath } = await import("url");
-    const __dirname = path27.dirname(fileURLToPath(import.meta.url));
-    const apiPath = path27.resolve(__dirname, "../../api/dist/index.js");
-    console.log(chalk20.gray(`  Spawning API from ${apiPath}...
+    const __dirname = path28.dirname(fileURLToPath(import.meta.url));
+    const apiPath = path28.resolve(__dirname, "../../api/dist/index.js");
+    console.log(chalk21.gray(`  Spawning API from ${apiPath}...
 `));
-    const child = spawn7("node", [apiPath], {
+    const child = spawn8("node", [apiPath], {
       env: {
         ...process.env,
         PORT: String(port),
@@ -18042,7 +18331,7 @@ var serveCommand = new Command19("serve").description("Start the StackSolo API s
       stdio: "inherit"
     });
     child.on("error", (err) => {
-      console.log(chalk20.red(`  Failed to start server: ${err.message}
+      console.log(chalk21.red(`  Failed to start server: ${err.message}
 `));
       process.exit(1);
     });
@@ -18060,21 +18349,21 @@ var serveCommand = new Command19("serve").description("Start the StackSolo API s
 
 // src/commands/config/config.ts
 import { Command as Command20 } from "commander";
-import chalk21 from "chalk";
-import * as path24 from "path";
+import chalk22 from "chalk";
+import * as path25 from "path";
 var STACKSOLO_DIR11 = ".stacksolo";
 var CONFIG_FILENAME9 = "stacksolo.config.json";
 function getConfigPath6() {
-  return path24.join(process.cwd(), STACKSOLO_DIR11, CONFIG_FILENAME9);
+  return path25.join(process.cwd(), STACKSOLO_DIR11, CONFIG_FILENAME9);
 }
 async function loadConfig3(configPath) {
   try {
     return parseConfig(configPath);
   } catch (error) {
-    console.log(chalk21.red(`
+    console.log(chalk22.red(`
   Error: Could not read ${STACKSOLO_DIR11}/${CONFIG_FILENAME9}
 `));
-    console.log(chalk21.gray(`  ${error}`));
+    console.log(chalk22.gray(`  ${error}`));
     return null;
   }
 }
@@ -18086,75 +18375,75 @@ var showCommand2 = new Command20("show").description("Display the current config
     console.log(JSON.stringify(config, null, 2));
     return;
   }
-  console.log(chalk21.bold("\n  StackSolo Configuration\n"));
-  console.log(chalk21.cyan("  Project:"));
-  console.log(chalk21.white(`    Name:       ${config.project.name}`));
-  console.log(chalk21.white(`    Region:     ${config.project.region}`));
-  console.log(chalk21.white(`    GCP Project: ${config.project.gcpProjectId}`));
+  console.log(chalk22.bold("\n  StackSolo Configuration\n"));
+  console.log(chalk22.cyan("  Project:"));
+  console.log(chalk22.white(`    Name:       ${config.project.name}`));
+  console.log(chalk22.white(`    Region:     ${config.project.region}`));
+  console.log(chalk22.white(`    GCP Project: ${config.project.gcpProjectId}`));
   const { buckets, secrets, topics, queues, crons } = config.project;
   if (buckets?.length) {
-    console.log(chalk21.cyan("\n  Buckets:"));
+    console.log(chalk22.cyan("\n  Buckets:"));
     buckets.forEach((b) => {
-      console.log(chalk21.white(`    - ${b.name}`) + chalk21.gray(` (${b.storageClass || "STANDARD"})`));
+      console.log(chalk22.white(`    - ${b.name}`) + chalk22.gray(` (${b.storageClass || "STANDARD"})`));
     });
   }
   if (secrets?.length) {
-    console.log(chalk21.cyan("\n  Secrets:"));
+    console.log(chalk22.cyan("\n  Secrets:"));
     secrets.forEach((s) => {
-      console.log(chalk21.white(`    - ${s.name}`));
+      console.log(chalk22.white(`    - ${s.name}`));
     });
   }
   if (topics?.length) {
-    console.log(chalk21.cyan("\n  Topics:"));
+    console.log(chalk22.cyan("\n  Topics:"));
     topics.forEach((t) => {
-      console.log(chalk21.white(`    - ${t.name}`));
+      console.log(chalk22.white(`    - ${t.name}`));
     });
   }
   if (queues?.length) {
-    console.log(chalk21.cyan("\n  Queues:"));
+    console.log(chalk22.cyan("\n  Queues:"));
     queues.forEach((q) => {
-      console.log(chalk21.white(`    - ${q.name}`));
+      console.log(chalk22.white(`    - ${q.name}`));
     });
   }
   if (crons?.length) {
-    console.log(chalk21.cyan("\n  Scheduled Jobs:"));
+    console.log(chalk22.cyan("\n  Scheduled Jobs:"));
     crons.forEach((c) => {
-      console.log(chalk21.white(`    - ${c.name}`) + chalk21.gray(` (${c.schedule})`));
+      console.log(chalk22.white(`    - ${c.name}`) + chalk22.gray(` (${c.schedule})`));
     });
   }
   const networks = config.project.networks || [];
   if (networks.length) {
     networks.forEach((network) => {
-      console.log(chalk21.cyan(`
+      console.log(chalk22.cyan(`
   Network: ${network.name}`));
       if (network.subnets?.length) {
-        console.log(chalk21.gray("    Subnets:"));
+        console.log(chalk22.gray("    Subnets:"));
         network.subnets.forEach((s) => {
-          console.log(chalk21.white(`      - ${s.name}`) + chalk21.gray(` (${s.ipCidrRange})`));
+          console.log(chalk22.white(`      - ${s.name}`) + chalk22.gray(` (${s.ipCidrRange})`));
         });
       }
       if (network.containers?.length) {
-        console.log(chalk21.gray("    Containers:"));
+        console.log(chalk22.gray("    Containers:"));
         network.containers.forEach((c) => {
-          console.log(chalk21.white(`      - ${c.name}`) + chalk21.gray(` (${c.memory || "256Mi"})`));
+          console.log(chalk22.white(`      - ${c.name}`) + chalk22.gray(` (${c.memory || "256Mi"})`));
         });
       }
       if (network.functions?.length) {
-        console.log(chalk21.gray("    Functions:"));
+        console.log(chalk22.gray("    Functions:"));
         network.functions.forEach((f) => {
-          console.log(chalk21.white(`      - ${f.name}`) + chalk21.gray(` (${f.runtime || "nodejs20"})`));
+          console.log(chalk22.white(`      - ${f.name}`) + chalk22.gray(` (${f.runtime || "nodejs20"})`));
         });
       }
       if (network.databases?.length) {
-        console.log(chalk21.gray("    Databases:"));
+        console.log(chalk22.gray("    Databases:"));
         network.databases.forEach((d) => {
-          console.log(chalk21.white(`      - ${d.name}`) + chalk21.gray(` (${d.databaseVersion || "POSTGRES_15"})`));
+          console.log(chalk22.white(`      - ${d.name}`) + chalk22.gray(` (${d.databaseVersion || "POSTGRES_15"})`));
         });
       }
       if (network.caches?.length) {
-        console.log(chalk21.gray("    Caches:"));
+        console.log(chalk22.gray("    Caches:"));
         network.caches.forEach((c) => {
-          console.log(chalk21.white(`      - ${c.name}`) + chalk21.gray(` (${c.memorySizeGb || 1}GB)`));
+          console.log(chalk22.white(`      - ${c.name}`) + chalk22.gray(` (${c.memorySizeGb || 1}GB)`));
         });
       }
     });
@@ -18172,20 +18461,20 @@ var resourcesCommand = new Command20("resources").description("List all resource
       console.log(JSON.stringify(resolved.resources, null, 2));
       return;
     }
-    console.log(chalk21.bold("\n  Resources to Create\n"));
-    console.log(chalk21.gray(`  Order of creation (${order.length} resources):
+    console.log(chalk22.bold("\n  Resources to Create\n"));
+    console.log(chalk22.gray(`  Order of creation (${order.length} resources):
 `));
     order.forEach((id, index) => {
       const resource = resolved.resources.find((r) => r.id === id);
       if (!resource) return;
-      const deps = resource.dependsOn.length ? chalk21.gray(` \u2192 depends on: ${resource.dependsOn.join(", ")}`) : "";
+      const deps = resource.dependsOn.length ? chalk22.gray(` \u2192 depends on: ${resource.dependsOn.join(", ")}`) : "";
       console.log(
-        chalk21.white(`  ${String(index + 1).padStart(2)}. `) + chalk21.cyan(resource.type) + chalk21.white(` "${resource.name}"`) + deps
+        chalk22.white(`  ${String(index + 1).padStart(2)}. `) + chalk22.cyan(resource.type) + chalk22.white(` "${resource.name}"`) + deps
       );
     });
     console.log("");
   } catch (error) {
-    console.log(chalk21.red(`
+    console.log(chalk22.red(`
   Error resolving config: ${error}
 `));
   }
@@ -18196,24 +18485,24 @@ var validateCommand = new Command20("validate").description("Validate the config
   if (!config) return;
   const result = validateConfig(config);
   if (result.valid) {
-    console.log(chalk21.green("\n  \u2713 Configuration is valid\n"));
+    console.log(chalk22.green("\n  \u2713 Configuration is valid\n"));
     try {
       const resolved = resolveConfig(config);
       const order = topologicalSort(resolved.resources);
-      console.log(chalk21.gray(`  ${resolved.resources.length} resources defined`));
-      console.log(chalk21.gray(`  No circular dependencies detected
+      console.log(chalk22.gray(`  ${resolved.resources.length} resources defined`));
+      console.log(chalk22.gray(`  No circular dependencies detected
 `));
     } catch (error) {
-      console.log(chalk21.yellow(`
+      console.log(chalk22.yellow(`
   \u26A0 Warning: ${error}
 `));
     }
   } else {
-    console.log(chalk21.red("\n  \u2717 Configuration has errors:\n"));
+    console.log(chalk22.red("\n  \u2717 Configuration has errors:\n"));
     result.errors.forEach((err) => {
-      console.log(chalk21.red(`    - ${err.path}: ${err.message}`));
+      console.log(chalk22.red(`    - ${err.path}: ${err.message}`));
       if (err.value !== void 0) {
-        console.log(chalk21.gray(`      value: ${JSON.stringify(err.value)}`));
+        console.log(chalk22.gray(`      value: ${JSON.stringify(err.value)}`));
       }
     });
     console.log("");
@@ -18224,7 +18513,7 @@ var referencesCommand = new Command20("references").description("Show all resour
   const configPath = getConfigPath6();
   const config = await loadConfig3(configPath);
   if (!config) return;
-  console.log(chalk21.bold("\n  Resource References\n"));
+  console.log(chalk22.bold("\n  Resource References\n"));
   const allReferences = [];
   const networks = config.project.networks || [];
   networks.forEach((network) => {
@@ -18258,7 +18547,7 @@ var referencesCommand = new Command20("references").description("Show all resour
     });
   });
   if (allReferences.length === 0) {
-    console.log(chalk21.gray("  No references found.\n"));
+    console.log(chalk22.gray("  No references found.\n"));
     return;
   }
   const byType = /* @__PURE__ */ new Map();
@@ -18270,11 +18559,11 @@ var referencesCommand = new Command20("references").description("Show all resour
     byType.get(type).push(ref);
   });
   byType.forEach((refs, type) => {
-    console.log(chalk21.cyan(`  @${type}:`));
+    console.log(chalk22.cyan(`  @${type}:`));
     refs.forEach((ref) => {
       const property = ref.parsed?.property ? `.${ref.parsed.property}` : "";
       console.log(
-        chalk21.white(`    ${ref.reference}`) + chalk21.gray(` \u2192 ${ref.location}.env.${ref.envVar}`)
+        chalk22.white(`    ${ref.reference}`) + chalk22.gray(` \u2192 ${ref.location}.env.${ref.envVar}`)
       );
     });
     console.log("");
@@ -18287,47 +18576,47 @@ configCommand.action(() => {
 
 // src/commands/config/env.ts
 import { Command as Command21 } from "commander";
-import chalk22 from "chalk";
-import ora10 from "ora";
-import * as fs21 from "fs/promises";
-import * as path25 from "path";
+import chalk23 from "chalk";
+import ora11 from "ora";
+import * as fs22 from "fs/promises";
+import * as path26 from "path";
 var envCommand = new Command21("env").description("Generate environment configuration files").option("--stdout", "Print to stdout instead of writing files").option("--format <format>", "Output format: dotenv, json, typescript", "dotenv").action(async (options) => {
   const cwd = process.cwd();
-  console.log(chalk22.bold("\n  StackSolo Env\n"));
-  const configPath = path25.join(cwd, ".stacksolo", "config.json");
+  console.log(chalk23.bold("\n  StackSolo Env\n"));
+  const configPath = path26.join(cwd, ".stacksolo", "config.json");
   let config;
   try {
-    const configData = await fs21.readFile(configPath, "utf-8");
+    const configData = await fs22.readFile(configPath, "utf-8");
     config = JSON.parse(configData);
   } catch {
-    console.log(chalk22.red("  Not initialized. Run `stacksolo init` first.\n"));
+    console.log(chalk23.red("  Not initialized. Run `stacksolo init` first.\n"));
     return;
   }
   const apiConnected = await checkApiConnection();
   if (!apiConnected) {
-    console.log(chalk22.red("  StackSolo API not running."));
-    console.log(chalk22.gray("  Start with: stacksolo serve\n"));
+    console.log(chalk23.red("  StackSolo API not running."));
+    console.log(chalk23.gray("  Start with: stacksolo serve\n"));
     return;
   }
-  const spinner = ora10("Checking deployment...").start();
+  const spinner = ora11("Checking deployment...").start();
   const statusResult = await api.deployments.status(config.projectId);
   if (!statusResult.success || !statusResult.data) {
     spinner.fail("Could not get deployment status");
-    console.log(chalk22.gray("\n  Deploy first with: stacksolo deploy\n"));
+    console.log(chalk23.gray("\n  Deploy first with: stacksolo deploy\n"));
     return;
   }
   if (statusResult.data.status !== "succeeded") {
     spinner.fail("No successful deployment");
-    console.log(chalk22.gray(`
+    console.log(chalk23.gray(`
   Current status: ${statusResult.data.status}`));
-    console.log(chalk22.gray("  Deploy first with: stacksolo deploy\n"));
+    console.log(chalk23.gray("  Deploy first with: stacksolo deploy\n"));
     return;
   }
   spinner.text = "Generating configuration...";
   const configResult = await api.deployments.generateConfig(config.projectId);
   if (!configResult.success || !configResult.data) {
     spinner.fail("Failed to generate config");
-    console.log(chalk22.red(`  ${configResult.error}
+    console.log(chalk23.red(`  ${configResult.error}
 `));
     return;
   }
@@ -18336,38 +18625,38 @@ var envCommand = new Command21("env").description("Generate environment configur
   const tsConfigPath = configResult.data.configPath;
   if (options.stdout) {
     try {
-      console.log(chalk22.gray("\n  .env.local:"));
-      const envContent = await fs21.readFile(envPath, "utf-8");
+      console.log(chalk23.gray("\n  .env.local:"));
+      const envContent = await fs22.readFile(envPath, "utf-8");
       console.log(envContent);
-      console.log(chalk22.gray("\n  stacksolo.config.ts:"));
-      const tsContent = await fs21.readFile(tsConfigPath, "utf-8");
+      console.log(chalk23.gray("\n  stacksolo.config.ts:"));
+      const tsContent = await fs22.readFile(tsConfigPath, "utf-8");
       console.log(tsContent);
     } catch (error) {
-      console.log(chalk22.red(`  Error reading files: ${error}
+      console.log(chalk23.red(`  Error reading files: ${error}
 `));
     }
   } else {
-    console.log(chalk22.green("\n  Files generated:"));
-    console.log(chalk22.gray(`    ${envPath}`));
-    console.log(chalk22.gray(`    ${tsConfigPath}`));
+    console.log(chalk23.green("\n  Files generated:"));
+    console.log(chalk23.gray(`    ${envPath}`));
+    console.log(chalk23.gray(`    ${tsConfigPath}`));
     console.log("");
-    console.log(chalk22.gray("  Add to .gitignore:"));
-    console.log(chalk22.gray("    .env.local"));
+    console.log(chalk23.gray("  Add to .gitignore:"));
+    console.log(chalk23.gray("    .env.local"));
     console.log("");
-    console.log(chalk22.gray("  Usage in your app:"));
-    console.log(chalk22.gray("    import { config } from './stacksolo.config';"));
-    console.log(chalk22.gray("    const dbUrl = config.database?.url;\n"));
+    console.log(chalk23.gray("  Usage in your app:"));
+    console.log(chalk23.gray("    import { config } from './stacksolo.config';"));
+    console.log(chalk23.gray("    const dbUrl = config.database?.url;\n"));
   }
 });
 
 // src/commands/config/register.ts
 import { Command as Command22 } from "commander";
-import chalk23 from "chalk";
-import * as path26 from "path";
+import chalk24 from "chalk";
+import * as path27 from "path";
 var STACKSOLO_DIR12 = ".stacksolo";
 var CONFIG_FILENAME10 = "stacksolo.config.json";
 function getConfigPath7() {
-  return path26.join(process.cwd(), STACKSOLO_DIR12, CONFIG_FILENAME10);
+  return path27.join(process.cwd(), STACKSOLO_DIR12, CONFIG_FILENAME10);
 }
 var registerCommand = new Command22("register").description("Register the current project in the global registry").option("-f, --force", "Overwrite existing registration").action(async (options) => {
   const configPath = getConfigPath7();
@@ -18375,11 +18664,11 @@ var registerCommand = new Command22("register").description("Register the curren
   try {
     config = parseConfig(configPath);
   } catch (error) {
-    console.log(chalk23.red(`
+    console.log(chalk24.red(`
   Error: Could not read ${STACKSOLO_DIR12}/${CONFIG_FILENAME10}
 `));
-    console.log(chalk23.gray(`  ${error}`));
-    console.log(chalk23.gray(`
+    console.log(chalk24.gray(`  ${error}`));
+    console.log(chalk24.gray(`
   Run 'stacksolo init' to create a project first.
 `));
     process.exit(1);
@@ -18389,21 +18678,21 @@ var registerCommand = new Command22("register").description("Register the curren
   if (existingByPath) {
     if (options.force) {
       await registry3.unregisterProject(existingByPath.id);
-      console.log(chalk23.yellow(`  Updating registration for "${existingByPath.name}"...`));
+      console.log(chalk24.yellow(`  Updating registration for "${existingByPath.name}"...`));
     } else {
-      console.log(chalk23.yellow(`
+      console.log(chalk24.yellow(`
   Project already registered as "${existingByPath.name}"`));
-      console.log(chalk23.gray(`  Use --force to update the registration.
+      console.log(chalk24.gray(`  Use --force to update the registration.
 `));
       return;
     }
   }
   const existingByName = await registry3.findProjectByName(config.project.name);
   if (existingByName && existingByName.configPath !== configPath) {
-    console.log(chalk23.red(`
+    console.log(chalk24.red(`
   Error: Project name "${config.project.name}" is already registered`));
-    console.log(chalk23.gray(`  Registered path: ${existingByName.configPath}`));
-    console.log(chalk23.gray(`  Choose a different project name in stacksolo.config.json
+    console.log(chalk24.gray(`  Registered path: ${existingByName.configPath}`));
+    console.log(chalk24.gray(`  Choose a different project name in stacksolo.config.json
 `));
     process.exit(1);
   }
@@ -18413,42 +18702,42 @@ var registerCommand = new Command22("register").description("Register the curren
     region: config.project.region,
     configPath
   });
-  console.log(chalk23.green(`
+  console.log(chalk24.green(`
   \u2713 Project registered: ${project.name}
 `));
-  console.log(chalk23.gray(`  GCP Project: ${project.gcpProjectId}`));
-  console.log(chalk23.gray(`  Region:      ${project.region}`));
-  console.log(chalk23.gray(`  Config:      ${project.configPath}`));
+  console.log(chalk24.gray(`  GCP Project: ${project.gcpProjectId}`));
+  console.log(chalk24.gray(`  Region:      ${project.region}`));
+  console.log(chalk24.gray(`  Config:      ${project.configPath}`));
   console.log("");
-  console.log(chalk23.cyan("  Next steps:"));
-  console.log(chalk23.gray("    stacksolo list           # View all registered projects"));
-  console.log(chalk23.gray("    stacksolo deploy         # Deploy the project"));
+  console.log(chalk24.cyan("  Next steps:"));
+  console.log(chalk24.gray("    stacksolo list           # View all registered projects"));
+  console.log(chalk24.gray("    stacksolo deploy         # Deploy the project"));
   console.log("");
 });
 
 // src/commands/config/unregister.ts
 import { Command as Command23 } from "commander";
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 import inquirer5 from "inquirer";
 var unregisterCommand = new Command23("unregister").description("Remove a project from the global registry").argument("<project>", "Project name to unregister").option("-y, --yes", "Skip confirmation prompt").action(async (projectName, options) => {
   const registry3 = getRegistry();
   const project = await registry3.findProjectByName(projectName);
   if (!project) {
-    console.log(chalk24.red(`
+    console.log(chalk25.red(`
   Error: Project "${projectName}" not found.
 `));
-    console.log(chalk24.gray("  Run `stacksolo list` to see registered projects.\n"));
+    console.log(chalk25.gray("  Run `stacksolo list` to see registered projects.\n"));
     process.exit(1);
   }
   const resources = await registry3.findResourcesByProject(project.id);
   if (!options.yes) {
-    console.log(chalk24.yellow(`
+    console.log(chalk25.yellow(`
   Warning: This will remove "${projectName}" from the registry.`));
     if (resources.length > 0) {
-      console.log(chalk24.yellow(`  This project has ${resources.length} registered resource(s).`));
+      console.log(chalk25.yellow(`  This project has ${resources.length} registered resource(s).`));
     }
-    console.log(chalk24.gray("\n  Note: This does NOT destroy deployed cloud resources."));
-    console.log(chalk24.gray("  To destroy resources, run `stacksolo destroy` first.\n"));
+    console.log(chalk25.gray("\n  Note: This does NOT destroy deployed cloud resources."));
+    console.log(chalk25.gray("  To destroy resources, run `stacksolo destroy` first.\n"));
     const { confirm } = await inquirer5.prompt([
       {
         type: "confirm",
@@ -18458,17 +18747,17 @@ var unregisterCommand = new Command23("unregister").description("Remove a projec
       }
     ]);
     if (!confirm) {
-      console.log(chalk24.gray("\n  Cancelled.\n"));
+      console.log(chalk25.gray("\n  Cancelled.\n"));
       return;
     }
   }
   await registry3.unregisterProject(project.id);
-  console.log(chalk24.green(`
+  console.log(chalk25.green(`
   \u2713 Project "${projectName}" removed from registry.
 `));
   if (project.configPath) {
-    console.log(chalk24.gray(`  Config file still exists at: ${project.configPath}`));
-    console.log(chalk24.gray("  Run `stacksolo register` to re-register this project.\n"));
+    console.log(chalk25.gray(`  Config file still exists at: ${project.configPath}`));
+    console.log(chalk25.gray("  Run `stacksolo register` to re-register this project.\n"));
   }
 });