@specific.dev/cli 0.1.37 → 0.1.39

package/dist/cli.js

@@ -41,8 +41,8 @@ var require_dist = __commonJS({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require : $global = this, void 0 === $global || void 0 === $global.Array) throw new Error("no global object found");
       if ("undefined" != typeof module && ($module = module), !$global.fs && $global.require) try {
-        var fs25 = $global.require("fs");
-        "object" == typeof fs25 && null !== fs25 && 0 !== Object.keys(fs25).length && ($global.fs = fs25);
+        var fs26 = $global.require("fs");
+        "object" == typeof fs26 && null !== fs26 && 0 !== Object.keys(fs26).length && ($global.fs = fs26);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -182236,8 +182236,8 @@ import { Command } from "commander";
 import React, { useState, useEffect } from "react";
 import { render, Text, Box, useInput, useApp } from "ink";
 import "ink-spinner";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/lib/dev/local-ca.ts
 import * as fs from "fs";
@@ -182368,40 +182368,143 @@ function installCAToTrustStore(certPath) {
     throw new Error(`Unsupported platform: ${platform5}`);
   }
 }
-function generateCertificate(domain) {
+function generateCertificate(domain, keys = []) {
   const caDir = getCADir();
   const caCertPem = fs.readFileSync(path.join(caDir, "ca.crt"), "utf-8");
   const caKeyPem = fs.readFileSync(path.join(caDir, "ca.key"), "utf-8");
   const caCert = forge.pki.certificateFromPem(caCertPem);
   const caKey = forge.pki.privateKeyFromPem(caKeyPem);
-  const keys = forge.pki.rsa.generateKeyPair(2048);
+  const certKeys = forge.pki.rsa.generateKeyPair(2048);
   const cert = forge.pki.createCertificate();
-  cert.publicKey = keys.publicKey;
+  cert.publicKey = certKeys.publicKey;
   cert.serialNumber = forge.util.bytesToHex(forge.random.getBytesSync(16));
   cert.validity.notBefore = /* @__PURE__ */ new Date();
   cert.validity.notAfter = /* @__PURE__ */ new Date();
   cert.validity.notAfter.setDate(cert.validity.notBefore.getDate() + 7);
   cert.setSubject([{ name: "commonName", value: domain }]);
   cert.setIssuer(caCert.subject.attributes);
+  const altNames = [
+    { type: 2, value: domain },
+    { type: 2, value: `*.${domain}` }
+  ];
+  for (const key of keys) {
+    if (key !== "default") {
+      altNames.push({ type: 2, value: `*.${key}.${domain}` });
+    }
+  }
   cert.setExtensions([
     { name: "basicConstraints", cA: false },
     { name: "keyUsage", digitalSignature: true, keyEncipherment: true },
     { name: "extKeyUsage", serverAuth: true },
-    {
-      name: "subjectAltName",
-      altNames: [
-        { type: 2, value: domain },
-        { type: 2, value: `*.${domain}` }
-      ]
-    }
+    { name: "subjectAltName", altNames }
   ]);
   cert.sign(caKey, forge.md.sha256.create());
   return {
-    key: Buffer.from(forge.pki.privateKeyToPem(keys.privateKey)),
+    key: Buffer.from(forge.pki.privateKeyToPem(certKeys.privateKey)),
     cert: Buffer.from(forge.pki.certificateToPem(cert))
   };
 }
 
+// src/lib/analytics/index.ts
+import { PostHog } from "posthog-node";
+import * as os2 from "os";
+import * as crypto from "crypto";
+
+// src/lib/project/config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var PROJECT_ID_FILE = ".specific/project_id";
+var ProjectNotLinkedError = class extends Error {
+  constructor() {
+    super(
+      `Project not linked to Specific.
+
+The file ${PROJECT_ID_FILE} does not exist.
+
+Run: specific deploy`
+    );
+    this.name = "ProjectNotLinkedError";
+  }
+};
+function readProjectId(projectDir = process.cwd()) {
+  const projectIdPath = path2.join(projectDir, PROJECT_ID_FILE);
+  if (!fs2.existsSync(projectIdPath)) {
+    throw new ProjectNotLinkedError();
+  }
+  const projectId = fs2.readFileSync(projectIdPath, "utf-8").trim();
+  if (!projectId) {
+    throw new Error(`${PROJECT_ID_FILE} is empty`);
+  }
+  return projectId;
+}
+function hasProjectId(projectDir = process.cwd()) {
+  const projectIdPath = path2.join(projectDir, PROJECT_ID_FILE);
+  return fs2.existsSync(projectIdPath);
+}
+function writeProjectId(projectId, projectDir = process.cwd()) {
+  const specificDir = path2.join(projectDir, ".specific");
+  if (!fs2.existsSync(specificDir)) {
+    fs2.mkdirSync(specificDir, { recursive: true });
+  }
+  fs2.writeFileSync(path2.join(specificDir, "project_id"), projectId + "\n");
+}
+
+// src/lib/analytics/index.ts
+var POSTHOG_HOST = "https://eu.i.posthog.com";
+var client = null;
+var anonymousId = null;
+function isEnabled() {
+  return true;
+}
+function getAnonymousId() {
+  if (anonymousId) return anonymousId;
+  const machineId = `${os2.hostname()}-${os2.userInfo().username}`;
+  anonymousId = crypto.createHash("sha256").update(machineId).digest("hex").slice(0, 16);
+  return anonymousId;
+}
+function getProjectId() {
+  try {
+    if (hasProjectId()) {
+      return readProjectId();
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getClient() {
+  if (!isEnabled()) return null;
+  if (!client) {
+    client = new PostHog("phc_qNQCEUXh6ErdciQRRmeG2xlVvwFjkcW6A5bnOFJ8vXZ", {
+      host: POSTHOG_HOST,
+      flushAt: 1,
+      // Flush immediately for CLI
+      flushInterval: 0
+    });
+  }
+  return client;
+}
+function trackEvent(event, properties) {
+  const ph = getClient();
+  if (!ph) return;
+  ph.capture({
+    distinctId: getAnonymousId(),
+    event,
+    properties: {
+      ...properties,
+      cli_version: "0.1.39",
+      platform: process.platform,
+      node_version: process.version,
+      project_id: getProjectId()
+    }
+  });
+}
+async function shutdown() {
+  if (client) {
+    await client.shutdown();
+    client = null;
+  }
+}
+
 // src/commands/init.tsx
 var SPECIFIC_INSTRUCTIONS = `Use Specific to handle all infrastructure and development environments: like deployments, databases, real-time sync, services, secrets, configuration and environment variables. Run \`specific docs\` to learn how to use Specific. ALWAYS run \`specific check\` after making changes to the Specific configuration.`;
 var CURSOR_MDC_CONTENT = `---
@@ -182419,67 +182522,67 @@ var options = [
   { id: "other", label: "Other / Manual" }
 ];
 function isGitProject() {
-  const gitPath = path2.join(process.cwd(), ".git");
-  return fs2.existsSync(gitPath);
+  const gitPath = path3.join(process.cwd(), ".git");
+  return fs3.existsSync(gitPath);
 }
 function detectExistingAgents() {
   const detected = {};
-  const cursorDir = path2.join(process.cwd(), ".cursor");
-  if (fs2.existsSync(cursorDir)) {
+  const cursorDir = path3.join(process.cwd(), ".cursor");
+  if (fs3.existsSync(cursorDir)) {
     detected["cursor"] = true;
   }
-  const claudeDir = path2.join(process.cwd(), ".claude");
-  const claudeMd = path2.join(process.cwd(), "CLAUDE.md");
-  if (fs2.existsSync(claudeDir) || fs2.existsSync(claudeMd)) {
+  const claudeDir = path3.join(process.cwd(), ".claude");
+  const claudeMd = path3.join(process.cwd(), "CLAUDE.md");
+  if (fs3.existsSync(claudeDir) || fs3.existsSync(claudeMd)) {
     detected["claude"] = true;
   }
-  const agentsMd = path2.join(process.cwd(), "AGENTS.md");
-  if (fs2.existsSync(agentsMd)) {
+  const agentsMd = path3.join(process.cwd(), "AGENTS.md");
+  if (fs3.existsSync(agentsMd)) {
     detected["codex"] = true;
   }
   return detected;
 }
 function appendOrCreateFile(filePath, content) {
-  if (fs2.existsSync(filePath)) {
-    const existing = fs2.readFileSync(filePath, "utf-8");
+  if (fs3.existsSync(filePath)) {
+    const existing = fs3.readFileSync(filePath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    fs2.writeFileSync(filePath, existing + separator + content + "\n");
+    fs3.writeFileSync(filePath, existing + separator + content + "\n");
     return "modified";
   } else {
-    fs2.writeFileSync(filePath, content + "\n");
+    fs3.writeFileSync(filePath, content + "\n");
     return "created";
   }
 }
 function addToGitignore() {
-  const gitignorePath = path2.join(process.cwd(), ".gitignore");
+  const gitignorePath = path3.join(process.cwd(), ".gitignore");
   const entries = [".specific", "specific.secrets"];
-  if (fs2.existsSync(gitignorePath)) {
-    const existing = fs2.readFileSync(gitignorePath, "utf-8");
+  if (fs3.existsSync(gitignorePath)) {
+    const existing = fs3.readFileSync(gitignorePath, "utf-8");
     const lines = existing.split("\n").map((l) => l.trim());
     const missingEntries = entries.filter((entry) => !lines.includes(entry));
     if (missingEntries.length === 0) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "" : "\n";
-    fs2.writeFileSync(
+    fs3.writeFileSync(
       gitignorePath,
       existing + separator + missingEntries.join("\n") + "\n"
     );
     return "modified";
   } else {
-    fs2.writeFileSync(gitignorePath, entries.join("\n") + "\n");
+    fs3.writeFileSync(gitignorePath, entries.join("\n") + "\n");
     return "created";
   }
 }
 function configureClaudeCodePermissions() {
-  const claudeDir = path2.join(process.cwd(), ".claude");
-  const settingsPath = path2.join(claudeDir, "settings.local.json");
+  const claudeDir = path3.join(process.cwd(), ".claude");
+  const settingsPath = path3.join(claudeDir, "settings.local.json");
   const permissions = ["Bash(specific docs:*)", "Bash(specific check:*)"];
-  if (fs2.existsSync(settingsPath)) {
-    const existing = JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
+  if (fs3.existsSync(settingsPath)) {
+    const existing = JSON.parse(fs3.readFileSync(settingsPath, "utf-8"));
     const allowList = existing?.permissions?.allow || [];
     const missingPermissions = permissions.filter(
       (p) => !allowList.includes(p)
@@ -182494,39 +182597,39 @@ function configureClaudeCodePermissions() {
       existing.permissions.allow = [];
     }
     existing.permissions.allow.push(...missingPermissions);
-    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    fs3.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
     return "modified";
   }
-  if (!fs2.existsSync(claudeDir)) {
-    fs2.mkdirSync(claudeDir);
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir);
   }
   const settings = {
     permissions: {
       allow: permissions
     }
   };
-  fs2.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return "created";
 }
 function createCursorRule() {
-  const cursorDir = path2.join(process.cwd(), ".cursor");
-  const rulesDir = path2.join(cursorDir, "rules");
-  const mdcPath = path2.join(rulesDir, "specific.mdc");
-  if (fs2.existsSync(mdcPath)) {
-    const existing = fs2.readFileSync(mdcPath, "utf-8");
+  const cursorDir = path3.join(process.cwd(), ".cursor");
+  const rulesDir = path3.join(cursorDir, "rules");
+  const mdcPath = path3.join(rulesDir, "specific.mdc");
+  if (fs3.existsSync(mdcPath)) {
+    const existing = fs3.readFileSync(mdcPath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
-    fs2.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+    fs3.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
     return "modified";
   }
-  if (!fs2.existsSync(cursorDir)) {
-    fs2.mkdirSync(cursorDir);
+  if (!fs3.existsSync(cursorDir)) {
+    fs3.mkdirSync(cursorDir);
   }
-  if (!fs2.existsSync(rulesDir)) {
-    fs2.mkdirSync(rulesDir);
+  if (!fs3.existsSync(rulesDir)) {
+    fs3.mkdirSync(rulesDir);
   }
-  fs2.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+  fs3.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
   return "created";
 }
 function configureAgents(checked) {
@@ -182542,7 +182645,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".cursor/rules/specific.mdc");
   }
   if (checked["claude"]) {
-    const claudeMdPath = path2.join(process.cwd(), "CLAUDE.md");
+    const claudeMdPath = path3.join(process.cwd(), "CLAUDE.md");
     const status = appendOrCreateFile(claudeMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("CLAUDE.md");
     else if (status === "modified") agents.filesModified.push("CLAUDE.md");
@@ -182553,7 +182656,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".claude/settings.local.json");
   }
   if (checked["codex"]) {
-    const agentsMdPath = path2.join(process.cwd(), "AGENTS.md");
+    const agentsMdPath = path3.join(process.cwd(), "AGENTS.md");
     const status = appendOrCreateFile(agentsMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("AGENTS.md");
     else if (status === "modified") agents.filesModified.push("AGENTS.md");
@@ -182629,6 +182732,9 @@ function InitUI() {
     } else if ((key.return || input === " ") && isSubmitFocused) {
       const configResult = configureAgents(checked);
       setResult(configResult);
+      trackEvent("project_initialized", {
+        agents: Object.keys(checked).filter((k) => checked[k])
+      });
       setPhase("done");
     }
   });
@@ -182672,35 +182778,35 @@ function initCommand() {
 }
 
 // src/commands/docs.tsx
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { join as join3, dirname } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { join as join4, dirname } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var docsDir = join3(__dirname, "docs");
-function docsCommand(path20) {
-  const docPath = resolveDocPath(path20);
+var docsDir = join4(__dirname, "docs");
+function docsCommand(path22) {
+  const docPath = resolveDocPath(path22);
   if (!docPath) {
     console.error(
-      `Documentation not found: ${path20 || "index"}
+      `Documentation not found: ${path22 || "index"}
 
 Run 'specific docs' to see available topics.`
     );
     process.exit(1);
   }
-  const content = readFileSync3(docPath, "utf-8");
+  const content = readFileSync4(docPath, "utf-8");
   console.log(content);
 }
-function resolveDocPath(path20) {
-  if (!path20) {
-    const indexPath2 = join3(docsDir, "index.md");
-    return existsSync3(indexPath2) ? indexPath2 : null;
+function resolveDocPath(path22) {
+  if (!path22) {
+    const indexPath2 = join4(docsDir, "index.md");
+    return existsSync4(indexPath2) ? indexPath2 : null;
   }
-  const directPath = join3(docsDir, `${path20}.md`);
-  if (existsSync3(directPath)) {
+  const directPath = join4(docsDir, `${path22}.md`);
+  if (existsSync4(directPath)) {
     return directPath;
   }
-  const indexPath = join3(docsDir, path20, "index.md");
-  if (existsSync3(indexPath)) {
+  const indexPath = join4(docsDir, path22, "index.md");
+  if (existsSync4(indexPath)) {
     return indexPath;
   }
   return null;
@@ -182710,8 +182816,8 @@ function resolveDocPath(path20) {
 import React2, { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render2, Text as Text2, Box as Box2 } from "ink";
 import Spinner2 from "ink-spinner";
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // ../config/dist/parser.js
 var import_hcl2_json_parser = __toESM(require_dist(), 1);
@@ -183193,8 +183299,8 @@ function CheckUI() {
   const [state, setState] = useState2({ status: "loading" });
   useEffect2(() => {
     async function load() {
-      const configPath = path3.join(process.cwd(), "specific.hcl");
-      if (!fs3.existsSync(configPath)) {
+      const configPath = path4.join(process.cwd(), "specific.hcl");
+      if (!fs4.existsSync(configPath)) {
         setState({
           status: "error",
           error: "No specific.hcl found in current directory"
@@ -183202,7 +183308,7 @@ function CheckUI() {
         return;
       }
       try {
-        const hcl = fs3.readFileSync(configPath, "utf-8");
+        const hcl = fs4.readFileSync(configPath, "utf-8");
         const config2 = await parseConfig(hcl);
         setState({ status: "success", config: config2 });
       } catch (err) {
@@ -183234,8 +183340,8 @@ function checkCommand() {
 import React3, { useState as useState3, useEffect as useEffect3, useRef } from "react";
 import { render as render3, Text as Text3, Box as Box3, useApp as useApp2, Static } from "ink";
 import Spinner3 from "ink-spinner";
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 
 // node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
@@ -183327,7 +183433,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path20) => statMethod(path20, { bigint: true });
+      this._stat = (path22) => statMethod(path22, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -183352,8 +183458,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path20, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path20));
+          const { path: path22, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -183393,21 +183499,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path20, depth) {
+  async _exploreDir(path22, depth) {
     let files;
     try {
-      files = await readdir(path20, this._rdOptions);
+      files = await readdir(path22, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path20 };
+    return { files, depth, path: path22 };
   }
-  async _formatEntry(dirent, path20) {
+  async _formatEntry(dirent, path22) {
     let entry;
-    const basename4 = this._isDirent ? dirent.name : dirent;
+    const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path20, basename4));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      const fullPath = presolve(pjoin(path22, basename5));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -183806,16 +183912,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path20, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path22, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path20);
-    emitRaw(rawEvent, evPath, { watchedPath: path20 });
-    if (evPath && path20 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path20, evPath), KEY_LISTENERS, sp.join(path20, evPath));
+    listener(path22);
+    emitRaw(rawEvent, evPath, { watchedPath: path22 });
+    if (evPath && path22 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
     }
   };
   try {
-    return fs_watch(path20, {
+    return fs_watch(path22, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -183831,12 +183937,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path20, fullPath, options2, handlers) => {
+var setFsWatchListener = (path22, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path20, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path22, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -183847,7 +183953,7 @@ var setFsWatchListener = (path20, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path20,
+      path22,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -183862,7 +183968,7 @@ var setFsWatchListener = (path20, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path20, "r");
+          const fd = await open(path22, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -183893,7 +183999,7 @@ var setFsWatchListener = (path20, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path20, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -183915,7 +184021,7 @@ var setFsWatchFileListener = (path20, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path20, curr));
+          foreach(cont.listeners, (listener2) => listener2(path22, curr));
         }
       })
     };
@@ -183945,13 +184051,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path20, listener) {
+  _watchWithNodeFs(path22, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path20);
-    const basename4 = sp.basename(path20);
+    const directory = sp.dirname(path22);
+    const basename5 = sp.basename(path22);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename4);
-    const absolutePath = sp.resolve(path20);
+    parent.add(basename5);
+    const absolutePath = sp.resolve(path22);
     const options2 = {
       persistent: opts.persistent
     };
@@ -183960,13 +184066,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options2.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path20, absolutePath, options2, {
+      options2.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path22, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path20, absolutePath, options2, {
+      closer = setFsWatchListener(path22, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -183983,12 +184089,12 @@ var NodeFsHandler = class {
       return;
     }
     const dirname8 = sp.dirname(file);
-    const basename4 = sp.basename(file);
+    const basename5 = sp.basename(file);
     const parent = this.fsw._getWatchedDir(dirname8);
     let prevStats = stats;
-    if (parent.has(basename4))
+    if (parent.has(basename5))
       return;
-    const listener = async (path20, newStats) => {
+    const listener = async (path22, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -184002,18 +184108,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path20);
+            this.fsw._closeFile(path22);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path20, closer2);
+              this.fsw._addPathCloser(path22, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname8, basename4);
+          this.fsw._remove(dirname8, basename5);
         }
-      } else if (parent.has(basename4)) {
+      } else if (parent.has(basename5)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -184038,7 +184144,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path20, item) {
+  async _handleSymlink(entry, directory, path22, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -184048,7 +184154,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path20);
+        linkPath = await fsrealpath(path22);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -184058,12 +184164,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path20, entry.stats);
+          this.fsw._emit(EV.CHANGE, path22, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path20, entry.stats);
+        this.fsw._emit(EV.ADD, path22, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -184093,9 +184199,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path20 = sp.join(directory, item);
+      let path22 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path20, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -184104,11 +184210,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path20 = sp.join(dir, sp.relative(dir, path20));
-        this._addToNodeFs(path20, initialAdd, wh, depth + 1);
+        path22 = sp.join(dir, sp.relative(dir, path22));
+        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -184117,7 +184223,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve4(void 0);
+        resolve5(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -184174,13 +184280,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path20, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path20) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path20);
+    const wh = this.fsw._getWatchHelpers(path22);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -184196,8 +184302,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path20);
-        const targetPath = follow ? await fsrealpath(path20) : path20;
+        const absPath = sp.resolve(path22);
+        const targetPath = follow ? await fsrealpath(path22) : path22;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -184207,29 +184313,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path20) : path20;
+        const targetPath = follow ? await fsrealpath(path22) : path22;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path20, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path20), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path20, closer);
+        this.fsw._addPathCloser(path22, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path20;
+        return path22;
       }
     }
   }
@@ -184272,24 +184378,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path20) {
-  if (typeof path20 !== "string")
+function normalizePath(path22) {
+  if (typeof path22 !== "string")
     throw new Error("string expected");
-  path20 = sp2.normalize(path20);
-  path20 = path20.replace(/\\/g, "/");
+  path22 = sp2.normalize(path22);
+  path22 = path22.replace(/\\/g, "/");
   let prepend = false;
-  if (path20.startsWith("//"))
+  if (path22.startsWith("//"))
     prepend = true;
-  path20 = path20.replace(DOUBLE_SLASH_RE, "/");
+  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path20 = "/" + path20;
-  return path20;
+    path22 = "/" + path22;
+  return path22;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path20 = normalizePath(testString);
+  const path22 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path20, stats)) {
+    if (pattern(path22, stats)) {
       return true;
     }
   }
@@ -184327,19 +184433,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path20) => toUnix(sp2.normalize(toUnix(path20)));
-var normalizeIgnored = (cwd = "") => (path20) => {
-  if (typeof path20 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path20) ? path20 : sp2.join(cwd, path20));
+var normalizePathToUnix = (path22) => toUnix(sp2.normalize(toUnix(path22)));
+var normalizeIgnored = (cwd = "") => (path22) => {
+  if (typeof path22 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path22) ? path22 : sp2.join(cwd, path22));
   } else {
-    return path20;
+    return path22;
   }
 };
-var getAbsolutePath = (path20, cwd) => {
-  if (sp2.isAbsolute(path20)) {
-    return path20;
+var getAbsolutePath = (path22, cwd) => {
+  if (sp2.isAbsolute(path22)) {
+    return path22;
   }
-  return sp2.join(cwd, path20);
+  return sp2.join(cwd, path22);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -184404,10 +184510,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path20, follow, fsw) {
+  constructor(path22, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path20;
-    this.path = path20 = path20.replace(REPLACER_RE, "");
+    const watchPath = path22;
+    this.path = path22 = path22.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -184547,20 +184653,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path20) => {
-        const absPath = getAbsolutePath(path20, cwd);
+      paths = paths.map((path22) => {
+        const absPath = getAbsolutePath(path22, cwd);
         return absPath;
       });
     }
-    paths.forEach((path20) => {
-      this._removeIgnoredPath(path20);
+    paths.forEach((path22) => {
+      this._removeIgnoredPath(path22);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path20) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path20, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path22) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -184582,17 +184688,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path20) => {
-      if (!sp2.isAbsolute(path20) && !this._closers.has(path20)) {
+    paths.forEach((path22) => {
+      if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
         if (cwd)
-          path20 = sp2.join(cwd, path20);
-        path20 = sp2.resolve(path20);
+          path22 = sp2.join(cwd, path22);
+        path22 = sp2.resolve(path22);
       }
-      this._closePath(path20);
-      this._addIgnoredPath(path20);
-      if (this._watched.has(path20)) {
+      this._closePath(path22);
+      this._addIgnoredPath(path22);
+      if (this._watched.has(path22)) {
         this._addIgnoredPath({
-          path: path20,
+          path: path22,
           recursive: true
         });
       }
@@ -184656,38 +184762,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path20, stats) {
+  async _emit(event, path22, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path20 = sp2.normalize(path20);
+      path22 = sp2.normalize(path22);
     if (opts.cwd)
-      path20 = sp2.relative(opts.cwd, path20);
-    const args = [path20];
+      path22 = sp2.relative(opts.cwd, path22);
+    const args = [path22];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path20))) {
+    if (awf && (pw = this._pendingWrites.get(path22))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path20, [event, ...args]);
+        this._pendingUnlinks.set(path22, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path21) => {
+          this._pendingUnlinks.forEach((entry, path23) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path21);
+            this._pendingUnlinks.delete(path23);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path20)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path20);
+        this._pendingUnlinks.delete(path22);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -184705,16 +184811,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path20, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path20, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path20) : path20;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path22) : path22;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -184745,23 +184851,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path20, timeout) {
+  _throttle(actionType, path22, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path20);
+    const actionPath = action.get(path22);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path20);
+      const item = action.get(path22);
       const count = item ? item.count : 0;
-      action.delete(path20);
+      action.delete(path22);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -184769,7 +184875,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path20, thr);
+    action.set(path22, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -184783,44 +184889,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path20, threshold, event, awfEmit) {
+  _awaitWriteFinish(path22, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path20;
-    if (this.options.cwd && !sp2.isAbsolute(path20)) {
-      fullPath = sp2.join(this.options.cwd, path20);
+    let fullPath = path22;
+    if (this.options.cwd && !sp2.isAbsolute(path22)) {
+      fullPath = sp2.join(this.options.cwd, path22);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path20)) {
+        if (err || !writes.has(path22)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path20).lastChange = now2;
+          writes.get(path22).lastChange = now2;
         }
-        const pw = writes.get(path20);
+        const pw = writes.get(path22);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path20);
+          writes.delete(path22);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path20)) {
-      writes.set(path20, {
+    if (!writes.has(path22)) {
+      writes.set(path22, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path20);
+          writes.delete(path22);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -184831,8 +184937,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path20, stats) {
-    if (this.options.atomic && DOT_RE.test(path20))
+  _isIgnored(path22, stats) {
+    if (this.options.atomic && DOT_RE.test(path22))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -184842,17 +184948,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path20, stats);
+    return this._userIgnored(path22, stats);
   }
-  _isntIgnored(path20, stat4) {
-    return !this._isIgnored(path20, stat4);
+  _isntIgnored(path22, stat4) {
+    return !this._isIgnored(path22, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path20) {
-    return new WatchHelper(path20, this.options.followSymlinks, this);
+  _getWatchHelpers(path22) {
+    return new WatchHelper(path22, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -184884,63 +184990,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path20 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path20);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path20) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path20, 100))
+    const path22 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path22);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path22, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path20);
+    const wp = this._getWatchedDir(path22);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path20, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path20;
+    let relPath = path22;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path20);
+      relPath = sp2.relative(this.options.cwd, path22);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path20);
+    this._watched.delete(path22);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path20))
-      this._emit(eventName, path20);
-    this._closePath(path20);
+    if (wasTracked && !this._isIgnored(path22))
+      this._emit(eventName, path22);
+    this._closePath(path22);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path20) {
-    this._closeFile(path20);
-    const dir = sp2.dirname(path20);
-    this._getWatchedDir(dir).remove(sp2.basename(path20));
+  _closePath(path22) {
+    this._closeFile(path22);
+    const dir = sp2.dirname(path22);
+    this._getWatchedDir(dir).remove(sp2.basename(path22));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path20) {
-    const closers = this._closers.get(path20);
+  _closeFile(path22) {
+    const closers = this._closers.get(path22);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path20);
+    this._closers.delete(path22);
   }
-  _addPathCloser(path20, closer) {
+  _addPathCloser(path22, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path20);
+    let list = this._closers.get(path22);
     if (!list) {
       list = [];
-      this._closers.set(path20, list);
+      this._closers.set(path22, list);
     }
     list.push(closer);
   }
@@ -184989,8 +185095,8 @@ var PortAllocator = class {
 };
 
 // src/lib/dev/stable-port-allocator.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 var PORT_RANGE_START2 = 4e4;
 var PORT_RANGE_END2 = 49999;
 var StablePortAllocator = class {
@@ -184998,17 +185104,17 @@ var StablePortAllocator = class {
   portsFilePath;
   savedPorts = {};
   usedPorts = /* @__PURE__ */ new Set();
-  constructor(projectRoot) {
-    this.portsDir = path4.join(projectRoot, ".specific");
-    this.portsFilePath = path4.join(this.portsDir, "ports.json");
+  constructor(projectRoot, key = "default") {
+    this.portsDir = path5.join(projectRoot, ".specific", "keys", key);
+    this.portsFilePath = path5.join(this.portsDir, "ports.json");
     this.loadPorts();
   }
   loadPorts() {
-    if (!fs4.existsSync(this.portsFilePath)) {
+    if (!fs5.existsSync(this.portsFilePath)) {
       return;
     }
     try {
-      const content = fs4.readFileSync(this.portsFilePath, "utf-8");
+      const content = fs5.readFileSync(this.portsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.ports) {
         this.savedPorts = data.ports;
@@ -185021,14 +185127,14 @@ var StablePortAllocator = class {
     }
   }
   savePorts() {
-    if (!fs4.existsSync(this.portsDir)) {
-      fs4.mkdirSync(this.portsDir, { recursive: true });
+    if (!fs5.existsSync(this.portsDir)) {
+      fs5.mkdirSync(this.portsDir, { recursive: true });
     }
     const data = {
       version: 1,
       ports: this.savedPorts
     };
-    fs4.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
+    fs5.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
   }
   allocateRandom() {
     const rangeSize = PORT_RANGE_END2 - PORT_RANGE_START2 + 1;
@@ -185054,10 +185160,10 @@ var StablePortAllocator = class {
 };
 
 // src/lib/dev/database-manager.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import * as net from "net";
-import * as os3 from "os";
+import * as os4 from "os";
 import { spawn } from "child_process";
 
 // src/lib/bin/types.ts
@@ -185095,17 +185201,17 @@ var ExtractionError = class extends Error {
 };
 
 // src/lib/bin/manager.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import * as os2 from "os";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
 import { createReadStream } from "fs";
 import { createTarExtractor, extractTo } from "tar-vern";
 function getBinBaseDir() {
-  return path5.join(os2.homedir(), ".specific", "bin");
+  return path6.join(os3.homedir(), ".specific", "bin");
 }
 function getPlatformInfo() {
-  const platform5 = os2.platform();
-  const arch3 = os2.arch();
+  const platform5 = os3.platform();
+  const arch3 = os3.arch();
   if (platform5 !== "darwin" && platform5 !== "linux") {
     throw new Error(
       `Unsupported platform: ${platform5}. Only macOS and Linux are supported.`
@@ -185124,7 +185230,7 @@ function getPlatformInfo() {
   return { platform: platform5, arch: mappedArch };
 }
 function getBinaryDir(definition, version, platformInfo) {
-  return path5.join(
+  return path6.join(
     getBinBaseDir(),
     definition.name,
     version,
@@ -185134,8 +185240,8 @@ function getBinaryDir(definition, version, platformInfo) {
 function isBinaryInstalled(definition, version, platformInfo) {
   const binDir = getBinaryDir(definition, version, platformInfo);
   for (const execPath of definition.executables) {
-    const fullPath = path5.join(binDir, execPath);
-    if (!fs5.existsSync(fullPath)) {
+    const fullPath = path6.join(binDir, execPath);
+    if (!fs6.existsSync(fullPath)) {
       return false;
     }
   }
@@ -185163,12 +185269,12 @@ async function downloadFile(url, destPath, onProgress) {
     10
   );
   let bytesDownloaded = 0;
-  const parentDir = path5.dirname(destPath);
-  if (!fs5.existsSync(parentDir)) {
-    fs5.mkdirSync(parentDir, { recursive: true });
+  const parentDir = path6.dirname(destPath);
+  if (!fs6.existsSync(parentDir)) {
+    fs6.mkdirSync(parentDir, { recursive: true });
   }
   const partPath = destPath + ".part";
-  const fileStream = fs5.createWriteStream(partPath);
+  const fileStream = fs6.createWriteStream(partPath);
   try {
     const reader = response.body.getReader();
     while (true) {
@@ -185185,18 +185291,18 @@ async function downloadFile(url, destPath, onProgress) {
         });
       }
     }
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       fileStream.end((err) => {
         if (err) reject(err);
-        else resolve4();
+        else resolve5();
       });
     });
-    fs5.renameSync(partPath, destPath);
+    fs6.renameSync(partPath, destPath);
   } catch (error) {
     try {
       fileStream.close();
-      if (fs5.existsSync(partPath)) {
-        fs5.unlinkSync(partPath);
+      if (fs6.existsSync(partPath)) {
+        fs6.unlinkSync(partPath);
       }
     } catch {
     }
@@ -185205,8 +185311,8 @@ async function downloadFile(url, destPath, onProgress) {
 }
 async function extractTarball(archivePath, destDir, definition, onProgress) {
   onProgress?.({ phase: "extracting" });
-  if (!fs5.existsSync(destDir)) {
-    fs5.mkdirSync(destDir, { recursive: true });
+  if (!fs6.existsSync(destDir)) {
+    fs6.mkdirSync(destDir, { recursive: true });
   }
   try {
     const fileStream = createReadStream(archivePath);
@@ -185214,9 +185320,9 @@ async function extractTarball(archivePath, destDir, definition, onProgress) {
     await extractTo(entries, destDir);
     onProgress?.({ phase: "finalizing" });
     for (const execPath of definition.executables) {
-      const fullPath = path5.join(destDir, execPath);
-      if (fs5.existsSync(fullPath)) {
-        fs5.chmodSync(fullPath, 493);
+      const fullPath = path6.join(destDir, execPath);
+      if (fs6.existsSync(fullPath)) {
+        fs6.chmodSync(fullPath, 493);
       }
     }
   } catch (error) {
@@ -185240,24 +185346,24 @@ async function ensureBinary(definition, version, onProgress) {
           `Binary type definitions must have exactly one executable, got ${definition.executables.length}`
         );
       }
-      if (!fs5.existsSync(binDir)) {
-        fs5.mkdirSync(binDir, { recursive: true });
+      if (!fs6.existsSync(binDir)) {
+        fs6.mkdirSync(binDir, { recursive: true });
       }
-      const execPath = path5.join(binDir, definition.executables[0]);
+      const execPath = path6.join(binDir, definition.executables[0]);
       await downloadFile(url, execPath, onProgress);
-      fs5.chmodSync(execPath, 493);
+      fs6.chmodSync(execPath, 493);
       onProgress?.({ phase: "finalizing" });
     } else {
-      const downloadDir = path5.join(getBinBaseDir(), "downloads");
+      const downloadDir = path6.join(getBinBaseDir(), "downloads");
       const archiveName = `${definition.name}-${resolvedVersion}-${platformInfo.platform}-${platformInfo.arch}.tar.gz`;
-      const archivePath = path5.join(downloadDir, archiveName);
+      const archivePath = path6.join(downloadDir, archiveName);
       try {
         await downloadFile(url, archivePath, onProgress);
         await extractTarball(archivePath, binDir, definition, onProgress);
       } finally {
         try {
-          if (fs5.existsSync(archivePath)) {
-            fs5.unlinkSync(archivePath);
+          if (fs6.existsSync(archivePath)) {
+            fs6.unlinkSync(archivePath);
           }
         } catch {
         }
@@ -185266,10 +185372,10 @@ async function ensureBinary(definition, version, onProgress) {
   }
   const executables = {};
   for (const execPath of definition.executables) {
-    const name = path5.basename(execPath);
-    executables[name] = path5.join(binDir, execPath);
+    const name = path6.basename(execPath);
+    executables[name] = path6.join(binDir, execPath);
   }
-  const libraryPath = definition.libraryDir ? path5.join(binDir, definition.libraryDir) : void 0;
+  const libraryPath = definition.libraryDir ? path6.join(binDir, definition.libraryDir) : void 0;
   return {
     rootDir: binDir,
     version: resolvedVersion,
@@ -185369,17 +185475,17 @@ var drizzleGatewayBinary = {
 };
 
 // src/lib/dev/debug-logger.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 var DEBUG_LOG_PATH = ".specific/debug.log";
 var logStream = null;
 function getLogStream() {
   if (logStream) {
     return logStream;
   }
-  const logPath = path6.join(process.cwd(), DEBUG_LOG_PATH);
-  fs6.mkdirSync(path6.dirname(logPath), { recursive: true });
-  logStream = fs6.createWriteStream(logPath, { flags: "a" });
+  const logPath = path7.join(process.cwd(), DEBUG_LOG_PATH);
+  fs7.mkdirSync(path7.dirname(logPath), { recursive: true });
+  logStream = fs7.createWriteStream(logPath, { flags: "a" });
   return logStream;
 }
 function writeLog(source, message) {
@@ -185422,7 +185528,7 @@ function getLibraryEnv(binary) {
   if (!binary.libraryPath) {
     return {};
   }
-  const platform5 = os3.platform();
+  const platform5 = os4.platform();
   if (platform5 === "darwin") {
     return { DYLD_LIBRARY_PATH: binary.libraryPath };
   } else if (platform5 === "linux") {
@@ -185432,15 +185538,15 @@ function getLibraryEnv(binary) {
 }
 async function startPostgres(pg, port, dataDir, onProgress) {
   const binary = await ensureBinary(postgresBinary, void 0, onProgress);
-  const dbDataPath = path7.join(process.cwd(), dataDir, pg.name);
+  const dbDataPath = path8.join(process.cwd(), dataDir, pg.name);
   const host = "127.0.0.1";
   const user = "postgres";
   const password = "postgres";
   const libraryEnv = getLibraryEnv(binary);
   const env2 = { ...process.env, ...libraryEnv };
-  const dataExists = fs7.existsSync(dbDataPath);
+  const dataExists = fs8.existsSync(dbDataPath);
   if (!dataExists) {
-    fs7.mkdirSync(dbDataPath, { recursive: true });
+    fs8.mkdirSync(dbDataPath, { recursive: true });
     await runCommand(
       binary.executables["initdb"],
       ["-D", dbDataPath, "-U", user, "--auth=trust", "--no-locale", "-E", "UTF8"],
@@ -185516,9 +185622,9 @@ async function startRedis(redis, port, onProgress) {
 }
 async function startStorage(storage, port, dataDir) {
   const S3rver = (await import("s3rver")).default;
-  const storageDataPath = path7.join(process.cwd(), dataDir, storage.name);
-  if (!fs7.existsSync(storageDataPath)) {
-    fs7.mkdirSync(storageDataPath, { recursive: true });
+  const storageDataPath = path8.join(process.cwd(), dataDir, storage.name);
+  if (!fs8.existsSync(storageDataPath)) {
+    fs8.mkdirSync(storageDataPath, { recursive: true });
   }
   const host = "127.0.0.1";
   const accessKey = "S3RVER";
@@ -185552,7 +185658,7 @@ async function startStorage(storage, port, dataDir) {
   };
 }
 async function runCommand(command, args, env2) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: env2
@@ -185563,7 +185669,7 @@ async function runCommand(command, args, env2) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve4();
+        resolve5();
       } else {
         reject(new Error(`Command failed with code ${code}: ${stderr}`));
       }
@@ -185572,7 +185678,7 @@ async function runCommand(command, args, env2) {
   });
 }
 async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = spawn(
       postgresPath,
       ["--single", "-D", dataDir, "postgres"],
@@ -185586,7 +185692,7 @@ async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      resolve4();
+      resolve5();
     });
     proc.on("error", reject);
     proc.stdin?.write(`CREATE DATABASE "${dbName}";
@@ -185606,33 +185712,33 @@ async function waitForTcpPort(host, port, timeoutMs = 3e4) {
   throw new Error(`Port ${port} did not become available within timeout`);
 }
 function checkTcpPort(host, port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const socket = new net.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve4(true);
+      resolve5(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve4(false);
+      resolve5(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve4(false);
+      resolve5(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess(proc) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve4();
+      resolve5();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve4();
+      resolve5();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -185643,7 +185749,7 @@ async function stopProcess(proc) {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
 // src/lib/dev/service-runner.ts
@@ -185652,9 +185758,9 @@ import { spawn as spawn2 } from "child_process";
 // src/lib/secrets/parser.ts
 var import_hcl2_json_parser2 = __toESM(require_dist(), 1);
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import * as path8 from "path";
-import * as crypto from "crypto";
+import { existsSync as existsSync9 } from "fs";
+import * as path9 from "path";
+import * as crypto2 from "crypto";
 var { parseToObject: parseToObject2 } = import_hcl2_json_parser2.default;
 var SECRETS_FILE = "specific.secrets";
 var GENERATED_SECRETS_FILE = ".specific/generated-secrets.json";
@@ -185672,7 +185778,7 @@ async function parseSecretsFile(content) {
   return secrets;
 }
 async function loadSecrets() {
-  if (!existsSync8(SECRETS_FILE)) {
+  if (!existsSync9(SECRETS_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile(SECRETS_FILE, "utf-8");
@@ -185680,7 +185786,7 @@ async function loadSecrets() {
 }
 function generateRandomString(length = 64) {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  const bytes = crypto.randomBytes(length);
+  const bytes = crypto2.randomBytes(length);
   let result = "";
   for (let i = 0; i < length; i++) {
     result += chars[bytes[i] % chars.length];
@@ -185688,7 +185794,7 @@ function generateRandomString(length = 64) {
   return result;
 }
 async function loadGeneratedSecrets() {
-  if (!existsSync8(GENERATED_SECRETS_FILE)) {
+  if (!existsSync9(GENERATED_SECRETS_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile(GENERATED_SECRETS_FILE, "utf-8");
@@ -185697,13 +185803,13 @@ async function loadGeneratedSecrets() {
 }
 async function saveGeneratedSecret(name, value) {
   let secrets = {};
-  if (existsSync8(GENERATED_SECRETS_FILE)) {
+  if (existsSync9(GENERATED_SECRETS_FILE)) {
     const content = await readFile(GENERATED_SECRETS_FILE, "utf-8");
     secrets = JSON.parse(content);
   }
   secrets[name] = value;
-  const dir = path8.dirname(GENERATED_SECRETS_FILE);
-  if (!existsSync8(dir)) {
+  const dir = path9.dirname(GENERATED_SECRETS_FILE);
+  if (!existsSync9(dir)) {
     await mkdir(dir, { recursive: true });
   }
   await writeFile(GENERATED_SECRETS_FILE, JSON.stringify(secrets, null, 2) + "\n");
@@ -185733,7 +185839,7 @@ async function prepareSecrets(secretsConfig) {
 // src/lib/config/parser.ts
 var import_hcl2_json_parser3 = __toESM(require_dist(), 1);
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 var { parseToObject: parseToObject3 } = import_hcl2_json_parser3.default;
 var CONFIG_FILE = "specific.config";
 async function parseConfigFile(content) {
@@ -185750,7 +185856,7 @@ async function parseConfigFile(content) {
   return configs;
 }
 async function loadConfigs() {
-  if (!existsSync9(CONFIG_FILE)) {
+  if (!existsSync10(CONFIG_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile2(CONFIG_FILE, "utf-8");
@@ -186041,14 +186147,14 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     ports: endpointPorts,
     process: child,
     async stop() {
-      return new Promise((resolve4) => {
+      return new Promise((resolve5) => {
         if (child.killed || child.exitCode !== null) {
-          resolve4();
+          resolve5();
           return;
         }
         child.once("exit", () => {
           clearTimeout(forceKillTimeout);
-          resolve4();
+          resolve5();
         });
         child.kill("SIGTERM");
         const forceKillTimeout = setTimeout(() => {
@@ -186062,21 +186168,26 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
 }
 
 // src/lib/dev/instance-state.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 var InstanceStateManager = class {
   stateDir;
   statePath;
   lockPath;
   ownsInstances = false;
-  constructor(projectRoot) {
-    this.stateDir = path9.join(projectRoot, ".specific");
-    this.statePath = path9.join(this.stateDir, "state.json");
-    this.lockPath = path9.join(this.stateDir, "state.lock");
+  key;
+  constructor(projectRoot, key = "default") {
+    this.key = key;
+    this.stateDir = path10.join(projectRoot, ".specific", "keys", key);
+    this.statePath = path10.join(this.stateDir, "state.json");
+    this.lockPath = path10.join(this.stateDir, "state.lock");
+  }
+  getKey() {
+    return this.key;
   }
   ensureStateDir() {
-    if (!fs8.existsSync(this.stateDir)) {
-      fs8.mkdirSync(this.stateDir, { recursive: true });
+    if (!fs9.existsSync(this.stateDir)) {
+      fs9.mkdirSync(this.stateDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -186093,15 +186204,15 @@ var InstanceStateManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs8.openSync(
+        const fd = fs9.openSync(
           this.lockPath,
-          fs8.constants.O_CREAT | fs8.constants.O_EXCL | fs8.constants.O_WRONLY
+          fs9.constants.O_CREAT | fs9.constants.O_EXCL | fs9.constants.O_WRONLY
         );
-        fs8.writeSync(fd, String(process.pid));
-        fs8.closeSync(fd);
+        fs9.writeSync(fd, String(process.pid));
+        fs9.closeSync(fd);
         return () => {
           try {
-            fs8.unlinkSync(this.lockPath);
+            fs9.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -186110,21 +186221,21 @@ var InstanceStateManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs8.readFileSync(this.lockPath, "utf-8").trim(),
+              fs9.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs8.unlinkSync(this.lockPath);
+              fs9.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs8.unlinkSync(this.lockPath);
+              fs9.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
           }
-          await new Promise((resolve4) => setTimeout(resolve4, 100));
+          await new Promise((resolve5) => setTimeout(resolve5, 100));
         } else {
           throw e;
         }
@@ -186133,12 +186244,12 @@ var InstanceStateManager = class {
     throw new Error("Failed to acquire state lock (timeout)");
   }
   async getExistingInstances() {
-    if (!fs8.existsSync(this.statePath)) {
+    if (!fs9.existsSync(this.statePath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs8.readFileSync(this.statePath, "utf-8");
+      const content = fs9.readFileSync(this.statePath, "utf-8");
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
         return null;
@@ -186151,21 +186262,21 @@ var InstanceStateManager = class {
     }
   }
   async cleanStaleState() {
-    if (!fs8.existsSync(this.statePath)) {
+    if (!fs9.existsSync(this.statePath)) {
       return false;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs8.readFileSync(this.statePath, "utf-8");
+      const content = fs9.readFileSync(this.statePath, "utf-8");
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
-        fs8.unlinkSync(this.statePath);
+        fs9.unlinkSync(this.statePath);
         return true;
       }
       return false;
     } catch {
       try {
-        fs8.unlinkSync(this.statePath);
+        fs9.unlinkSync(this.statePath);
         return true;
       } catch {
       }
@@ -186177,8 +186288,8 @@ var InstanceStateManager = class {
   async claimOwnership(command) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs8.existsSync(this.statePath)) {
-        const content = fs8.readFileSync(this.statePath, "utf-8");
+      if (fs9.existsSync(this.statePath)) {
+        const content = fs9.readFileSync(this.statePath, "utf-8");
         const state2 = JSON.parse(content);
         if (this.isProcessRunning(state2.owner.pid)) {
           throw new Error(`Instances already owned by PID ${state2.owner.pid}`);
@@ -186247,8 +186358,8 @@ var InstanceStateManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs8.existsSync(this.statePath)) {
-        fs8.unlinkSync(this.statePath);
+      if (fs9.existsSync(this.statePath)) {
+        fs9.unlinkSync(this.statePath);
       }
       this.ownsInstances = false;
     } finally {
@@ -186256,31 +186367,31 @@ var InstanceStateManager = class {
     }
   }
   readState() {
-    const content = fs8.readFileSync(this.statePath, "utf-8");
+    const content = fs9.readFileSync(this.statePath, "utf-8");
     return JSON.parse(content);
   }
   writeStateAtomic(state) {
     this.ensureStateDir();
     const tmpPath = this.statePath + ".tmp";
-    fs8.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs8.renameSync(tmpPath, this.statePath);
+    fs9.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs9.renameSync(tmpPath, this.statePath);
   }
 };
 
 // src/lib/dev/http-proxy.ts
 import * as http from "http";
 import * as https from "https";
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import httpProxy from "http-proxy";
-var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
-var adminDir = path10.join(__dirname2, "admin");
+var __dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
+var adminDir = path11.join(__dirname2, "admin");
 var HTTP_PORT = 80;
 var HTTPS_PORT = 443;
 var DOMAIN_SUFFIX = ".local.spcf.app";
 var ADMIN_DOMAIN = "local.spcf.app";
-var DRIZZLE_GATEWAY_DOMAIN = "__drizzle_gateway.local.spcf.app";
+var DRIZZLE_GATEWAY_PREFIX = "__drizzle_gateway";
 var MIME_TYPES = {
   ".html": "text/html",
   ".css": "text/css",
@@ -186295,11 +186406,31 @@ var MIME_TYPES = {
   ".woff2": "font/woff2",
   ".txt": "text/plain"
 };
-async function startHttpProxy(services, certificate, getState, drizzleGatewayPort) {
+async function startHttpProxy(services, certificate, getState, instanceKey = "default") {
   const serviceMap = /* @__PURE__ */ new Map();
+  const adminPortMap = /* @__PURE__ */ new Map();
+  const drizzleGatewayPortMap = /* @__PURE__ */ new Map();
+  const buildMapKey = (serviceName, key) => {
+    return key === "default" ? serviceName : `${serviceName}.${key}`;
+  };
   for (const svc of services) {
-    serviceMap.set(svc.name, svc.port);
+    serviceMap.set(buildMapKey(svc.name, instanceKey), svc.port);
   }
+  const updateServices = (registryServices, keys) => {
+    serviceMap.clear();
+    adminPortMap.clear();
+    drizzleGatewayPortMap.clear();
+    for (const svc of registryServices) {
+      serviceMap.set(buildMapKey(svc.serviceName, svc.key), svc.port);
+    }
+    for (const [key, registration] of Object.entries(keys)) {
+      adminPortMap.set(key, registration.adminPort);
+      if (registration.drizzleGatewayPort !== void 0) {
+        drizzleGatewayPortMap.set(key, registration.drizzleGatewayPort);
+      }
+    }
+    writeLog("proxy", `Updated service map: ${serviceMap.size} services, ${adminPortMap.size} admin instances, ${drizzleGatewayPortMap.size} drizzle gateways`);
+  };
   const { key: defaultKey, cert: defaultCert } = certificate;
   const proxy = httpProxy.createProxyServer({});
   proxy.on("error", (err, req, res) => {
@@ -186312,39 +186443,65 @@ async function startHttpProxy(services, certificate, getState, drizzleGatewayPor
   });
   const handleRequest = (req, res) => {
     const host = req.headers.host || "";
-    const hostname = host.split(":")[0];
-    if (hostname === ADMIN_DOMAIN) {
-      return handleAdminRequest(req, res, proxy, getState);
-    }
-    if (hostname === DRIZZLE_GATEWAY_DOMAIN && drizzleGatewayPort) {
-      proxy.web(req, res, {
-        target: `http://127.0.0.1:${drizzleGatewayPort}`
-      });
+    const hostname2 = host.split(":")[0];
+    const drizzleKey = extractDrizzleGatewayKey(host);
+    if (drizzleKey !== null) {
+      const drizzlePort = drizzleGatewayPortMap.get(drizzleKey);
+      if (drizzlePort) {
+        proxy.web(req, res, {
+          target: `http://127.0.0.1:${drizzlePort}`
+        });
+        return;
+      }
+      res.writeHead(503, { "Content-Type": "text/html" });
+      res.end("<h1>Database Viewer</h1><p>No database viewer running for this instance.</p>");
       return;
     }
-    const serviceName = extractServiceName(host);
-    if (!serviceName) {
-      return sendNotFound(res, null, services);
+    const adminKey = extractAdminKey(host);
+    if (adminKey !== null) {
+      const adminPort = adminPortMap.get(adminKey);
+      if (adminPort) {
+        const url = new URL(req.url || "/", "http://localhost");
+        if (url.pathname.startsWith("/api/")) {
+          proxy.web(req, res, { target: `http://127.0.0.1:${adminPort}` });
+          return;
+        }
+        serveStaticFile(res, url.pathname);
+        return;
+      }
+      if (adminKey === "default" && hostname2 === ADMIN_DOMAIN) {
+        res.writeHead(503, { "Content-Type": "text/html" });
+        res.end("<h1>Admin UI</h1><p>No dev instance running. Start <code>specific dev</code> first.</p>");
+        return;
+      }
+    }
+    const route = extractServiceAndKey(host);
+    if (!route) {
+      return sendNotFound(res, null, serviceMap);
     }
-    const targetPort = serviceMap.get(serviceName);
+    const mapKey = buildMapKey(route.serviceName, route.key);
+    const targetPort = serviceMap.get(mapKey);
     if (!targetPort) {
-      return sendNotFound(res, serviceName, services);
+      return sendNotFound(res, route.serviceName, serviceMap);
     }
     proxy.web(req, res, { target: `http://127.0.0.1:${targetPort}` });
   };
   const handleUpgrade = (req, socket, head) => {
     const host = req.headers.host || "";
-    const hostname = host.split(":")[0];
-    if (hostname === ADMIN_DOMAIN) {
-      socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
-      return;
+    const adminKey = extractAdminKey(host);
+    if (adminKey !== null) {
+      if (adminPortMap.has(adminKey)) {
+        socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
+        return;
+      }
     }
-    const serviceName = extractServiceName(host);
-    if (!serviceName) {
+    const route = extractServiceAndKey(host);
+    if (!route) {
       socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
       return;
     }
-    const targetPort = serviceMap.get(serviceName);
+    const mapKey = buildMapKey(route.serviceName, route.key);
+    const targetPort = serviceMap.get(mapKey);
     if (!targetPort) {
       socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
       return;
@@ -186361,7 +186518,7 @@ async function startHttpProxy(services, certificate, getState, drizzleGatewayPor
     handleRequest
   );
   httpsServer.on("upgrade", handleUpgrade);
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let httpStarted = false;
     let httpsStarted = false;
     let failed = false;
@@ -186372,17 +186529,25 @@ async function startHttpProxy(services, certificate, getState, drizzleGatewayPor
           "proxy",
           `HTTP/HTTPS proxy started on ports ${HTTP_PORT}/${HTTPS_PORT}`
         );
-        resolve4({
+        resolve5({
           httpPort: HTTP_PORT,
           httpsPort: HTTPS_PORT,
+          updateServices,
+          updateCertificate(newCert) {
+            httpsServer.setSecureContext({
+              key: newCert.key,
+              cert: newCert.cert
+            });
+            writeLog("proxy", "Certificate updated");
+          },
           async stop() {
-            return new Promise((resolve5) => {
+            return new Promise((resolve6) => {
               let closed = 0;
               const onClose = () => {
                 closed++;
                 if (closed === 2) {
                   clearTimeout(forceCloseTimeout);
-                  resolve5();
+                  resolve6();
                 }
               };
               httpServer.close(onClose);
@@ -186390,7 +186555,7 @@ async function startHttpProxy(services, certificate, getState, drizzleGatewayPor
               const forceCloseTimeout = setTimeout(() => {
                 httpServer.closeAllConnections?.();
                 httpsServer.closeAllConnections?.();
-                resolve5();
+                resolve6();
               }, 2e3);
             });
           }
@@ -186424,15 +186589,70 @@ async function startHttpProxy(services, certificate, getState, drizzleGatewayPor
     });
   });
 }
-function extractServiceName(host) {
-  const hostname = host.split(":")[0];
-  if (!hostname || !hostname.endsWith(DOMAIN_SUFFIX)) {
+function extractServiceAndKey(host) {
+  const hostname2 = host.split(":")[0];
+  if (!hostname2 || !hostname2.endsWith(DOMAIN_SUFFIX)) {
     return null;
   }
-  return hostname.slice(0, -DOMAIN_SUFFIX.length);
+  const prefix = hostname2.slice(0, -DOMAIN_SUFFIX.length);
+  if (!prefix) {
+    return null;
+  }
+  const parts = prefix.split(".");
+  if (parts.length === 1) {
+    return { serviceName: parts[0], key: "default" };
+  } else if (parts.length === 2) {
+    return { serviceName: parts[0], key: parts[1] };
+  }
+  return null;
 }
-function sendNotFound(res, requestedService, availableServices) {
-  const serviceList = availableServices.map((s) => `<li>${s.name}.local.spcf.app</li>`).join("\n");
+function extractDrizzleGatewayKey(host) {
+  const hostname2 = host.split(":")[0];
+  if (!hostname2 || !hostname2.endsWith(DOMAIN_SUFFIX)) {
+    return null;
+  }
+  const prefix = hostname2.slice(0, -DOMAIN_SUFFIX.length);
+  if (!prefix) {
+    return null;
+  }
+  const parts = prefix.split(".");
+  if (parts.length === 1 && parts[0] === DRIZZLE_GATEWAY_PREFIX) {
+    return "default";
+  } else if (parts.length === 2 && parts[0] === DRIZZLE_GATEWAY_PREFIX) {
+    return parts[1];
+  }
+  return null;
+}
+function extractAdminKey(host) {
+  const hostname2 = host.split(":")[0];
+  if (!hostname2) {
+    return null;
+  }
+  if (hostname2 === ADMIN_DOMAIN) {
+    return "default";
+  }
+  if (!hostname2.endsWith(DOMAIN_SUFFIX)) {
+    return null;
+  }
+  const prefix = hostname2.slice(0, -DOMAIN_SUFFIX.length);
+  if (!prefix) {
+    return null;
+  }
+  const parts = prefix.split(".");
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  return null;
+}
+function sendNotFound(res, requestedService, serviceMap) {
+  const serviceList = Array.from(serviceMap.keys()).map((key) => {
+    const parts = key.split(".");
+    if (parts.length === 1) {
+      return `<li>${parts[0]}.local.spcf.app</li>`;
+    } else {
+      return `<li>${key}.local.spcf.app</li>`;
+    }
+  }).join("\n");
   const message = requestedService ? `No service named "${requestedService}" is running.` : "Invalid host header.";
   res.writeHead(404, { "Content-Type": "text/html" });
   res.end(`<!DOCTYPE html>
@@ -186441,61 +186661,36 @@ function sendNotFound(res, requestedService, availableServices) {
 <body>
   <h1>Service Not Found</h1>
   <p>${message}</p>
-  ${availableServices.length > 0 ? `<p>Available services:</p>
+  ${serviceMap.size > 0 ? `<p>Available services:</p>
   <ul>${serviceList}</ul>` : "<p>No services are currently exposed.</p>"}
 </body>
 </html>`);
 }
-function handleAdminRequest(req, res, proxy, getState) {
-  const url = new URL(req.url || "/", "http://localhost");
-  if (url.pathname.startsWith("/api/")) {
-    return handleAdminApi(req, res, url, getState);
-  }
-  serveStaticFile(res, url.pathname);
-}
-function handleAdminApi(_req, res, url, getState) {
-  res.setHeader("Content-Type", "application/json");
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  const pathname = url.pathname.endsWith("/") && url.pathname.length > 1 ? url.pathname.slice(0, -1) : url.pathname;
-  if (pathname === "/api/state") {
-    if (!getState) {
-      res.writeHead(500);
-      res.end(JSON.stringify({ error: "State not available" }));
-      return;
-    }
-    const state = getState();
-    res.writeHead(200);
-    res.end(JSON.stringify(state));
-    return;
-  }
-  res.writeHead(404);
-  res.end(JSON.stringify({ error: "Not found" }));
-}
 function serveStaticFile(res, pathname) {
   let filePath = pathname;
   if (filePath === "/" || filePath.endsWith("/")) {
     filePath = filePath + "index.html";
   }
   const relativePath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path10.join(adminDir, relativePath);
-  const resolvedPath = path10.resolve(fullPath);
-  const resolvedAdminDir = path10.resolve(adminDir);
+  const fullPath = path11.join(adminDir, relativePath);
+  const resolvedPath = path11.resolve(fullPath);
+  const resolvedAdminDir = path11.resolve(adminDir);
   if (!resolvedPath.startsWith(resolvedAdminDir)) {
     res.writeHead(403, { "Content-Type": "text/html" });
     res.end("<h1>Forbidden</h1>");
     return;
   }
-  if (!fs9.existsSync(resolvedPath)) {
+  if (!fs10.existsSync(resolvedPath)) {
     const htmlPath = resolvedPath + ".html";
-    if (fs9.existsSync(htmlPath)) {
+    if (fs10.existsSync(htmlPath)) {
       return serveFile(res, htmlPath);
     }
-    const indexPath = path10.join(resolvedPath, "index.html");
-    if (fs9.existsSync(indexPath)) {
+    const indexPath = path11.join(resolvedPath, "index.html");
+    if (fs10.existsSync(indexPath)) {
       return serveFile(res, indexPath);
     }
-    const notFoundPath = path10.join(adminDir, "404.html");
-    if (fs9.existsSync(notFoundPath)) {
+    const notFoundPath = path11.join(adminDir, "404.html");
+    if (fs10.existsSync(notFoundPath)) {
       return serveFileContent(res, notFoundPath, "text/html", 404);
     }
     res.writeHead(404, { "Content-Type": "text/html" });
@@ -186505,13 +186700,13 @@ function serveStaticFile(res, pathname) {
   serveFile(res, resolvedPath);
 }
 function serveFile(res, filePath) {
-  const ext = path10.extname(filePath).toLowerCase();
+  const ext = path11.extname(filePath).toLowerCase();
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
   serveFileContent(res, filePath, contentType, 200);
 }
 function serveFileContent(res, filePath, contentType, statusCode = 200) {
   try {
-    const content = fs9.readFileSync(filePath);
+    const content = fs10.readFileSync(filePath);
     res.writeHead(statusCode, { "Content-Type": contentType });
     res.end(content);
   } catch (err) {
@@ -186522,6 +186717,48 @@ function serveFileContent(res, filePath, contentType, statusCode = 200) {
     res.end("<h1>Internal Server Error</h1>");
   }
 }
+async function startAdminServer(getState) {
+  return new Promise((resolve5, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "/", "http://localhost");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      const pathname = url.pathname.endsWith("/") && url.pathname.length > 1 ? url.pathname.slice(0, -1) : url.pathname;
+      if (pathname === "/api/state") {
+        res.setHeader("Content-Type", "application/json");
+        const state = getState();
+        res.writeHead(200);
+        res.end(JSON.stringify(state));
+        return;
+      }
+      res.setHeader("Content-Type", "application/json");
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "Not found" }));
+    });
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = addr.port;
+      writeLog("admin", `Admin API server started on port ${port}`);
+      resolve5({
+        port,
+        stop: () => new Promise((res, rej) => {
+          server.close((err) => err ? rej(err) : res());
+        })
+      });
+    });
+  });
+}
 
 // src/lib/dev/electric-manager.ts
 import * as net2 from "net";
@@ -186579,33 +186816,33 @@ async function waitForTcpPort2(host, port, timeoutMs = 3e4) {
   throw new Error(`Electric port ${port} did not become available within timeout`);
 }
 function checkTcpPort2(host, port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const socket = new net2.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve4(true);
+      resolve5(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve4(false);
+      resolve5(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve4(false);
+      resolve5(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess2(proc) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve4();
+      resolve5();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve4();
+      resolve5();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -186616,13 +186853,13 @@ async function stopProcess2(proc) {
   });
 }
 function sleep2(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
 // src/lib/dev/drizzle-gateway-manager.ts
 import * as net3 from "net";
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import { spawn as spawn4 } from "child_process";
 import { randomUUID } from "crypto";
 function generateStoreJson(postgresInstances) {
@@ -186654,13 +186891,13 @@ async function startDrizzleGateway(postgresInstances, port, configDir, options2)
     options2?.onProgress
   );
   const host = "127.0.0.1";
-  const drizzleConfigDir = path11.join(configDir, "drizzle-gateway");
-  if (!fs10.existsSync(drizzleConfigDir)) {
-    fs10.mkdirSync(drizzleConfigDir, { recursive: true });
+  const drizzleConfigDir = path12.join(configDir, "drizzle-gateway");
+  if (!fs11.existsSync(drizzleConfigDir)) {
+    fs11.mkdirSync(drizzleConfigDir, { recursive: true });
   }
   const storeJson = generateStoreJson(postgresInstances);
-  const storeJsonPath = path11.join(drizzleConfigDir, "store.json");
-  fs10.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
+  const storeJsonPath = path12.join(drizzleConfigDir, "store.json");
+  fs11.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
   writeLog("drizzle-gateway", `Starting Drizzle Gateway`);
   writeLog("drizzle-gateway", `STORE_PATH: ${drizzleConfigDir}`);
   writeLog("drizzle-gateway", `PORT: ${port}`);
@@ -186700,33 +186937,33 @@ async function waitForTcpPort3(host, port, timeoutMs = 3e4) {
   );
 }
 function checkTcpPort3(host, port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const socket = new net3.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve4(true);
+      resolve5(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve4(false);
+      resolve5(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve4(false);
+      resolve5(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess3(proc) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve4();
+      resolve5();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve4();
+      resolve5();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -186737,7 +186974,7 @@ async function stopProcess3(proc) {
   });
 }
 function sleep3(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
 // src/lib/dev/sync-detector.ts
@@ -186928,19 +187165,345 @@ function watchConfigFile(configPath, debounceMs, onChange) {
   };
 }
 
+// src/lib/dev/proxy-registry.ts
+import * as fs12 from "fs";
+import * as path13 from "path";
+import * as os5 from "os";
+var ProxyRegistryManager = class {
+  proxyDir;
+  ownerPath;
+  registryPath;
+  lockPath;
+  isOwner = false;
+  registryWatcher = null;
+  constructor() {
+    this.proxyDir = path13.join(os5.homedir(), ".specific", "proxy");
+    this.ownerPath = path13.join(this.proxyDir, "owner.json");
+    this.registryPath = path13.join(this.proxyDir, "registry.json");
+    this.lockPath = path13.join(this.proxyDir, "registry.lock");
+  }
+  ensureProxyDir() {
+    if (!fs12.existsSync(this.proxyDir)) {
+      fs12.mkdirSync(this.proxyDir, { recursive: true });
+    }
+  }
+  isProcessRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (e) {
+      const err = e;
+      return err.code !== "ESRCH";
+    }
+  }
+  async acquireLock(timeoutMs = 5e3) {
+    this.ensureProxyDir();
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const fd = fs12.openSync(
+          this.lockPath,
+          fs12.constants.O_CREAT | fs12.constants.O_EXCL | fs12.constants.O_WRONLY
+        );
+        fs12.writeSync(fd, String(process.pid));
+        fs12.closeSync(fd);
+        return () => {
+          try {
+            fs12.unlinkSync(this.lockPath);
+          } catch {
+          }
+        };
+      } catch (e) {
+        const err = e;
+        if (err.code === "EEXIST") {
+          try {
+            const lockPid = parseInt(
+              fs12.readFileSync(this.lockPath, "utf-8").trim(),
+              10
+            );
+            if (!this.isProcessRunning(lockPid)) {
+              fs12.unlinkSync(this.lockPath);
+              continue;
+            }
+          } catch {
+            try {
+              fs12.unlinkSync(this.lockPath);
+            } catch {
+            }
+            continue;
+          }
+          await new Promise((resolve5) => setTimeout(resolve5, 100));
+        } else {
+          throw e;
+        }
+      }
+    }
+    throw new Error("Failed to acquire proxy registry lock (timeout)");
+  }
+  /**
+   * Try to claim ownership of the proxy.
+   * Returns true if this process is now the owner.
+   */
+  async claimProxyOwnership(key) {
+    const releaseLock = await this.acquireLock();
+    try {
+      if (fs12.existsSync(this.ownerPath)) {
+        const content = fs12.readFileSync(this.ownerPath, "utf-8");
+        const ownerFile2 = JSON.parse(content);
+        if (this.isProcessRunning(ownerFile2.owner.pid)) {
+          return false;
+        }
+      }
+      const ownerFile = {
+        version: 1,
+        owner: {
+          pid: process.pid,
+          key,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      this.writeFileAtomic(this.ownerPath, ownerFile);
+      this.isOwner = true;
+      return true;
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Release ownership of the proxy.
+   */
+  async releaseProxyOwnership() {
+    if (!this.isOwner) {
+      return;
+    }
+    const releaseLock = await this.acquireLock();
+    try {
+      if (fs12.existsSync(this.ownerPath)) {
+        const content = fs12.readFileSync(this.ownerPath, "utf-8");
+        const ownerFile = JSON.parse(content);
+        if (ownerFile.owner.pid === process.pid) {
+          fs12.unlinkSync(this.ownerPath);
+        }
+      }
+      this.isOwner = false;
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Get the current proxy owner.
+   */
+  async getProxyOwner() {
+    if (!fs12.existsSync(this.ownerPath)) {
+      return null;
+    }
+    const releaseLock = await this.acquireLock();
+    try {
+      const content = fs12.readFileSync(this.ownerPath, "utf-8");
+      const ownerFile = JSON.parse(content);
+      if (!this.isProcessRunning(ownerFile.owner.pid)) {
+        return null;
+      }
+      return ownerFile.owner;
+    } catch {
+      return null;
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Check if this process is the proxy owner.
+   */
+  isProxyOwner() {
+    return this.isOwner;
+  }
+  /**
+   * Register services for a key.
+   */
+  async registerServices(key, adminPort, services, drizzleGatewayPort) {
+    const releaseLock = await this.acquireLock();
+    try {
+      const registry = this.readRegistry();
+      const registration = {
+        adminPort,
+        services
+      };
+      if (drizzleGatewayPort !== void 0) {
+        registration.drizzleGatewayPort = drizzleGatewayPort;
+      }
+      registry.keys[key] = registration;
+      registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      this.writeFileAtomic(this.registryPath, registry);
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Unregister all services for a key.
+   */
+  async unregisterServices(key) {
+    const releaseLock = await this.acquireLock();
+    try {
+      const registry = this.readRegistry();
+      delete registry.keys[key];
+      registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      this.writeFileAtomic(this.registryPath, registry);
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Get all registered services (flattened view for proxy routing).
+   */
+  async getAllServices() {
+    const releaseLock = await this.acquireLock();
+    try {
+      const registry = this.readRegistry();
+      const services = [];
+      for (const [key, registration] of Object.entries(registry.keys)) {
+        for (const svc of registration.services) {
+          services.push({
+            key,
+            serviceName: svc.serviceName,
+            port: svc.port
+          });
+        }
+      }
+      return services;
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Get all registered keys and their admin ports.
+   */
+  async getAllKeyRegistrations() {
+    const releaseLock = await this.acquireLock();
+    try {
+      const registry = this.readRegistry();
+      return { ...registry.keys };
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Watch the registry for changes. Returns a cleanup function.
+   * Callback receives both the flattened services list and all key registrations (for admin ports).
+   * Uses chokidar instead of fs.watch for reliable detection of atomic file writes on macOS.
+   */
+  watchRegistry(onChange) {
+    this.ensureProxyDir();
+    if (!fs12.existsSync(this.registryPath)) {
+      const emptyRegistry = {
+        version: 1,
+        keys: {},
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.writeFileAtomic(this.registryPath, emptyRegistry);
+    }
+    let debounceTimer = null;
+    this.registryWatcher = chokidar_default.watch(this.registryPath, {
+      persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    this.registryWatcher.on("change", async () => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(async () => {
+        try {
+          const services = await this.getAllServices();
+          const keys = await this.getAllKeyRegistrations();
+          onChange(services, keys);
+        } catch {
+        }
+      }, 50);
+    });
+    return () => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      this.registryWatcher?.close();
+      this.registryWatcher = null;
+    };
+  }
+  /**
+   * Attempt to become the proxy owner (election).
+   * This is called when the current owner is detected as dead.
+   */
+  async attemptElection(key) {
+    const releaseLock = await this.acquireLock();
+    try {
+      if (fs12.existsSync(this.ownerPath)) {
+        const content = fs12.readFileSync(this.ownerPath, "utf-8");
+        const ownerFile2 = JSON.parse(content);
+        if (this.isProcessRunning(ownerFile2.owner.pid)) {
+          return false;
+        }
+        fs12.unlinkSync(this.ownerPath);
+      }
+      const ownerFile = {
+        version: 1,
+        owner: {
+          pid: process.pid,
+          key,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      this.writeFileAtomic(this.ownerPath, ownerFile);
+      this.isOwner = true;
+      return true;
+    } finally {
+      releaseLock();
+    }
+  }
+  readRegistry() {
+    if (!fs12.existsSync(this.registryPath)) {
+      return {
+        version: 1,
+        keys: {},
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    try {
+      const content = fs12.readFileSync(this.registryPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {
+        version: 1,
+        keys: {},
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  writeFileAtomic(filePath, data) {
+    this.ensureProxyDir();
+    const tmpPath = filePath + ".tmp";
+    fs12.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs12.renameSync(tmpPath, filePath);
+  }
+};
+
 // src/commands/dev.tsx
 var COLORS = ["cyan", "yellow", "green", "magenta", "blue"];
-function DevUI() {
+function DevUI({ instanceKey }) {
   const { exit } = useApp2();
-  const [state, setState] = useState3(() => ({
-    status: caFilesExist() ? "loading" : "installing-ca",
-    caInstallPhase: caFilesExist() ? void 0 : "installing",
-    resources: /* @__PURE__ */ new Map(),
-    resourceStatus: /* @__PURE__ */ new Map(),
-    services: [],
-    output: [],
-    colorMap: /* @__PURE__ */ new Map()
-  }));
+  const [state, setState] = useState3(() => {
+    const caExists = caFilesExist();
+    return {
+      status: caExists ? "loading" : "installing-ca",
+      ...caExists ? {} : { caInstallPhase: "installing" },
+      resources: /* @__PURE__ */ new Map(),
+      resourceStatus: /* @__PURE__ */ new Map(),
+      services: [],
+      output: [],
+      colorMap: /* @__PURE__ */ new Map(),
+      isProxyOwner: false
+    };
+  });
   useEffect3(() => {
     if (state.status === "installing-ca" && state.caInstallPhase === "installing") {
       installCA();
@@ -186963,22 +187526,39 @@ function DevUI() {
     }
   }
   const shuttingDown = useRef(false);
+  const startTimeRef = useRef(null);
   const stateManagerRef = useRef(null);
+  const proxyRegistryRef = useRef(null);
   const electricInstancesRef = useRef([]);
   const drizzleGatewayRef = useRef(null);
+  const registryWatcherCleanupRef = useRef(null);
+  const electionIntervalRef = useRef(null);
   const proxyRef = useRef(null);
+  const adminServerRef = useRef(null);
   const servicesRef = useRef([]);
   const resourcesRef = useRef(/* @__PURE__ */ new Map());
   const [reloadTrigger, setReloadTrigger] = useState3(0);
   const [readyToStart, setReadyToStart] = useState3(() => caFilesExist());
-  const shutdown = async () => {
+  const shutdown2 = async () => {
     if (shuttingDown.current) return;
     shuttingDown.current = true;
+    const duration = startTimeRef.current ? Math.round((Date.now() - startTimeRef.current) / 1e3) : void 0;
+    trackEvent("dev_stopped", { duration_seconds: duration });
     writeLog("system", "Shutting down");
     setState((s) => ({ ...s, status: "stopping" }));
+    if (electionIntervalRef.current) {
+      clearInterval(electionIntervalRef.current);
+      electionIntervalRef.current = null;
+    }
+    if (registryWatcherCleanupRef.current) {
+      registryWatcherCleanupRef.current();
+      registryWatcherCleanupRef.current = null;
+    }
     await Promise.all([
       // Stop proxy
       proxyRef.current?.stop(),
+      // Stop admin server
+      adminServerRef.current?.stop(),
       // Stop all services
       ...servicesRef.current.map((service) => service.stop()),
       // Stop all Electric instances
@@ -186988,6 +187568,10 @@ function DevUI() {
       // Stop all resources
       ...[...resourcesRef.current.values()].map((resource) => resource.stop())
     ]);
+    if (proxyRegistryRef.current) {
+      await proxyRegistryRef.current.unregisterServices(instanceKey);
+      await proxyRegistryRef.current.releaseProxyOwnership();
+    }
     if (stateManagerRef.current) {
       await stateManagerRef.current.releaseOwnership();
     }
@@ -186999,9 +187583,19 @@ function DevUI() {
     if (shuttingDown.current || state.status === "reloading") return;
     writeLog("system", "Reloading (config changed)");
     setState((s) => ({ ...s, status: "reloading", parseError: void 0 }));
+    if (electionIntervalRef.current) {
+      clearInterval(electionIntervalRef.current);
+      electionIntervalRef.current = null;
+    }
+    if (registryWatcherCleanupRef.current) {
+      registryWatcherCleanupRef.current();
+      registryWatcherCleanupRef.current = null;
+    }
     await Promise.all([
       // Stop proxy
       proxyRef.current?.stop(),
+      // Stop admin server
+      adminServerRef.current?.stop(),
       // Stop all services
       ...servicesRef.current.map((service) => service.stop()),
       // Stop all Electric instances
@@ -187014,8 +187608,13 @@ function DevUI() {
     electricInstancesRef.current = [];
     drizzleGatewayRef.current = null;
     proxyRef.current = null;
+    adminServerRef.current = null;
     servicesRef.current = [];
     resourcesRef.current = /* @__PURE__ */ new Map();
+    if (proxyRegistryRef.current) {
+      await proxyRegistryRef.current.unregisterServices(instanceKey);
+      await proxyRegistryRef.current.releaseProxyOwnership();
+    }
     if (stateManagerRef.current) {
       await stateManagerRef.current.releaseOwnership();
     }
@@ -187026,7 +187625,8 @@ function DevUI() {
       resources: /* @__PURE__ */ new Map(),
       resourceStatus: /* @__PURE__ */ new Map(),
       services: [],
-      proxy: void 0
+      proxy: void 0,
+      isProxyOwner: false
     }));
     setReloadTrigger((t) => t + 1);
   };
@@ -187050,7 +187650,7 @@ function DevUI() {
         }
         process.exit(1);
       }
-      shutdown();
+      shutdown2();
     };
     process.on("SIGINT", handleSignal);
     process.on("SIGTERM", handleSignal);
@@ -187059,12 +187659,18 @@ function DevUI() {
       process.off("SIGTERM", handleSignal);
     };
   }, []);
+  useEffect3(() => {
+    if (state.status === "running" && !startTimeRef.current) {
+      startTimeRef.current = Date.now();
+      trackEvent("dev_started");
+    }
+  }, [state.status]);
   useEffect3(() => {
     if (state.status !== "running") return;
-    const configPath = path12.join(process.cwd(), "specific.hcl");
+    const configPath = path14.join(process.cwd(), "specific.hcl");
     const watcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs11.readFileSync(configPath, "utf-8");
+        const hcl = fs13.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           triggerReload();
         }).catch((err) => {
@@ -187104,8 +187710,10 @@ function DevUI() {
     let startedDrizzleGateway = null;
     const startedServices = [];
     let startedProxy = null;
-    const stateManager = new InstanceStateManager(process.cwd());
+    const stateManager = new InstanceStateManager(process.cwd(), instanceKey);
     stateManagerRef.current = stateManager;
+    const proxyRegistry = new ProxyRegistryManager();
+    proxyRegistryRef.current = proxyRegistry;
     async function start() {
       writeLog("system", "Starting dev server");
       await stateManager.cleanStaleState();
@@ -187128,8 +187736,8 @@ function DevUI() {
         }));
         return;
       }
-      const configPath = path12.join(process.cwd(), "specific.hcl");
-      if (!fs11.existsSync(configPath)) {
+      const configPath = path14.join(process.cwd(), "specific.hcl");
+      if (!fs13.existsSync(configPath)) {
         writeLog("system", "Waiting for specific.hcl to appear");
         setState((s) => ({
           ...s,
@@ -187148,7 +187756,7 @@ function DevUI() {
       }
       let config2;
       try {
-        const hcl = fs11.readFileSync(configPath, "utf-8");
+        const hcl = fs13.readFileSync(configPath, "utf-8");
         config2 = await parseConfig(hcl);
       } catch (err) {
         setState((s) => ({
@@ -187181,7 +187789,7 @@ function DevUI() {
         colorIndex++;
       }
       setState((s) => ({ ...s, status: "starting", config: config2, colorMap }));
-      const portAllocator = new StablePortAllocator(process.cwd());
+      const portAllocator = new StablePortAllocator(process.cwd(), instanceKey);
       const resourceStatus = /* @__PURE__ */ new Map();
       const syncDatabases = detectSyncDatabases(config2);
       let resources2;
@@ -187190,7 +187798,7 @@ function DevUI() {
           config: config2,
           selection: { mode: "all" },
           stateManager,
-          dataDir: ".specific/data",
+          dataDir: `.specific/keys/${instanceKey}/data`,
           portAllocator,
           callbacks: {
             onResourceStarting: (name, type) => {
@@ -187254,7 +187862,7 @@ function DevUI() {
           const drizzleGateway = await startDrizzleGateway(
             postgresResources,
             drizzlePort,
-            path12.join(process.cwd(), ".specific")
+            path14.join(process.cwd(), ".specific", "keys", instanceKey)
           );
           startedDrizzleGateway = drizzleGateway;
           drizzleGatewayRef.current = drizzleGateway;
@@ -187362,6 +187970,7 @@ function DevUI() {
         }
       }
       if (cancelled) return;
+      const serviceInfos = [];
       const exposedServices = [];
       for (const service of config2.services) {
         const endpointInfos = serviceEndpoints.get(service.name) || [];
@@ -187372,6 +187981,10 @@ function DevUI() {
           if (endpointConfig?.public) {
             const proxyName = info.endpointName === "default" ? service.name : `${service.name}-${info.endpointName}`;
             exposedServices.push({ name: proxyName, port: info.port });
+            serviceInfos.push({
+              serviceName: proxyName,
+              port: info.port
+            });
           }
         }
       }
@@ -187395,26 +188008,114 @@ function DevUI() {
           syncEnabled: r.type === "postgres" && syncDatabases.has(name)
         }))
       });
-      try {
-        const certificate = generateCertificate("local.spcf.app");
-        const proxy2 = await startHttpProxy(
-          exposedServices,
-          certificate,
-          getState,
-          startedDrizzleGateway?.port
-        );
-        startedProxy = proxy2;
-        proxyRef.current = proxy2;
-        setState((s) => ({ ...s, proxy: proxy2 }));
-      } catch (err) {
-        const errorMsg = `Failed to start HTTP proxy: ${err instanceof Error ? err.message : String(err)}`;
-        writeLog("system:error", errorMsg);
-        setState((s) => ({
-          ...s,
-          status: "error",
-          error: errorMsg
-        }));
-        return;
+      const adminServer = await startAdminServer(getState);
+      adminServerRef.current = adminServer;
+      writeLog("system", `Admin API server started on port ${adminServer.port}`);
+      await proxyRegistry.registerServices(
+        instanceKey,
+        adminServer.port,
+        serviceInfos,
+        startedDrizzleGateway?.port
+      );
+      writeLog("system", `Registered ${serviceInfos.length} services with proxy registry`);
+      const becameProxyOwner = await proxyRegistry.claimProxyOwnership(instanceKey);
+      if (becameProxyOwner) {
+        writeLog("system", "Claimed proxy ownership, starting HTTP proxy");
+        try {
+          const currentServices = await proxyRegistry.getAllServices();
+          const registeredKeys = [...new Set(currentServices.map((s) => s.key))];
+          const certificate = generateCertificate("local.spcf.app", registeredKeys);
+          const proxy2 = await startHttpProxy(
+            exposedServices,
+            certificate,
+            getState,
+            instanceKey
+          );
+          startedProxy = proxy2;
+          proxyRef.current = proxy2;
+          setState((s) => ({ ...s, proxy: proxy2, isProxyOwner: true }));
+          const knownKeys = new Set(registeredKeys);
+          registryWatcherCleanupRef.current = proxyRegistry.watchRegistry(async (updatedServices, updatedKeys) => {
+            writeLog("system", `Registry updated: ${updatedServices.length} services`);
+            proxy2.updateServices(updatedServices, updatedKeys);
+            const newKeyNames = Object.keys(updatedKeys).filter((k) => !knownKeys.has(k));
+            if (newKeyNames.length > 0) {
+              writeLog("system", `New keys detected: ${newKeyNames.join(", ")} - regenerating certificate`);
+              for (const key of newKeyNames) {
+                knownKeys.add(key);
+              }
+              const allKeys = [...knownKeys];
+              const newCertificate = generateCertificate("local.spcf.app", allKeys);
+              proxy2.updateCertificate(newCertificate);
+            }
+          });
+          const currentKeys = await proxyRegistry.getAllKeyRegistrations();
+          proxy2.updateServices(currentServices, currentKeys);
+          writeLog("system", `Loaded ${currentServices.length} services from registry`);
+        } catch (err) {
+          const errorMsg = `Failed to start HTTP proxy: ${err instanceof Error ? err.message : String(err)}`;
+          writeLog("system:error", errorMsg);
+          setState((s) => ({
+            ...s,
+            status: "error",
+            error: errorMsg
+          }));
+          return;
+        }
+      } else {
+        writeLog("system", "Another instance owns the proxy, starting election watcher");
+        setState((s) => ({ ...s, isProxyOwner: false }));
+        const isProcessRunning = (pid) => {
+          try {
+            process.kill(pid, 0);
+            return true;
+          } catch {
+            return false;
+          }
+        };
+        electionIntervalRef.current = setInterval(async () => {
+          if (cancelled || shuttingDown.current) {
+            if (electionIntervalRef.current) {
+              clearInterval(electionIntervalRef.current);
+              electionIntervalRef.current = null;
+            }
+            return;
+          }
+          const owner = await proxyRegistry.getProxyOwner();
+          if (!owner || !isProcessRunning(owner.pid)) {
+            writeLog("system", "Proxy owner died, attempting election");
+            const won = await proxyRegistry.attemptElection(instanceKey);
+            if (won) {
+              writeLog("system", "Won election, starting HTTP proxy");
+              if (electionIntervalRef.current) {
+                clearInterval(electionIntervalRef.current);
+                electionIntervalRef.current = null;
+              }
+              try {
+                const electionServices = await proxyRegistry.getAllServices();
+                const electionKeyRegistrations = await proxyRegistry.getAllKeyRegistrations();
+                const electionKeyNames = Object.keys(electionKeyRegistrations);
+                const certificate = generateCertificate("local.spcf.app", electionKeyNames);
+                const proxy2 = await startHttpProxy(
+                  exposedServices,
+                  certificate,
+                  getState,
+                  instanceKey
+                );
+                startedProxy = proxy2;
+                proxyRef.current = proxy2;
+                setState((s) => ({ ...s, proxy: proxy2, isProxyOwner: true }));
+                registryWatcherCleanupRef.current = proxyRegistry.watchRegistry((updatedServices, updatedKeys) => {
+                  writeLog("system", `Registry updated: ${updatedServices.length} services`);
+                  proxy2.updateServices(updatedServices, updatedKeys);
+                });
+                proxy2.updateServices(electionServices, electionKeyRegistrations);
+              } catch (err) {
+                writeLog("system:error", `Failed to start proxy after election: ${err}`);
+              }
+            }
+          }
+        }, 1e3);
       }
       if (cancelled) return;
       writeLog("system", "Dev server running");
@@ -187423,6 +188124,14 @@ function DevUI() {
     start();
     return () => {
       cancelled = true;
+      if (electionIntervalRef.current) {
+        clearInterval(electionIntervalRef.current);
+        electionIntervalRef.current = null;
+      }
+      if (registryWatcherCleanupRef.current) {
+        registryWatcherCleanupRef.current();
+        registryWatcherCleanupRef.current = null;
+      }
       if (startedProxy) {
         startedProxy.stop().catch(() => {
         });
@@ -187443,10 +188152,14 @@ function DevUI() {
         resource.stop().catch(() => {
         });
       }
+      proxyRegistry.unregisterServices(instanceKey).catch(() => {
+      });
+      proxyRegistry.releaseProxyOwnership().catch(() => {
+      });
       stateManager.releaseOwnership().catch(() => {
       });
     };
-  }, [reloadTrigger, readyToStart]);
+  }, [reloadTrigger, readyToStart, instanceKey]);
   if (state.status === "installing-ca") {
     if (state.caInstallPhase === "installing") {
       return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "TLS Certificate Setup"), /* @__PURE__ */ React3.createElement(Text3, null, " "), /* @__PURE__ */ React3.createElement(Text3, null, "Installing a local certificate authority (CA) to enable HTTPS"), /* @__PURE__ */ React3.createElement(Text3, null, "for local development. The CA is limited to Specific projects."), /* @__PURE__ */ React3.createElement(Text3, null, " "), /* @__PURE__ */ React3.createElement(Text3, null, "Your password is required to add the CA to your system's trust store."), /* @__PURE__ */ React3.createElement(Text3, null, " "));
@@ -187524,17 +188237,15 @@ function DevUI() {
   const staticItems = [
     {
       key: "title",
-      content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "Specific dev server"), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " (Ctrl+C to stop)"))
+      content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "Specific dev server"), instanceKey !== "default" && /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, " [", instanceKey, "]"), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " (Ctrl+C to stop)"))
     },
     { key: "space1", content: /* @__PURE__ */ React3.createElement(Text3, null, " ") },
-    // Show admin UI URL when proxy is running
-    ...proxy ? [
-      {
-        key: "admin",
-        content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Admin:"), /* @__PURE__ */ React3.createElement(Text3, null, " "), /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "https://local.spcf.app"))
-      },
-      { key: "admin-space", content: /* @__PURE__ */ React3.createElement(Text3, null, " ") }
-    ] : [],
+    // Show admin UI URL
+    {
+      key: "admin",
+      content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Admin:"), /* @__PURE__ */ React3.createElement(Text3, null, " "), /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "https://", instanceKey === "default" ? "" : `${instanceKey}.`, "local.spcf.app"))
+    },
+    { key: "admin-space", content: /* @__PURE__ */ React3.createElement(Text3, null, " ") },
     ...services.length > 0 ? [
       { key: "svc-header", content: /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Services:") },
       ...services.flatMap((svc) => {
@@ -187553,17 +188264,14 @@ function DevUI() {
           const proxyName = endpoint.name === "default" ? svc.name : `${svc.name}-${endpoint.name}`;
           return {
             key: `svc-${svc.name}-${endpoint.name}`,
-            content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, " \u25CF "), /* @__PURE__ */ React3.createElement(Text3, null, displayName), port ? endpoint.public && proxy ? /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(Text3, null, " \u2192 "), /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "https://", proxyName, ".local.spcf.app"), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " (localhost:", port, ")")) : /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " (localhost:", port, ")") : null)
+            content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, " \u25CF "), /* @__PURE__ */ React3.createElement(Text3, null, displayName), port ? endpoint.public ? /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(Text3, null, " \u2192 "), /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "https://", proxyName, instanceKey === "default" ? "" : `.${instanceKey}`, ".local.spcf.app"), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " (localhost:", port, ")")) : /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " (localhost:", port, ")") : null)
           };
         });
       }),
       { key: "space2", content: /* @__PURE__ */ React3.createElement(Text3, null, " ") }
     ] : [],
     ...config.postgres.length > 0 ? [
-      {
-        key: "pg-header",
-        content: /* @__PURE__ */ React3.createElement(Text3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Postgres:"), drizzleGatewayRef.current && /* @__PURE__ */ React3.createElement(Text3, null, " ", "(admin \u2192 ", /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "http://localhost:", drizzleGatewayRef.current.port), ")"))
-      },
+      { key: "pg-header", content: /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Postgres:") },
       ...config.postgres.map((pg) => {
         const instance = resources.get(pg.name);
         return {
@@ -187609,8 +188317,47 @@ function DevUI() {
   ];
   return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Static, { items: staticItems }, (item) => /* @__PURE__ */ React3.createElement(Box3, { key: item.key }, item.content)));
 }
-function devCommand() {
-  render3(/* @__PURE__ */ React3.createElement(DevUI, null));
+function devCommand(instanceKey) {
+  render3(/* @__PURE__ */ React3.createElement(DevUI, { instanceKey }));
+}
+
+// src/lib/dev/git-worktree.ts
+import { execSync as execSync2 } from "child_process";
+import * as path15 from "path";
+function isInWorktree() {
+  try {
+    const commonDir = execSync2("git rev-parse --git-common-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const gitDir = execSync2("git rev-parse --git-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const resolvedCommonDir = path15.resolve(commonDir);
+    const resolvedGitDir = path15.resolve(gitDir);
+    return resolvedCommonDir !== resolvedGitDir;
+  } catch {
+    return false;
+  }
+}
+function getWorktreeName() {
+  if (!isInWorktree()) {
+    return null;
+  }
+  try {
+    const gitDir = execSync2("git rev-parse --git-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return path15.basename(gitDir);
+  } catch {
+    return null;
+  }
+}
+function getDefaultKey() {
+  const worktreeName = getWorktreeName();
+  return worktreeName ?? "default";
 }
 
 // src/commands/deploy.tsx
@@ -187620,30 +188367,30 @@ import Spinner5 from "ink-spinner";
 
 // ../../node_modules/open/index.js
 import process8 from "node:process";
-import path13 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import childProcess3 from "node:child_process";
-import fs16, { constants as fsConstants2 } from "node:fs/promises";
+import fs18, { constants as fsConstants2 } from "node:fs/promises";
 
 // ../../node_modules/wsl-utils/index.js
 import { promisify as promisify2 } from "node:util";
 import childProcess2 from "node:child_process";
-import fs15, { constants as fsConstants } from "node:fs/promises";
+import fs17, { constants as fsConstants } from "node:fs/promises";
 
 // ../../node_modules/is-wsl/index.js
 import process2 from "node:process";
-import os4 from "node:os";
-import fs14 from "node:fs";
+import os6 from "node:os";
+import fs16 from "node:fs";
 
 // ../../node_modules/is-inside-container/index.js
-import fs13 from "node:fs";
+import fs15 from "node:fs";
 
 // ../../node_modules/is-docker/index.js
-import fs12 from "node:fs";
+import fs14 from "node:fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs12.statSync("/.dockerenv");
+    fs14.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -187651,7 +188398,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs12.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs14.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -187667,7 +188414,7 @@ function isDocker() {
 var cachedResult;
 var hasContainerEnv = () => {
   try {
-    fs13.statSync("/run/.containerenv");
+    fs15.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -187685,14 +188432,14 @@ var isWsl = () => {
   if (process2.platform !== "linux") {
     return false;
   }
-  if (os4.release().toLowerCase().includes("microsoft")) {
+  if (os6.release().toLowerCase().includes("microsoft")) {
     if (isInsideContainer()) {
       return false;
     }
     return true;
   }
   try {
-    return fs14.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+    return fs16.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
   } catch {
     return false;
   }
@@ -187760,14 +188507,14 @@ var wslDrivesMountPoint = /* @__PURE__ */ (() => {
     const configFilePath = "/etc/wsl.conf";
     let isConfigFileExists = false;
     try {
-      await fs15.access(configFilePath, fsConstants.F_OK);
+      await fs17.access(configFilePath, fsConstants.F_OK);
       isConfigFileExists = true;
     } catch {
     }
     if (!isConfigFileExists) {
       return defaultMountPoint;
     }
-    const configContent = await fs15.readFile(configFilePath, { encoding: "utf8" });
+    const configContent = await fs17.readFile(configFilePath, { encoding: "utf8" });
     const parsedMountPoint = parseMountPointFromConfig(configContent);
     if (parsedMountPoint === void 0) {
       return defaultMountPoint;
@@ -187787,7 +188534,7 @@ var canAccessPowerShell = async () => {
   canAccessPowerShellPromise ??= (async () => {
     try {
       const psPath = await powerShellPath2();
-      await fs15.access(psPath, fsConstants.X_OK);
+      await fs17.access(psPath, fsConstants.X_OK);
       return true;
     } catch {
       return false;
@@ -187801,15 +188548,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path20) => {
-  if (/^[a-z]+:\/\//i.test(path20)) {
-    return path20;
+var convertWslPathToWindows = async (path22) => {
+  if (/^[a-z]+:\/\//i.test(path22)) {
+    return path22;
   }
   try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path20], { encoding: "utf8" });
+    const { stdout } = await execFile2("wslpath", ["-aw", path22], { encoding: "utf8" });
     return stdout.trim();
   } catch {
-    return path20;
+    return path22;
   }
 };
 
@@ -187951,8 +188698,8 @@ var is_in_ssh_default = isInSsh;
 
 // ../../node_modules/open/index.js
 var fallbackAttemptSymbol = Symbol("fallbackAttempt");
-var __dirname3 = import.meta.url ? path13.dirname(fileURLToPath3(import.meta.url)) : "";
-var localXdgOpenPath = path13.join(__dirname3, "xdg-open");
+var __dirname3 = import.meta.url ? path16.dirname(fileURLToPath3(import.meta.url)) : "";
+var localXdgOpenPath = path16.join(__dirname3, "xdg-open");
 var { platform: platform4, arch: arch2 } = process8;
 var tryEachApp = async (apps2, opener) => {
   if (apps2.length === 0) {
@@ -188100,7 +188847,7 @@ var baseOpen = async (options2) => {
       const isBundled = !__dirname3 || __dirname3 === "/";
       let exeLocalXdgOpen = false;
       try {
-        await fs16.access(localXdgOpenPath, fsConstants2.X_OK);
+        await fs18.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {
       }
@@ -188123,19 +188870,19 @@ var baseOpen = async (options2) => {
   }
   const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
   if (options2.wait) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options2.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve4(subprocess);
+        resolve5(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -188145,17 +188892,17 @@ var baseOpen = async (options2) => {
             return;
           }
           subprocess.unref();
-          resolve4(subprocess);
+          resolve5(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve4(subprocess);
+      resolve5(subprocess);
     });
   });
 };
@@ -188232,35 +188979,35 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({
 var open_default = open2;
 
 // src/commands/deploy.tsx
-import * as fs20 from "fs";
-import * as path17 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 
 // src/lib/deploy/build-tester.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync14 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join17 } from "path";
 function getDependencyInstallCommand(build, projectDir) {
   switch (build.base) {
     case "node":
-      if (existsSync14(join15(projectDir, "pnpm-lock.yaml"))) {
+      if (existsSync16(join17(projectDir, "pnpm-lock.yaml"))) {
         return "pnpm install --frozen-lockfile";
-      } else if (existsSync14(join15(projectDir, "yarn.lock"))) {
+      } else if (existsSync16(join17(projectDir, "yarn.lock"))) {
         return "yarn install --frozen-lockfile";
-      } else if (existsSync14(join15(projectDir, "package-lock.json"))) {
+      } else if (existsSync16(join17(projectDir, "package-lock.json"))) {
         return "npm ci";
       } else {
         return "npm install";
       }
     case "python":
-      if (existsSync14(join15(projectDir, "poetry.lock"))) {
+      if (existsSync16(join17(projectDir, "poetry.lock"))) {
         return "poetry install --no-interaction";
-      } else if (existsSync14(join15(projectDir, "Pipfile.lock"))) {
+      } else if (existsSync16(join17(projectDir, "Pipfile.lock"))) {
         return "pipenv install --deploy";
-      } else if (existsSync14(join15(projectDir, "Pipfile"))) {
+      } else if (existsSync16(join17(projectDir, "Pipfile"))) {
         return "pipenv install";
-      } else if (existsSync14(join15(projectDir, "pyproject.toml"))) {
+      } else if (existsSync16(join17(projectDir, "pyproject.toml"))) {
         return "pip install .";
-      } else if (existsSync14(join15(projectDir, "requirements.txt"))) {
+      } else if (existsSync16(join17(projectDir, "requirements.txt"))) {
         return "pip install -r requirements.txt";
       }
       return null;
@@ -188274,7 +189021,7 @@ function getDependencyInstallCommand(build, projectDir) {
   }
 }
 function runCommand2(command, projectDir, buildName) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const stdout = [];
     const stderr = [];
     writeLog("build-test", `[${buildName}] Running: ${command}`);
@@ -188304,7 +189051,7 @@ function runCommand2(command, projectDir, buildName) {
     });
     child.on("error", (err) => {
       writeLog("build-test:error", `[${buildName}] Failed to start: ${err.message}`);
-      resolve4({
+      resolve5({
         success: false,
         output: `Failed to start command: ${err.message}`
       });
@@ -188313,10 +189060,10 @@ function runCommand2(command, projectDir, buildName) {
       const output = [...stdout, ...stderr].join("");
       if (code === 0) {
         writeLog("build-test", `[${buildName}] Command succeeded (exit code 0)`);
-        resolve4({ success: true, output });
+        resolve5({ success: true, output });
       } else {
         writeLog("build-test:error", `[${buildName}] Command failed with exit code ${code}`);
-        resolve4({
+        resolve5({
           success: false,
           output: output || `Exit code: ${code}`
         });
@@ -188652,16 +189399,44 @@ var ApiClient = class {
     }
     return response.json();
   }
+  async getMe(signal) {
+    const url = `${this.baseUrl}/users/me`;
+    writeLog("api", `GET ${url}`);
+    const response = await fetch(url, {
+      headers: this.authHeaders(),
+      signal
+    });
+    writeLog("api", `Response: ${response.status} ${response.statusText}`);
+    if (!response.ok) {
+      let errorBody;
+      try {
+        const error = await response.json();
+        errorBody = JSON.stringify(error);
+        writeLog("api:error", `API error: ${error.error} (${error.code})`);
+        writeLog("api:error", `Request was: GET ${url}`);
+        writeLog("api:error", `Response body: ${errorBody}`);
+        throw new Error(`Failed to get user: ${error.error} (${error.code})`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("Failed to get user")) {
+          throw e;
+        }
+        errorBody = await response.text();
+        writeLog("api:error", `Failed to parse error response: ${errorBody}`);
+        throw new Error(`Failed to get user: ${response.statusText}`);
+      }
+    }
+    return response.json();
+  }
 };
 
 // src/lib/tarball/create.ts
-import { execSync as execSync2 } from "child_process";
-import * as fs17 from "fs";
-import * as path14 from "path";
+import { execSync as execSync3 } from "child_process";
+import * as fs19 from "fs";
+import * as path17 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
 function isInsideGitRepository(dir) {
   try {
-    const result = execSync2("git rev-parse --is-inside-work-tree", {
+    const result = execSync3("git rev-parse --is-inside-work-tree", {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -188671,50 +189446,42 @@ function isInsideGitRepository(dir) {
     return false;
   }
 }
-function getGitInfo(projectDir) {
-  const gitRoot = execSync2("git rev-parse --show-toplevel", {
-    cwd: projectDir,
-    encoding: "utf-8"
-  }).trim();
-  const relativePath = path14.relative(gitRoot, projectDir);
-  return { gitRoot, relativePath: relativePath || "." };
-}
-function createGitArchive(projectDir) {
-  writeLog("tarball", "Creating tarball using git archive");
-  const { gitRoot, relativePath } = getGitInfo(projectDir);
-  const isSubdirectory = relativePath !== ".";
-  writeLog(
-    "tarball",
-    isSubdirectory ? `Project is in subdirectory: ${relativePath}` : "Project is at git root"
-  );
-  const stashResult = execSync2("git stash create --include-untracked", {
-    cwd: gitRoot,
-    encoding: "utf-8"
-  }).trim();
-  const treeish = stashResult || "HEAD";
-  writeLog(
-    "tarball",
-    `Archiving from: ${treeish === "HEAD" ? "HEAD (no uncommitted changes)" : "stash (includes uncommitted changes)"}`
-  );
-  const archiveTarget = isSubdirectory ? `${treeish}:${relativePath}` : treeish;
-  const tarball = execSync2(
-    `git archive --format=tar.gz ${archiveTarget} -- . ":!.specific"`,
+async function createGitArchive(projectDir) {
+  writeLog("tarball", "Creating tarball using git ls-files");
+  const filesOutput = execSync3(
+    "git ls-files --cached --others --exclude-standard",
     {
-      cwd: gitRoot,
+      cwd: projectDir,
+      encoding: "utf-8",
       maxBuffer: 100 * 1024 * 1024
       // 100MB max
     }
   );
-  writeLog("tarball", `Git archive created: ${tarball.length} bytes`);
+  const allFiles = filesOutput.trim().split("\n").filter(Boolean);
+  const filteredFiles = allFiles.filter(
+    (file) => !file.startsWith(".specific/") && file !== ".specific"
+  );
+  writeLog(
+    "tarball",
+    `Found ${allFiles.length} files, ${filteredFiles.length} after filtering .specific`
+  );
+  const entryGenerator = createEntryItemGenerator(projectDir, filteredFiles);
+  const tarStream = createTarPacker(entryGenerator, "gzip");
+  const chunks = [];
+  for await (const chunk of tarStream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const tarball = Buffer.concat(chunks);
+  writeLog("tarball", `Tarball created: ${tarball.length} bytes`);
   return tarball;
 }
 var EXCLUDED_DIRS = [".specific"];
 async function collectPaths(baseDir, currentDir, exclude) {
   const results = [];
-  const entries = await fs17.promises.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs19.promises.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path14.join(currentDir, entry.name);
-    const relativePath = path14.relative(baseDir, fullPath);
+    const fullPath = path17.join(currentDir, entry.name);
+    const relativePath = path17.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (!exclude.includes(entry.name)) {
         results.push(relativePath);
@@ -188729,8 +189496,8 @@ async function collectPaths(baseDir, currentDir, exclude) {
 }
 async function createTarArchive(projectDir) {
   writeLog("tarball", "Creating tarball using tar-vern (non-git project)");
-  const configPath = path14.join(projectDir, "specific.hcl");
-  if (!fs17.existsSync(configPath)) {
+  const configPath = path17.join(projectDir, "specific.hcl");
+  if (!fs19.existsSync(configPath)) {
     throw new Error("specific.hcl not found in project directory");
   }
   const relativePaths = await collectPaths(projectDir, projectDir, EXCLUDED_DIRS);
@@ -188752,49 +189519,10 @@ async function createProjectTarball(projectDir) {
   return createTarArchive(projectDir);
 }
 
-// src/lib/project/config.ts
-import * as fs18 from "fs";
-import * as path15 from "path";
-var PROJECT_ID_FILE = ".specific/project_id";
-var ProjectNotLinkedError = class extends Error {
-  constructor() {
-    super(
-      `Project not linked to Specific.
-
-The file ${PROJECT_ID_FILE} does not exist.
-
-Run: specific deploy`
-    );
-    this.name = "ProjectNotLinkedError";
-  }
-};
-function readProjectId(projectDir = process.cwd()) {
-  const projectIdPath = path15.join(projectDir, PROJECT_ID_FILE);
-  if (!fs18.existsSync(projectIdPath)) {
-    throw new ProjectNotLinkedError();
-  }
-  const projectId = fs18.readFileSync(projectIdPath, "utf-8").trim();
-  if (!projectId) {
-    throw new Error(`${PROJECT_ID_FILE} is empty`);
-  }
-  return projectId;
-}
-function hasProjectId(projectDir = process.cwd()) {
-  const projectIdPath = path15.join(projectDir, PROJECT_ID_FILE);
-  return fs18.existsSync(projectIdPath);
-}
-function writeProjectId(projectId, projectDir = process.cwd()) {
-  const specificDir = path15.join(projectDir, ".specific");
-  if (!fs18.existsSync(specificDir)) {
-    fs18.mkdirSync(specificDir, { recursive: true });
-  }
-  fs18.writeFileSync(path15.join(specificDir, "project_id"), projectId + "\n");
-}
-
 // src/lib/auth/credentials.ts
-import * as fs19 from "fs";
-import * as path16 from "path";
-import * as os5 from "os";
+import * as fs20 from "fs";
+import * as path18 from "path";
+import * as os7 from "os";
 
 // src/lib/auth/errors.ts
 var RefreshTokenExpiredError = class extends Error {
@@ -188871,7 +189599,7 @@ import React4, { useState as useState4, useEffect as useEffect4 } from "react";
 import { render as render4, Box as Box4, Text as Text4, useApp as useApp3 } from "ink";
 import Spinner4 from "ink-spinner";
 function performLogin(options2 = {}) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const instance = render4(
       /* @__PURE__ */ React4.createElement(
         LoginFlow,
@@ -188879,7 +189607,7 @@ function performLogin(options2 = {}) {
           isReauthentication: options2.isReauthentication,
           onComplete: (result) => {
             instance.unmount();
-            resolve4(result);
+            resolve5(result);
           }
         }
       )
@@ -188933,10 +189661,14 @@ function LoginFlow({ isReauthentication, onComplete }) {
               }
             } else {
               const successResponse = response;
+              const expiresAt2 = Date.now() + successResponse.expires_in * 1e3;
+              const client2 = new ApiClient(successResponse.access_token);
+              const user = await client2.getMe();
               writeUserCredentials({
                 accessToken: successResponse.access_token,
                 refreshToken: successResponse.refresh_token,
-                expiresAt: Date.now() + successResponse.expires_in * 1e3
+                expiresAt: expiresAt2,
+                userId: user.id
               });
               setUserEmail(successResponse.user.email);
               setPhase("success");
@@ -188985,18 +189717,18 @@ function LoginFlow({ isReauthentication, onComplete }) {
 
 // src/lib/auth/credentials.ts
 function getUserCredentialsDir() {
-  return path16.join(os5.homedir(), ".specific");
+  return path18.join(os7.homedir(), ".specific");
 }
 function getCredentialsPath() {
-  return path16.join(getUserCredentialsDir(), "credentials.json");
+  return path18.join(getUserCredentialsDir(), "credentials.json");
 }
 function readUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (!fs19.existsSync(credentialsPath)) {
+  if (!fs20.existsSync(credentialsPath)) {
     return null;
   }
   try {
-    const content = fs19.readFileSync(credentialsPath, "utf-8");
+    const content = fs20.readFileSync(credentialsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -189004,18 +189736,18 @@ function readUserCredentials() {
 }
 function writeUserCredentials(credentials) {
   const dir = getUserCredentialsDir();
-  if (!fs19.existsSync(dir)) {
-    fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
-  fs19.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs20.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
 function clearUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (fs19.existsSync(credentialsPath)) {
-    fs19.unlinkSync(credentialsPath);
+  if (fs20.existsSync(credentialsPath)) {
+    fs20.unlinkSync(credentialsPath);
   }
 }
 function isLoggedIn() {
@@ -189272,8 +190004,8 @@ function DeployUI({ environment, config, skipBuildTest }) {
     async function loadProjects() {
       try {
         const token = await getValidAccessToken();
-        const client = new ApiClient(token);
-        const { projects: projects2 } = await client.listProjects();
+        const client2 = new ApiClient(token);
+        const { projects: projects2 } = await client2.listProjects();
         if (cancelled) return;
         setState({
           phase: "selecting-project",
@@ -189319,8 +190051,8 @@ function DeployUI({ environment, config, skipBuildTest }) {
     async function createProject() {
       try {
         const token = await getValidAccessToken();
-        const client = new ApiClient(token);
-        const project = await client.createProject(state.newProjectName);
+        const client2 = new ApiClient(token);
+        const project = await client2.createProject(state.newProjectName);
         if (cancelled) return;
         writeProjectId(project.id);
         setState({
@@ -189413,15 +190145,15 @@ function DeployUI({ environment, config, skipBuildTest }) {
       (secret) => secretValues[secret]
     );
     if (!allSecretsCollected) return;
-    const client = clientRef.current;
-    if (!client) return;
+    const client2 = clientRef.current;
+    if (!client2) return;
     (async () => {
       try {
         writeLog(
           "deploy",
           `Submitting secrets: ${Object.keys(secretValues).join(", ")}`
         );
-        await client.submitSecrets(deployment2.id, secretValues);
+        await client2.submitSecrets(deployment2.id, secretValues);
         writeLog("deploy", "Secrets submitted successfully");
         setState((s) => ({
           ...s,
@@ -189455,15 +190187,15 @@ function DeployUI({ environment, config, skipBuildTest }) {
       (config2) => configValues[config2]
     );
     if (!allConfigsCollected) return;
-    const client = clientRef.current;
-    if (!client) return;
+    const client2 = clientRef.current;
+    if (!client2) return;
     (async () => {
       try {
         writeLog(
           "deploy",
           `Submitting configs: ${Object.keys(configValues).join(", ")}`
         );
-        await client.submitConfigs(deployment2.id, configValues);
+        await client2.submitConfigs(deployment2.id, configValues);
         writeLog("deploy", "Configs submitted successfully");
         setState((s) => ({
           ...s,
@@ -189535,8 +190267,8 @@ ${errorMsg}`
       writeLog("deploy", `Starting deployment to "${environment}"`);
       writeLog("deploy", `Project directory: ${projectDir}`);
       const authToken = await getValidAccessToken();
-      const client = new ApiClient(authToken);
-      clientRef.current = client;
+      const client2 = new ApiClient(authToken);
+      clientRef.current = client2;
       if (cancelled) return;
       let tarball;
       try {
@@ -189561,7 +190293,7 @@ ${errorMsg}`
       let deployment2;
       try {
         writeLog("deploy", `Creating deployment for project ${state.projectId}`);
-        deployment2 = await client.createDeployment(state.projectId, environment);
+        deployment2 = await client2.createDeployment(state.projectId, environment);
         writeLog("deploy", `Deployment created: ${deployment2.id}`);
       } catch (err) {
         const errorMsg = `Failed to create deployment: ${err instanceof Error ? err.message : String(err)}`;
@@ -189576,7 +190308,7 @@ ${errorMsg}`
       setState((s) => ({ ...s, phase: "uploading", deployment: deployment2 }));
       try {
         writeLog("deploy", `Uploading tarball (${tarball.length} bytes)`);
-        deployment2 = await client.uploadTarball(deployment2.id, tarball);
+        deployment2 = await client2.uploadTarball(deployment2.id, tarball);
         writeLog("deploy", "Tarball uploaded successfully");
       } catch (err) {
         const errorMsg = `Failed to upload tarball: ${err instanceof Error ? err.message : String(err)}`;
@@ -189595,7 +190327,7 @@ ${errorMsg}`
       let lastState;
       const pollForCompletion = async () => {
         try {
-          const status = await client.getDeployment(deployment2.id);
+          const status = await client2.getDeployment(deployment2.id);
           if (cancelled) return;
           if (status.state !== lastState) {
             writeLog(
@@ -189681,11 +190413,11 @@ ${errorMsg}`
   useEffect5(() => {
     let pollInterval;
     if ((state.phase === "building" || state.phase === "deploying") && state.deployment && state.missingSecrets === void 0 && state.secretValues === void 0 && state.missingConfigs === void 0 && state.configValues === void 0) {
-      const client = clientRef.current;
-      if (!client) return;
+      const client2 = clientRef.current;
+      if (!client2) return;
       const pollForCompletion = async () => {
         try {
-          const status = await client.getDeployment(state.deployment.id);
+          const status = await client2.getDeployment(state.deployment.id);
           if (status.state === "failed") {
             setState((s) => ({
               ...s,
@@ -189717,12 +190449,24 @@ ${errorMsg}`
     }
   }, [state.phase, state.missingSecrets, state.secretValues, state.missingConfigs, state.configValues]);
   useEffect5(() => {
-    if (state.phase === "success" || state.phase === "error") {
+    if (state.phase === "testing-builds") {
+      trackEvent("deploy_started", { environment });
+    }
+  }, [state.phase, environment]);
+  useEffect5(() => {
+    if (state.phase === "success") {
+      trackEvent("deploy_succeeded", { environment });
       closeDebugLog();
       const timer = setTimeout(() => exit(), 100);
       return () => clearTimeout(timer);
     }
-  }, [state.phase, exit]);
+    if (state.phase === "error") {
+      trackEvent("deploy_failed", { environment });
+      closeDebugLog();
+      const timer = setTimeout(() => exit(), 100);
+      return () => clearTimeout(timer);
+    }
+  }, [state.phase, exit, environment]);
   const {
     phase,
     deployment,
@@ -189837,14 +190581,14 @@ ${errorMsg}`
   ), phase === "error" && /* @__PURE__ */ React5.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, { color: "red" }, "Error: ", error)), phase === "success" && /* @__PURE__ */ React5.createElement(Box5, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Text5, { color: "green" }, "Deployment successful!"), deployment?.publicUrls && Object.keys(deployment.publicUrls).length > 0 && /* @__PURE__ */ React5.createElement(Box5, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Text5, { bold: true }, "Public URLs:"), Object.entries(deployment.publicUrls).map(([name, url]) => /* @__PURE__ */ React5.createElement(Text5, { key: name }, "  ", name, ": ", /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, url))))));
 }
 async function deployCommand(environment, options2) {
-  const configPath = path17.join(process.cwd(), "specific.hcl");
-  if (!fs20.existsSync(configPath)) {
+  const configPath = path19.join(process.cwd(), "specific.hcl");
+  if (!fs21.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
   try {
-    const hcl = fs20.readFileSync(configPath, "utf-8");
+    const hcl = fs21.readFileSync(configPath, "utf-8");
     config = await parseConfig(hcl);
   } catch (err) {
     console.error(
@@ -189868,9 +190612,9 @@ async function deployCommand(environment, options2) {
 
 // src/commands/exec.tsx
 import { spawn as spawn6 } from "child_process";
-import * as fs21 from "fs";
-import * as path18 from "path";
-async function execCommand(serviceName, command) {
+import * as fs22 from "fs";
+import * as path20 from "path";
+async function execCommand(serviceName, command, instanceKey = "default") {
   if (command.length === 0) {
     console.error(
       "Error: No command provided. Usage: specific exec <service> -- <command>"
@@ -189897,14 +190641,14 @@ async function execCommand(serviceName, command) {
       }
     }
   };
-  const configPath = path18.join(process.cwd(), "specific.hcl");
-  if (!fs21.existsSync(configPath)) {
+  const configPath = path20.join(process.cwd(), "specific.hcl");
+  if (!fs22.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
   try {
-    const hcl = fs21.readFileSync(configPath, "utf-8");
+    const hcl = fs22.readFileSync(configPath, "utf-8");
     config = await parseConfig(hcl);
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
@@ -189921,7 +190665,7 @@ async function execCommand(serviceName, command) {
   const required = findRequiredResources(service);
   let resources = /* @__PURE__ */ new Map();
   const hasRequiredResources = required.postgres.length > 0 || required.redis.length > 0 || required.storage.length > 0;
-  stateManager = new InstanceStateManager(process.cwd());
+  stateManager = new InstanceStateManager(process.cwd(), instanceKey);
   await stateManager.cleanStaleState();
   const existingInstances = await stateManager.getExistingInstances();
   if (hasRequiredResources) {
@@ -189976,7 +190720,7 @@ async function execCommand(serviceName, command) {
             storage: required.storage
           },
           stateManager,
-          dataDir: ".specific/data",
+          dataDir: `.specific/keys/${instanceKey}/data`,
           portAllocator: new PortAllocator(),
           callbacks: {
             log: (msg) => console.error(msg)
@@ -190041,8 +190785,8 @@ async function execCommand(serviceName, command) {
 
 // src/commands/psql.tsx
 import { spawn as spawn7 } from "child_process";
-async function psqlCommand(databaseName) {
-  const stateManager = new InstanceStateManager(process.cwd());
+async function psqlCommand(databaseName, instanceKey = "default") {
+  const stateManager = new InstanceStateManager(process.cwd(), instanceKey);
   await stateManager.cleanStaleState();
   const existingInstances = await stateManager.getExistingInstances();
   if (!existingInstances) {
@@ -190098,41 +190842,85 @@ async function psqlCommand(databaseName) {
 import React6, { useState as useState6, useEffect as useEffect6 } from "react";
 import { render as render6, Text as Text6, Box as Box6 } from "ink";
 import Spinner6 from "ink-spinner";
-import * as fs22 from "fs";
-import * as path19 from "path";
-function CleanUI() {
+import * as fs23 from "fs";
+import * as path21 from "path";
+function CleanUI({ instanceKey }) {
   const [state, setState] = useState6({ status: "checking" });
   useEffect6(() => {
     async function clean() {
       const projectRoot = process.cwd();
-      const specificDir = path19.join(projectRoot, ".specific");
-      if (!fs22.existsSync(specificDir)) {
+      const specificDir = path21.join(projectRoot, ".specific");
+      if (!fs23.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
-      const stateManager = new InstanceStateManager(projectRoot);
-      const existingInstances = await stateManager.getExistingInstances();
-      if (existingInstances) {
-        setState({
-          status: "error",
-          error: `Cannot clean while 'specific dev' is running (PID ${existingInstances.owner.pid}). Please stop it first.`
-        });
-        return;
-      }
-      await stateManager.cleanStaleState();
-      setState({ status: "cleaning" });
-      try {
-        fs22.rmSync(specificDir, { recursive: true, force: true });
-        setState({ status: "success" });
-      } catch (err) {
-        setState({
-          status: "error",
-          error: err instanceof Error ? err.message : String(err)
-        });
+      if (instanceKey) {
+        const keyDir = path21.join(specificDir, "keys", instanceKey);
+        if (!fs23.existsSync(keyDir)) {
+          setState({ status: "nothing" });
+          return;
+        }
+        const stateManager = new InstanceStateManager(projectRoot, instanceKey);
+        const existingInstances = await stateManager.getExistingInstances();
+        if (existingInstances) {
+          setState({
+            status: "error",
+            error: `Cannot clean while 'specific dev' is running for key "${instanceKey}" (PID ${existingInstances.owner.pid}). Please stop it first.`
+          });
+          return;
+        }
+        await stateManager.cleanStaleState();
+        setState({ status: "cleaning" });
+        try {
+          fs23.rmSync(keyDir, { recursive: true, force: true });
+          setState({ status: "success" });
+        } catch (err) {
+          setState({
+            status: "error",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      } else {
+        const keysDir = path21.join(specificDir, "keys");
+        if (fs23.existsSync(keysDir)) {
+          const keys = fs23.readdirSync(keysDir).filter(
+            (f) => fs23.statSync(path21.join(keysDir, f)).isDirectory()
+          );
+          for (const key of keys) {
+            const stateManager2 = new InstanceStateManager(projectRoot, key);
+            const existingInstances2 = await stateManager2.getExistingInstances();
+            if (existingInstances2) {
+              setState({
+                status: "error",
+                error: `Cannot clean while 'specific dev' is running for key "${key}" (PID ${existingInstances2.owner.pid}). Please stop it first.`
+              });
+              return;
+            }
+          }
+        }
+        const stateManager = new InstanceStateManager(projectRoot);
+        const existingInstances = await stateManager.getExistingInstances();
+        if (existingInstances) {
+          setState({
+            status: "error",
+            error: `Cannot clean while 'specific dev' is running (PID ${existingInstances.owner.pid}). Please stop it first.`
+          });
+          return;
+        }
+        setState({ status: "cleaning" });
+        try {
+          fs23.rmSync(specificDir, { recursive: true, force: true });
+          setState({ status: "success" });
+        } catch (err) {
+          setState({
+            status: "error",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
       }
     }
     clean();
-  }, []);
+  }, [instanceKey]);
   if (state.status === "checking") {
     return /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, /* @__PURE__ */ React6.createElement(Spinner6, { type: "dots" })), /* @__PURE__ */ React6.createElement(Text6, null, " Checking for running instances..."));
   }
@@ -190143,18 +190931,24 @@ function CleanUI() {
     return /* @__PURE__ */ React6.createElement(Text6, { color: "red" }, "Error: ", state.error);
   }
   if (state.status === "nothing") {
-    return /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, "Nothing to clean (.specific directory does not exist)");
+    const target2 = instanceKey ? `key "${instanceKey}"` : ".specific directory";
+    return /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, "Nothing to clean (", target2, " does not exist)");
   }
-  return /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, "Cleaned .specific directory");
+  const target = instanceKey ? `key "${instanceKey}"` : ".specific directory";
+  return /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, "Cleaned ", target);
 }
-function cleanCommand() {
-  render6(/* @__PURE__ */ React6.createElement(CleanUI, null));
+function cleanCommand(instanceKey) {
+  if (instanceKey) {
+    render6(/* @__PURE__ */ React6.createElement(CleanUI, { instanceKey }));
+  } else {
+    render6(/* @__PURE__ */ React6.createElement(CleanUI, null));
+  }
 }
 
 // src/commands/secrets.tsx
 import React7, { useState as useState7, useEffect as useEffect7 } from "react";
 import { render as render7, Text as Text7, Box as Box7, useInput as useInput4, useApp as useApp5 } from "ink";
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 var HEADER_COMMENT = "# Do not commit this file - it contains secrets\n";
 function SetSecretUI({ secretName }) {
   const { exit } = useApp5();
@@ -190173,8 +190967,8 @@ function SetSecretUI({ secretName }) {
         const hclLine = `${secretName} = "${escapedValue}"`;
         let content = "";
         let hasHeader = false;
-        if (fs23.existsSync(SECRETS_FILE)) {
-          content = fs23.readFileSync(SECRETS_FILE, "utf-8");
+        if (fs24.existsSync(SECRETS_FILE)) {
+          content = fs24.readFileSync(SECRETS_FILE, "utf-8");
           hasHeader = content.startsWith("#");
           const lines = content.split("\n");
           const newLines = [];
@@ -190189,7 +190983,7 @@ function SetSecretUI({ secretName }) {
             }
           }
           if (found) {
-            fs23.writeFileSync(SECRETS_FILE, newLines.join("\n"));
+            fs24.writeFileSync(SECRETS_FILE, newLines.join("\n"));
             setDone(true);
             return;
           }
@@ -190202,7 +190996,7 @@ function SetSecretUI({ secretName }) {
         }
         newContent += `${hclLine}
 `;
-        fs23.writeFileSync(SECRETS_FILE, newContent);
+        fs24.writeFileSync(SECRETS_FILE, newContent);
         setDone(true);
       } catch (err) {
         setError(err instanceof Error ? err.message : String(err));
@@ -190262,7 +191056,7 @@ async function secretsCommand(action, secretName) {
 // src/commands/config.tsx
 import React8, { useState as useState8, useEffect as useEffect8 } from "react";
 import { render as render8, Text as Text8, Box as Box8, useInput as useInput5, useApp as useApp6 } from "ink";
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 var HEADER_COMMENT2 = "# Configuration values for this project\n# These values override defaults defined in specific.hcl\n";
 function SetConfigUI({ configName, initialValue }) {
   const { exit } = useApp6();
@@ -190281,8 +191075,8 @@ function SetConfigUI({ configName, initialValue }) {
         const hclLine = `${configName} = "${escapedValue}"`;
         let content = "";
         let hasHeader = false;
-        if (fs24.existsSync(CONFIG_FILE)) {
-          content = fs24.readFileSync(CONFIG_FILE, "utf-8");
+        if (fs25.existsSync(CONFIG_FILE)) {
+          content = fs25.readFileSync(CONFIG_FILE, "utf-8");
           hasHeader = content.startsWith("#");
           const lines = content.split("\n");
           const newLines = [];
@@ -190297,7 +191091,7 @@ function SetConfigUI({ configName, initialValue }) {
             }
           }
           if (found) {
-            fs24.writeFileSync(CONFIG_FILE, newLines.join("\n"));
+            fs25.writeFileSync(CONFIG_FILE, newLines.join("\n"));
             setDone(true);
             return;
           }
@@ -190310,7 +191104,7 @@ function SetConfigUI({ configName, initialValue }) {
         }
         newContent += `${hclLine}
 `;
-        fs24.writeFileSync(CONFIG_FILE, newContent);
+        fs25.writeFileSync(CONFIG_FILE, newContent);
         setDone(true);
       } catch (err) {
         setError(err instanceof Error ? err.message : String(err));
@@ -190349,8 +191143,8 @@ async function configSetCommand(configName, configValue) {
       const hclLine = `${configName} = "${escapedValue}"`;
       let content = "";
       let hasHeader = false;
-      if (fs24.existsSync(CONFIG_FILE)) {
-        content = fs24.readFileSync(CONFIG_FILE, "utf-8");
+      if (fs25.existsSync(CONFIG_FILE)) {
+        content = fs25.readFileSync(CONFIG_FILE, "utf-8");
         hasHeader = content.startsWith("#");
         const lines = content.split("\n");
         const newLines = [];
@@ -190365,7 +191159,7 @@ async function configSetCommand(configName, configValue) {
           }
         }
         if (found) {
-          fs24.writeFileSync(CONFIG_FILE, newLines.join("\n"));
+          fs25.writeFileSync(CONFIG_FILE, newLines.join("\n"));
           console.log(`Config '${configName}' saved to ${CONFIG_FILE}`);
           return;
         }
@@ -190378,7 +191172,7 @@ async function configSetCommand(configName, configValue) {
       }
       newContent += `${hclLine}
 `;
-      fs24.writeFileSync(CONFIG_FILE, newContent);
+      fs25.writeFileSync(CONFIG_FILE, newContent);
       console.log(`Config '${configName}' saved to ${CONFIG_FILE}`);
     } catch (err) {
       console.error("Error:", err instanceof Error ? err.message : String(err));
@@ -190497,24 +191291,38 @@ function logoutCommand() {
 var program = new Command();
 var env = "production";
 var envLabel = env !== "production" ? `[${env.toUpperCase()}] ` : "";
-program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.37").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.39").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").action(initCommand);
 program.command("docs [topic]").description("Fetch LLM-optimized documentation").action(docsCommand);
 program.command("check").description("Validate specific.hcl configuration").action(checkCommand);
-program.command("dev").description("Start local development environment").action(devCommand);
+program.command("dev").description("Start local development environment").option("-k, --key <key>", "Namespace for isolated dev environment (auto-detected from git worktree if not specified)").action((options2) => {
+  const key = options2.key ?? getDefaultKey();
+  devCommand(key);
+});
 program.command("deploy [environment]").description("Deploy to Specific infrastructure").option("--skip-build-test", "Skip local build testing before deploy").action((environment, options2) => {
   deployCommand(environment, options2);
 });
-program.command("exec <service> [args...]").description("Run a one-off command with service environment").passThroughOptions().action(async (service, args) => {
+program.command("exec <service> [args...]").description("Run a one-off command with service environment").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").passThroughOptions().action(async (service, args, options2) => {
   const filteredArgs = args[0] === "--" ? args.slice(1) : args;
-  await execCommand(service, filteredArgs);
+  const key = options2.key ?? getDefaultKey();
+  await execCommand(service, filteredArgs, key);
+});
+program.command("psql [database]").description("Connect to a running Postgres database").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").action((database, options2) => {
+  const key = options2.key ?? getDefaultKey();
+  psqlCommand(database, key);
+});
+program.command("clean").description("Remove .specific directory for a clean slate").option("-k, --key <key>", "Clean only the specified dev environment key").action((options2) => {
+  cleanCommand(options2.key);
 });
-program.command("psql [database]").description("Connect to a running Postgres database").action(psqlCommand);
-program.command("clean").description("Remove .specific directory for a clean slate").action(cleanCommand);
 program.command("secrets [action] [name]").description("Manage secrets").action(secretsCommand);
 program.command("config [action] [name] [value]").description("Manage configuration values").action(configCommand);
 program.command("login").description("Log in to Specific").action(loginCommand);
 program.command("logout").description("Log out of Specific").action(logoutCommand);
+var commandName = process.argv[2] || "help";
+trackEvent("cli_command_invoked", { command: commandName });
+process.on("beforeExit", async () => {
+  await shutdown();
+});
 program.parse();
 /*! Bundled license information: