@specific.dev/cli 0.1.48 → 0.1.49

package/dist/cli.js

@@ -238,15 +238,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path23) => {
-      if (/^[a-z]+:\/\//i.test(path23)) {
-        return path23;
+    convertWslPathToWindows = async (path24) => {
+      if (/^[a-z]+:\/\//i.test(path24)) {
+        return path24;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path23], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path24], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path23;
+        return path24;
       }
     };
   }
@@ -754,8 +754,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) {
@@ -183055,13 +183055,13 @@ function removeCA() {
   }
 }
 function installCAToTrustStore(certPath) {
-  const platform5 = os.platform();
-  if (platform5 === "darwin") {
+  const platform4 = os.platform();
+  if (platform4 === "darwin") {
     execSync(
       `sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${certPath}"`,
       { stdio: "inherit" }
     );
-  } else if (platform5 === "linux") {
+  } else if (platform4 === "linux") {
     if (fs.existsSync("/usr/local/share/ca-certificates")) {
       execSync(
         `sudo cp "${certPath}" /usr/local/share/ca-certificates/specific-local-ca.crt`,
@@ -183078,7 +183078,7 @@ function installCAToTrustStore(certPath) {
       throw new Error("Could not detect Linux certificate trust mechanism");
     }
   } else {
-    throw new Error(`Unsupported platform: ${platform5}`);
+    throw new Error(`Unsupported platform: ${platform4}`);
   }
 }
 function generateCertificate(domain, keys = []) {
@@ -183873,7 +183873,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.48",
+      cli_version: "0.1.49",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),
@@ -183888,6 +183888,11 @@ async function shutdown() {
   }
 }
 
+// src/lib/ui/interactive.ts
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+
 // 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 = `---
@@ -184156,8 +184161,77 @@ function InitUI() {
     " "
   ))));
 }
-function initCommand() {
-  render2(/* @__PURE__ */ React2.createElement(InitUI, null));
+var VALID_AGENT_IDS = options.map((o) => o.id);
+function initCommand(opts) {
+  if (isInteractive()) {
+    render2(/* @__PURE__ */ React2.createElement(InitUI, null));
+    return;
+  }
+  if (!opts.agent || opts.agent.length === 0) {
+    console.error(
+      `Error: --agent is required in non-interactive environments.
+Usage: specific init --agent cursor claude codex
+Valid agents: ${VALID_AGENT_IDS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const invalid = opts.agent.filter((a) => !VALID_AGENT_IDS.includes(a));
+  if (invalid.length > 0) {
+    console.error(
+      `Error: Unknown agent(s): ${invalid.join(", ")}
+Valid agents: ${VALID_AGENT_IDS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const checked = {};
+  for (const agent of opts.agent) {
+    checked[agent] = true;
+  }
+  const result = configureAgents(checked);
+  trackEvent("project_initialized", {
+    agents: opts.agent
+  });
+  const selectedAgents = opts.agent.length;
+  const agentChanges = result.agents.filesCreated.length > 0 || result.agents.filesModified.length > 0;
+  console.log("\u2713 Coding agents configured");
+  if (result.agents.filesCreated.length > 0) {
+    console.log(`  Created: ${result.agents.filesCreated.join(", ")}`);
+  }
+  if (result.agents.filesModified.length > 0) {
+    console.log(`  Modified: ${result.agents.filesModified.join(", ")}`);
+  }
+  if (!agentChanges && selectedAgents > 0) {
+    console.log("  No changes needed (files already configured)");
+  }
+  if (result.git) {
+    const gitChanges = result.git.filesCreated.length > 0 || result.git.filesModified.length > 0;
+    console.log("\u2713 Git configured");
+    if (result.git.filesCreated.length > 0) {
+      console.log(`  Created: ${result.git.filesCreated.join(", ")}`);
+    }
+    if (result.git.filesModified.length > 0) {
+      console.log(`  Modified: ${result.git.filesModified.join(", ")}`);
+    }
+    if (!gitChanges) {
+      console.log("  No changes needed (.gitignore already configured)");
+    }
+  }
+  if (!caFilesExist()) {
+    console.log(
+      "\u26A0 TLS certificates not installed (run `specific init` in a terminal to set up)"
+    );
+  }
+  if (result.showManualInstructions) {
+    console.log("\n\u2713 Manual configuration selected");
+    console.log("\n  Add this to your agent's system prompt:");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`  ${SPECIFIC_INSTRUCTIONS}`);
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(
+      "\n  We also recommend allowing your agent to run `specific docs *`"
+    );
+    console.log("  and `specific check *` without confirmation.");
+  }
 }
 
 // src/commands/docs.tsx
@@ -184166,11 +184240,11 @@ import { join as join6, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var docsDir = join6(__dirname2, "docs");
-function docsCommand(path23) {
-  const docPath = resolveDocPath(path23);
+function docsCommand(path24) {
+  const docPath = resolveDocPath(path24);
   if (!docPath) {
     console.error(
-      `Documentation not found: ${path23 || "index"}
+      `Documentation not found: ${path24 || "index"}
 
 Run 'specific docs' to see available topics.`
     );
@@ -184179,16 +184253,16 @@ Run 'specific docs' to see available topics.`
   const content = readFileSync5(docPath, "utf-8");
   console.log(content);
 }
-function resolveDocPath(path23) {
-  if (!path23) {
+function resolveDocPath(path24) {
+  if (!path24) {
     const indexPath2 = join6(docsDir, "index.md");
     return existsSync5(indexPath2) ? indexPath2 : null;
   }
-  const directPath = join6(docsDir, `${path23}.md`);
+  const directPath = join6(docsDir, `${path24}.md`);
   if (existsSync5(directPath)) {
     return directPath;
   }
-  const indexPath = join6(docsDir, path23, "index.md");
+  const indexPath = join6(docsDir, path24, "index.md");
   if (existsSync5(indexPath)) {
     return indexPath;
   }
@@ -184283,7 +184357,7 @@ function parseReferenceString(str) {
       attribute: "port"
     };
   }
-  const serviceEndpointMatch = str.match(/^service\.(\w+)\.endpoint\.(\w+)\.(url|host|port)$/);
+  const serviceEndpointMatch = str.match(/^service\.(\w+)\.endpoint\.(\w+)\.(url|private_url|host|port|public_url)$/);
   if (serviceEndpointMatch && serviceEndpointMatch[1] && serviceEndpointMatch[2] && serviceEndpointMatch[3]) {
     return {
       type: "service",
@@ -184292,7 +184366,7 @@ function parseReferenceString(str) {
       attribute: serviceEndpointMatch[3]
     };
   }
-  const serviceMatch = str.match(/^service\.(\w+)\.(url|host|port)$/);
+  const serviceMatch = str.match(/^service\.(\w+)\.(url|private_url|host|port|public_url)$/);
   if (serviceMatch && serviceMatch[1] && serviceMatch[2]) {
     return {
       type: "service",
@@ -184397,6 +184471,17 @@ function parseBuilds(buildData) {
     if (dev) {
       build.dev = dev;
     }
+    const env2 = parseEnv(fieldObj.env);
+    if (env2) {
+      for (const [key, value] of Object.entries(env2)) {
+        if (typeof value === "string")
+          continue;
+        if (value.type === "service" && value.attribute === "public_url")
+          continue;
+        throw new Error(`Build "${name}" env var "${key}" uses an unsupported reference type. Build env vars only support string literals and \${service.<name>.public_url} references.`);
+      }
+      build.env = env2;
+    }
     builds.push(build);
   }
   return builds;
@@ -184704,6 +184789,26 @@ function validateEndpointReferences(config) {
               });
             }
           }
+          if (serviceRef.attribute === "public_url") {
+            const endpointName = serviceRef.endpointName;
+            if (endpointName) {
+              const targetEndpoint = targetEndpoints.find((e) => e.name === endpointName);
+              if (targetEndpoint && !targetEndpoint.public) {
+                errors.push({
+                  service: service.name,
+                  message: `Service "${service.name}" references public_url of endpoint "${endpointName}" on service "${serviceRef.serviceName}" in env var "${key}", but that endpoint is not public. Add \`public = true\` to the endpoint.`
+                });
+              }
+            } else {
+              const defaultEndpoint = targetEndpoints.length === 1 ? targetEndpoints[0] : targetEndpoints.find((e) => e.name === "default");
+              if (defaultEndpoint && !defaultEndpoint.public) {
+                errors.push({
+                  service: service.name,
+                  message: `Service "${service.name}" references public_url of service "${serviceRef.serviceName}" in env var "${key}", but its endpoint is not public. Add \`public = true\` to the endpoint.`
+                });
+              }
+            }
+          }
         }
         if (typeof value === "object" && value.type === "endpoint") {
           const endpointRef = value;
@@ -184860,7 +184965,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path23) => statMethod(path23, { bigint: true });
+      this._stat = (path24) => statMethod(path24, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -184885,8 +184990,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path23, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+          const { path: path24, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path24));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -184926,20 +185031,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path23, depth) {
+  async _exploreDir(path24, depth) {
     let files;
     try {
-      files = await readdir(path23, this._rdOptions);
+      files = await readdir(path24, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path23 };
+    return { files, depth, path: path24 };
   }
-  async _formatEntry(dirent, path23) {
+  async _formatEntry(dirent, path24) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path23, basename5));
+      const fullPath = presolve(pjoin(path24, basename5));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -185339,16 +185444,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path23, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path24, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, evPath));
+    listener(path24);
+    emitRaw(rawEvent, evPath, { watchedPath: path24 });
+    if (evPath && path24 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path24, evPath), KEY_LISTENERS, sp.join(path24, evPath));
     }
   };
   try {
-    return fs_watch(path23, {
+    return fs_watch(path24, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -185364,12 +185469,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path23, fullPath, options2, handlers) => {
+var setFsWatchListener = (path24, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path23, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path24, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -185380,7 +185485,7 @@ var setFsWatchListener = (path23, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path23,
+      path24,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -185395,7 +185500,7 @@ var setFsWatchListener = (path23, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open2(path23, "r");
+          const fd = await open2(path24, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -185426,7 +185531,7 @@ var setFsWatchListener = (path23, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path23, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path24, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -185448,7 +185553,7 @@ var setFsWatchFileListener = (path23, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path23, curr));
+          foreach(cont.listeners, (listener2) => listener2(path24, curr));
         }
       })
     };
@@ -185478,13 +185583,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path23, listener) {
+  _watchWithNodeFs(path24, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path23);
-    const basename5 = sp.basename(path23);
+    const directory = sp.dirname(path24);
+    const basename5 = sp.basename(path24);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sp.resolve(path23);
+    const absolutePath = sp.resolve(path24);
     const options2 = {
       persistent: opts.persistent
     };
@@ -185494,12 +185599,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path23, absolutePath, options2, {
+      closer = setFsWatchFileListener(path24, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path23, absolutePath, options2, {
+      closer = setFsWatchListener(path24, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -185521,7 +185626,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path23, newStats) => {
+    const listener = async (path24, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -185535,11 +185640,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path23);
+            this.fsw._closeFile(path24);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path23, closer2);
+              this.fsw._addPathCloser(path24, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -185571,7 +185676,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, path23, item) {
+  async _handleSymlink(entry, directory, path24, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -185581,7 +185686,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path23);
+        linkPath = await fsrealpath(path24);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -185591,12 +185696,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, path23, entry.stats);
+          this.fsw._emit(EV.CHANGE, path24, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path23, entry.stats);
+        this.fsw._emit(EV.ADD, path24, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -185626,9 +185731,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path23 = sp.join(directory, item);
+      let path24 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -185637,8 +185742,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path23 = sp.join(dir, sp.relative(dir, path23));
-        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
+        path24 = sp.join(dir, sp.relative(dir, path24));
+        this._addToNodeFs(path24, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve7, reject) => {
@@ -185707,13 +185812,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path24) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path23);
+    const wh = this.fsw._getWatchHelpers(path24);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -185729,8 +185834,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path23);
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        const absPath = sp.resolve(path24);
+        const targetPath = follow ? await fsrealpath(path24) : path24;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -185740,29 +185845,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        const targetPath = follow ? await fsrealpath(path24) : path24;
         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, path23, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path24, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path23), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path24), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path23, closer);
+        this.fsw._addPathCloser(path24, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path23;
+        return path24;
       }
     }
   }
@@ -185805,24 +185910,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path23) {
-  if (typeof path23 !== "string")
+function normalizePath(path24) {
+  if (typeof path24 !== "string")
     throw new Error("string expected");
-  path23 = sp2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path24 = sp2.normalize(path24);
+  path24 = path24.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path24.startsWith("//"))
     prepend = true;
-  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
+  path24 = path24.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path24 = "/" + path24;
+  return path24;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath(testString);
+  const path24 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path24, stats)) {
       return true;
     }
   }
@@ -185860,19 +185965,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path23) => toUnix(sp2.normalize(toUnix(path23)));
-var normalizeIgnored = (cwd = "") => (path23) => {
-  if (typeof path23 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path23) ? path23 : sp2.join(cwd, path23));
+var normalizePathToUnix = (path24) => toUnix(sp2.normalize(toUnix(path24)));
+var normalizeIgnored = (cwd = "") => (path24) => {
+  if (typeof path24 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path24) ? path24 : sp2.join(cwd, path24));
   } else {
-    return path23;
+    return path24;
   }
 };
-var getAbsolutePath = (path23, cwd) => {
-  if (sp2.isAbsolute(path23)) {
-    return path23;
+var getAbsolutePath = (path24, cwd) => {
+  if (sp2.isAbsolute(path24)) {
+    return path24;
   }
-  return sp2.join(cwd, path23);
+  return sp2.join(cwd, path24);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -185937,10 +186042,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path23, follow, fsw) {
+  constructor(path24, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path23;
-    this.path = path23 = path23.replace(REPLACER_RE, "");
+    const watchPath = path24;
+    this.path = path24 = path24.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -186080,20 +186185,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path23) => {
-        const absPath = getAbsolutePath(path23, cwd);
+      paths = paths.map((path24) => {
+        const absPath = getAbsolutePath(path24, cwd);
         return absPath;
       });
     }
-    paths.forEach((path23) => {
-      this._removeIgnoredPath(path23);
+    paths.forEach((path24) => {
+      this._removeIgnoredPath(path24);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path23) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path24) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -186115,17 +186220,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path23) => {
-      if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
+    paths.forEach((path24) => {
+      if (!sp2.isAbsolute(path24) && !this._closers.has(path24)) {
         if (cwd)
-          path23 = sp2.join(cwd, path23);
-        path23 = sp2.resolve(path23);
+          path24 = sp2.join(cwd, path24);
+        path24 = sp2.resolve(path24);
       }
-      this._closePath(path23);
-      this._addIgnoredPath(path23);
-      if (this._watched.has(path23)) {
+      this._closePath(path24);
+      this._addIgnoredPath(path24);
+      if (this._watched.has(path24)) {
         this._addIgnoredPath({
-          path: path23,
+          path: path24,
           recursive: true
         });
       }
@@ -186189,38 +186294,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, path23, stats) {
+  async _emit(event, path24, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path23 = sp2.normalize(path23);
+      path24 = sp2.normalize(path24);
     if (opts.cwd)
-      path23 = sp2.relative(opts.cwd, path23);
-    const args = [path23];
+      path24 = sp2.relative(opts.cwd, path24);
+    const args = [path24];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path23))) {
+    if (awf && (pw = this._pendingWrites.get(path24))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path23, [event, ...args]);
+        this._pendingUnlinks.set(path24, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path24) => {
+          this._pendingUnlinks.forEach((entry, path25) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path24);
+            this._pendingUnlinks.delete(path25);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path23);
+        this._pendingUnlinks.delete(path24);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -186238,16 +186343,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path24, 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, path23) : path23;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path24) : path24;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -186278,23 +186383,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, path23, timeout) {
+  _throttle(actionType, path24, 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(path23);
+    const actionPath = action.get(path24);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path23);
+      const item = action.get(path24);
       const count = item ? item.count : 0;
-      action.delete(path23);
+      action.delete(path24);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -186302,7 +186407,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path23, thr);
+    action.set(path24, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -186316,44 +186421,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path23, threshold, event, awfEmit) {
+  _awaitWriteFinish(path24, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path23;
-    if (this.options.cwd && !sp2.isAbsolute(path23)) {
-      fullPath = sp2.join(this.options.cwd, path23);
+    let fullPath = path24;
+    if (this.options.cwd && !sp2.isAbsolute(path24)) {
+      fullPath = sp2.join(this.options.cwd, path24);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path23)) {
+        if (err || !writes.has(path24)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path23).lastChange = now2;
+          writes.get(path24).lastChange = now2;
         }
-        const pw = writes.get(path23);
+        const pw = writes.get(path24);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path23);
+          writes.delete(path24);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path23)) {
-      writes.set(path23, {
+    if (!writes.has(path24)) {
+      writes.set(path24, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path23);
+          writes.delete(path24);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -186364,8 +186469,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path23, stats) {
-    if (this.options.atomic && DOT_RE.test(path23))
+  _isIgnored(path24, stats) {
+    if (this.options.atomic && DOT_RE.test(path24))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -186375,17 +186480,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path23, stats);
+    return this._userIgnored(path24, stats);
   }
-  _isntIgnored(path23, stat4) {
-    return !this._isIgnored(path23, stat4);
+  _isntIgnored(path24, stat4) {
+    return !this._isIgnored(path24, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path23) {
-    return new WatchHelper(path23, this.options.followSymlinks, this);
+  _getWatchHelpers(path24) {
+    return new WatchHelper(path24, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -186417,63 +186522,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path23 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path23);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path23, 100))
+    const path24 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path24);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path24) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path24, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path23);
+    const wp = this._getWatchedDir(path24);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path24, 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 = path23;
+    let relPath = path24;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path23);
+      relPath = sp2.relative(this.options.cwd, path24);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path23);
+    this._watched.delete(path24);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path23))
-      this._emit(eventName, path23);
-    this._closePath(path23);
+    if (wasTracked && !this._isIgnored(path24))
+      this._emit(eventName, path24);
+    this._closePath(path24);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path23) {
-    this._closeFile(path23);
-    const dir = sp2.dirname(path23);
-    this._getWatchedDir(dir).remove(sp2.basename(path23));
+  _closePath(path24) {
+    this._closeFile(path24);
+    const dir = sp2.dirname(path24);
+    this._getWatchedDir(dir).remove(sp2.basename(path24));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path23) {
-    const closers = this._closers.get(path23);
+  _closeFile(path24) {
+    const closers = this._closers.get(path24);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path23);
+    this._closers.delete(path24);
   }
-  _addPathCloser(path23, closer) {
+  _addPathCloser(path24, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path23);
+    let list = this._closers.get(path24);
     if (!list) {
       list = [];
-      this._closers.set(path23, list);
+      this._closers.set(path24, list);
     }
     list.push(closer);
   }
@@ -186591,7 +186696,6 @@ var StablePortAllocator = class {
 import * as fs14 from "fs";
 import * as path10 from "path";
 import * as net from "net";
-import * as os7 from "os";
 import { spawn } from "child_process";
 
 // src/lib/bin/types.ts
@@ -186634,15 +186738,27 @@ import * as path9 from "path";
 import * as os6 from "os";
 import { createReadStream } from "fs";
 import { createTarExtractor, extractTo } from "tar-vern";
+function getLibraryEnv(binary) {
+  if (!binary.libraryPath) {
+    return {};
+  }
+  const platform4 = os6.platform();
+  if (platform4 === "darwin") {
+    return { DYLD_LIBRARY_PATH: binary.libraryPath };
+  } else if (platform4 === "linux") {
+    return { LD_LIBRARY_PATH: binary.libraryPath };
+  }
+  return {};
+}
 function getBinBaseDir() {
   return path9.join(os6.homedir(), ".specific", "bin");
 }
 function getPlatformInfo() {
-  const platform5 = os6.platform();
+  const platform4 = os6.platform();
   const arch3 = os6.arch();
-  if (platform5 !== "darwin" && platform5 !== "linux") {
+  if (platform4 !== "darwin" && platform4 !== "linux") {
     throw new Error(
-      `Unsupported platform: ${platform5}. Only macOS and Linux are supported.`
+      `Unsupported platform: ${platform4}. Only macOS and Linux are supported.`
     );
   }
   const archStr = arch3;
@@ -186656,7 +186772,7 @@ function getPlatformInfo() {
       `Unsupported architecture: ${arch3}. Only x64 and arm64 are supported.`
     );
   }
-  return { platform: platform5, arch: mappedArch };
+  return { platform: platform4, arch: mappedArch };
 }
 function getBinaryDir(definition, version, platformInfo) {
   return path9.join(
@@ -186832,7 +186948,7 @@ var postgresBinary = {
   // Archive contains bin/ and lib/ directories at root
   stripComponents: 0,
   // Core PostgreSQL executables (in bin/ directory)
-  executables: ["bin/postgres", "bin/initdb"],
+  executables: ["bin/postgres", "bin/initdb", "bin/psql"],
   // Library directory relative to root (for setting LD_LIBRARY_PATH)
   libraryDir: "lib"
 };
@@ -186904,18 +187020,6 @@ var drizzleGatewayBinary = {
 };
 
 // src/lib/dev/database-manager.ts
-function getLibraryEnv(binary) {
-  if (!binary.libraryPath) {
-    return {};
-  }
-  const platform5 = os7.platform();
-  if (platform5 === "darwin") {
-    return { DYLD_LIBRARY_PATH: binary.libraryPath };
-  } else if (platform5 === "linux") {
-    return { LD_LIBRARY_PATH: binary.libraryPath };
-  }
-  return {};
-}
 async function startPostgres(pg, port, dataDir, onProgress) {
   const binary = await ensureBinary(postgresBinary, void 0, onProgress);
   const dbDataPath = path10.join(process.cwd(), dataDir, pg.name);
@@ -187271,7 +187375,7 @@ config {
     this.name = "MissingConfigError";
   }
 };
-function resolveEnvValue(value, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts) {
+function resolveEnvValue(value, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts, publicUrls) {
   if (typeof value === "string") {
     return value;
   }
@@ -187312,11 +187416,25 @@ function resolveEnvValue(value, resources, secrets, configs, servicePort, servic
       }
       switch (serviceRef.attribute) {
         case "url":
+        case "private_url":
           return `localhost:${endpoint.port}`;
         case "host":
           return "localhost";
         case "port":
           return String(endpoint.port);
+        case "public_url": {
+          if (!publicUrls) {
+            throw new Error("public_url reference used but no public URL map provided");
+          }
+          const k8sName = endpointName === "default" ? serviceRef.serviceName : `${serviceRef.serviceName}-${endpointName}`;
+          const publicUrl = publicUrls.get(k8sName);
+          if (!publicUrl) {
+            throw new Error(
+              `No public URL found for service "${serviceRef.serviceName}" endpoint "${endpointName}"`
+            );
+          }
+          return publicUrl;
+        }
         default:
           throw new Error(`Unknown service attribute: ${serviceRef.attribute}`);
       }
@@ -187421,7 +187539,7 @@ function resolveEnvValue(value, resources, secrets, configs, servicePort, servic
       throw new Error(`Unknown reference type`);
   }
 }
-function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts) {
+function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts, publicUrls) {
   if (!env2) {
     return {};
   }
@@ -187434,7 +187552,8 @@ function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpo
       configs,
       servicePort,
       serviceEndpoints,
-      currentServicePorts
+      currentServicePorts,
+      publicUrls
     );
   }
   return resolved;
@@ -187458,7 +187577,7 @@ function resolveEnvForExec(env2, resources, secrets, configs) {
 }
 
 // src/lib/dev/service-runner.ts
-function startService(service, resources, secrets, configs, endpointPorts, serviceEndpoints, onLog) {
+function startService(service, resources, secrets, configs, endpointPorts, serviceEndpoints, onLog, publicUrls) {
   const command = service.dev?.command ?? service.command;
   if (!command) {
     throw new Error(`Service "${service.name}" has no command`);
@@ -187475,7 +187594,8 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     configs,
     defaultPort,
     serviceEndpoints,
-    endpointPorts
+    endpointPorts,
+    publicUrls
   );
   const child = spawn2(command, {
     shell: true,
@@ -188720,7 +188840,7 @@ async function startTunnel(serviceName, endpointName, port, subdomain, callbacks
 // src/lib/dev/proxy-registry.ts
 import * as fs19 from "fs";
 import * as path16 from "path";
-import * as os8 from "os";
+import * as os7 from "os";
 import * as net4 from "net";
 var ProxyRegistryManager = class {
   proxyDir;
@@ -188730,7 +188850,7 @@ var ProxyRegistryManager = class {
   isOwner = false;
   registryWatcher = null;
   constructor() {
-    this.proxyDir = path16.join(os8.homedir(), ".specific", "proxy");
+    this.proxyDir = path16.join(os7.homedir(), ".specific", "proxy");
     this.ownerPath = path16.join(this.proxyDir, "owner.json");
     this.registryPath = path16.join(this.proxyDir, "registry.json");
     this.lockPath = path16.join(this.proxyDir, "registry.lock");
@@ -189175,11 +189295,6 @@ function ConfigInput({ configName, onSubmit, onCancel }) {
   return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, null, "Enter value for config ", /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, configName), ":"), /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(Text5, null, value), /* @__PURE__ */ React5.createElement(Text5, { color: "gray" }, "|")), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Press Enter to save, Esc to cancel)"));
 }
 
-// src/lib/ui/interactive.ts
-function isInteractive() {
-  return process.stdin.isTTY === true && process.stdout.isTTY === true;
-}
-
 // src/commands/dev.tsx
 var COLORS = ["cyan", "yellow", "green", "magenta", "blue"];
 function DevUI({ instanceKey, tunnelEnabled }) {
@@ -189305,6 +189420,9 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       // Stop all tunnels
       ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
+    if (tunnelsRef.current.length > 0) {
+      await new Promise((resolve7) => setTimeout(resolve7, 1500));
+    }
     electricInstancesRef.current = [];
     drizzleGatewayRef.current = null;
     proxyRef.current = null;
@@ -189724,6 +189842,39 @@ Add them to the config block in specific.local`);
         serviceEndpointPorts.set(service.name, endpointPorts);
         serviceEndpoints.set(service.name, endpointInfos);
       }
+      const serviceInfos = [];
+      const exposedServices = [];
+      for (const service of config2.services) {
+        const endpointInfos = serviceEndpoints.get(service.name) || [];
+        for (const info of endpointInfos) {
+          const endpointConfig = service.endpoints.find(
+            (e) => e.name === info.endpointName
+          );
+          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
+            });
+          }
+        }
+      }
+      const publicUrls = /* @__PURE__ */ new Map();
+      let subdomainAllocator;
+      if (tunnelEnabled && exposedServices.length > 0) {
+        subdomainAllocator = new StableSubdomainAllocator(process.cwd(), instanceKey);
+        const multipleServices = exposedServices.length > 1;
+        for (const svc of exposedServices) {
+          const subdomain = subdomainAllocator.allocate(svc.name, multipleServices);
+          publicUrls.set(svc.name, `${subdomain}.tunnel.spcf.app`);
+        }
+      } else {
+        const keySuffix = instanceKey === "default" ? "" : `.${instanceKey}`;
+        for (const svc of exposedServices) {
+          publicUrls.set(svc.name, `${svc.name}${keySuffix}.local.spcf.app`);
+        }
+      }
       const services2 = [];
       for (const service of config2.services) {
         if (cancelled) break;
@@ -189747,7 +189898,8 @@ Add them to the config block in specific.local`);
             configs,
             endpointPorts,
             serviceEndpoints,
-            (line) => addLog(line, colorMap)
+            (line) => addLog(line, colorMap),
+            publicUrls
           );
           services2.push(running);
           startedServices.push(running);
@@ -189775,30 +189927,11 @@ Add them to the config block in specific.local`);
         }
       }
       if (cancelled) return;
-      const serviceInfos = [];
-      const exposedServices = [];
-      for (const service of config2.services) {
-        const endpointInfos = serviceEndpoints.get(service.name) || [];
-        for (const info of endpointInfos) {
-          const endpointConfig = service.endpoints.find(
-            (e) => e.name === info.endpointName
-          );
-          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
-            });
-          }
-        }
-      }
       if (tunnelEnabled) {
         writeLog("system", "Tunnel mode enabled, starting tunnels for public services");
         if (exposedServices.length === 0) {
           writeLog("system", "No public services to tunnel");
         } else {
-          const subdomainAllocator = new StableSubdomainAllocator(process.cwd(), instanceKey);
           const multipleServices = exposedServices.length > 1;
           const tunnelInstances = [];
           const tunnelStatusMap = /* @__PURE__ */ new Map();
@@ -191654,27 +191787,48 @@ async function execCommand(serviceName, command, instanceKey = "default") {
 
 // src/commands/psql.tsx
 import { spawn as spawn7 } from "child_process";
-async function psqlCommand(databaseName, instanceKey = "default") {
-  const stateManager = new InstanceStateManager(process.cwd(), instanceKey);
-  await stateManager.cleanStaleState();
-  const existingInstances = await stateManager.getExistingInstances();
-  if (!existingInstances) {
-    console.error("Error: No running instances found. Run `specific dev` first.");
+import * as fs24 from "fs";
+import * as path22 from "path";
+async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []) {
+  let startedResources = [];
+  let ownsInstances = false;
+  let stateManager = null;
+  const cleanup = async () => {
+    if (ownsInstances) {
+      for (const resource of startedResources) {
+        await resource.stop().catch(() => {
+        });
+      }
+      if (stateManager) {
+        await stateManager.releaseOwnership().catch(() => {
+        });
+      }
+    }
+  };
+  const configPath = path22.join(process.cwd(), "specific.hcl");
+  if (!fs24.existsSync(configPath)) {
+    console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
-  const availableDatabases = Object.keys(existingInstances.databases);
+  let config;
+  try {
+    const hcl = fs24.readFileSync(configPath, "utf-8");
+    config = await parseConfig(hcl);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const availableDatabases = config.postgres.map((p) => p.name);
   if (availableDatabases.length === 0) {
-    console.error("Error: No databases found in running instances.");
+    console.error("Error: No postgres databases defined in specific.hcl");
     process.exit(1);
   }
   let targetDb;
+  if (databaseName && !availableDatabases.includes(databaseName)) {
+    extraArgs = [databaseName, ...extraArgs];
+    databaseName = void 0;
+  }
   if (databaseName) {
-    if (!existingInstances.databases[databaseName]) {
-      console.error(
-        `Error: Database "${databaseName}" not found. Available: ${availableDatabases.join(", ")}`
-      );
-      process.exit(1);
-    }
     targetDb = databaseName;
   } else {
     if (availableDatabases.length > 1) {
@@ -191685,24 +191839,95 @@ async function psqlCommand(databaseName, instanceKey = "default") {
     }
     targetDb = availableDatabases[0];
   }
-  const dbState = existingInstances.databases[targetDb];
-  const child = spawn7("psql", ["-h", dbState.host, "-p", String(dbState.port), "-U", dbState.user, "-d", dbState.dbName], {
+  stateManager = new InstanceStateManager(process.cwd(), instanceKey);
+  await stateManager.cleanStaleState();
+  const existingInstances = await stateManager.getExistingInstances();
+  let dbState;
+  if (existingInstances && existingInstances.databases[targetDb]) {
+    const db = existingInstances.databases[targetDb];
+    dbState = { host: db.host, port: db.port, user: db.user, password: db.password, dbName: db.dbName };
+  } else {
+    console.error("Starting database...");
+    try {
+      await stateManager.claimOwnership("psql");
+      ownsInstances = true;
+    } catch (err) {
+      console.error(
+        `Error: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+    try {
+      const result = await startResources({
+        config,
+        selection: {
+          mode: "required",
+          postgres: [targetDb],
+          redis: [],
+          storage: []
+        },
+        stateManager,
+        dataDir: `.specific/keys/${instanceKey}/data`,
+        portAllocator: new PortAllocator(),
+        callbacks: {
+          log: (msg) => console.error(msg)
+        },
+        startElectric: false
+      });
+      startedResources = result.startedResources;
+      const resource = result.resources.get(targetDb);
+      if (!resource) {
+        console.error(`Error: Failed to start database "${targetDb}"`);
+        await cleanup();
+        process.exit(1);
+      }
+      dbState = {
+        host: resource.host,
+        port: resource.port,
+        user: resource.user,
+        password: resource.password,
+        dbName: resource.dbName
+      };
+    } catch (err) {
+      console.error(
+        `Error: Failed to start database: ${err instanceof Error ? err.message : String(err)}`
+      );
+      await cleanup();
+      process.exit(1);
+    }
+  }
+  const binary = await ensureBinary(postgresBinary);
+  const psqlPath = binary.executables["psql"];
+  const libraryEnv = getLibraryEnv(binary);
+  let child = null;
+  const handleSignal = async (signal) => {
+    if (child && !child.killed) {
+      child.kill(signal);
+    }
+    await cleanup();
+  };
+  process.on("SIGINT", () => handleSignal("SIGINT"));
+  process.on("SIGTERM", () => handleSignal("SIGTERM"));
+  child = spawn7(psqlPath, ["-h", dbState.host, "-p", String(dbState.port), "-U", dbState.user, "-d", dbState.dbName, ...extraArgs], {
     cwd: process.cwd(),
     env: {
       ...process.env,
+      ...libraryEnv,
       PGPASSWORD: dbState.password
     },
     stdio: "inherit"
   });
-  child.on("exit", (code, signal) => {
+  child.on("exit", async (code, signal) => {
+    await cleanup();
     if (signal) {
       process.kill(process.pid, signal);
     } else {
       process.exit(code ?? 0);
     }
   });
-  child.on("error", (err) => {
+  child.on("error", async (err) => {
     console.error(`Error: Failed to start psql: ${err.message}`);
+    await cleanup();
     process.exit(1);
   });
 }
@@ -191711,21 +191936,21 @@ async function psqlCommand(databaseName, instanceKey = "default") {
 import React8, { useState as useState7, useEffect as useEffect5 } from "react";
 import { render as render6, Text as Text8, Box as Box8 } from "ink";
 import Spinner6 from "ink-spinner";
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 function CleanUI({ instanceKey }) {
   const [state, setState] = useState7({ status: "checking" });
   useEffect5(() => {
     async function clean() {
       const projectRoot = process.cwd();
-      const specificDir = path22.join(projectRoot, ".specific");
-      if (!fs24.existsSync(specificDir)) {
+      const specificDir = path23.join(projectRoot, ".specific");
+      if (!fs25.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
-        const keyDir = path22.join(specificDir, "keys", instanceKey);
-        if (!fs24.existsSync(keyDir)) {
+        const keyDir = path23.join(specificDir, "keys", instanceKey);
+        if (!fs25.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -191741,7 +191966,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs24.rmSync(keyDir, { recursive: true, force: true });
+          fs25.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191750,10 +191975,10 @@ function CleanUI({ instanceKey }) {
           });
         }
       } else {
-        const keysDir = path22.join(specificDir, "keys");
-        if (fs24.existsSync(keysDir)) {
-          const keys = fs24.readdirSync(keysDir).filter(
-            (f) => fs24.statSync(path22.join(keysDir, f)).isDirectory()
+        const keysDir = path23.join(specificDir, "keys");
+        if (fs25.existsSync(keysDir)) {
+          const keys = fs25.readdirSync(keysDir).filter(
+            (f) => fs25.statSync(path23.join(keysDir, f)).isDirectory()
           );
           for (const key of keys) {
             const stateManager2 = new InstanceStateManager(projectRoot, key);
@@ -191778,7 +192003,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs24.rmSync(specificDir, { recursive: true, force: true });
+          fs25.rmSync(specificDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191865,8 +192090,8 @@ 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.48").enablePositionalOptions();
-program.command("init").description("Initialize project for use with a coding agent").action(initCommand);
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.49").enablePositionalOptions();
+program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").action((options2) => initCommand(options2));
 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").option("-k, --key <key>", "Namespace for isolated dev environment (auto-detected from git worktree if not specified)").option("--tunnel", "Expose public services via localtunnel URLs").action((options2) => {
@@ -191881,9 +192106,10 @@ program.command("exec <service> [args...]").description("Run a one-off command w
   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) => {
+program.command("psql [database] [args...]").description("Connect to a Postgres database").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").passThroughOptions().action((database, args, options2) => {
+  const filteredArgs = args[0] === "--" ? args.slice(1) : args;
   const key = options2.key ?? getDefaultKey();
-  psqlCommand(database, key);
+  psqlCommand(database, key, filteredArgs);
 });
 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);