@specific.dev/cli 0.1.47 → 0.1.48

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 (path22) => {
-      if (/^[a-z]+:\/\//i.test(path22)) {
-        return path22;
+    convertWslPathToWindows = async (path23) => {
+      if (/^[a-z]+:\/\//i.test(path23)) {
+        return path23;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path22], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path23], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path22;
+        return path23;
       }
     };
   }
@@ -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 fs24 = $global.require("fs");
-        "object" == typeof fs24 && null !== fs24 && 0 !== Object.keys(fs24).length && ($global.fs = fs24);
+        var fs25 = $global.require("fs");
+        "object" == typeof fs25 && null !== fs25 && 0 !== Object.keys(fs25).length && ($global.fs = fs25);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183873,7 +183873,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.47",
+      cli_version: "0.1.48",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),
@@ -184166,11 +184166,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(path22) {
-  const docPath = resolveDocPath(path22);
+function docsCommand(path23) {
+  const docPath = resolveDocPath(path23);
   if (!docPath) {
     console.error(
-      `Documentation not found: ${path22 || "index"}
+      `Documentation not found: ${path23 || "index"}
 
 Run 'specific docs' to see available topics.`
     );
@@ -184179,16 +184179,16 @@ Run 'specific docs' to see available topics.`
   const content = readFileSync5(docPath, "utf-8");
   console.log(content);
 }
-function resolveDocPath(path22) {
-  if (!path22) {
+function resolveDocPath(path23) {
+  if (!path23) {
     const indexPath2 = join6(docsDir, "index.md");
     return existsSync5(indexPath2) ? indexPath2 : null;
   }
-  const directPath = join6(docsDir, `${path22}.md`);
+  const directPath = join6(docsDir, `${path23}.md`);
   if (existsSync5(directPath)) {
     return directPath;
   }
-  const indexPath = join6(docsDir, path22, "index.md");
+  const indexPath = join6(docsDir, path23, "index.md");
   if (existsSync5(indexPath)) {
     return indexPath;
   }
@@ -184767,8 +184767,8 @@ function checkCommand() {
 import React6, { useState as useState5, useEffect as useEffect3, useRef } from "react";
 import { render as render4, Text as Text6, Box as Box6, useApp as useApp2, Static } from "ink";
 import Spinner4 from "ink-spinner";
-import * as fs19 from "fs";
-import * as path16 from "path";
+import * as fs20 from "fs";
+import * as path17 from "path";
 
 // node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
@@ -184860,7 +184860,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path22) => statMethod(path22, { bigint: true });
+      this._stat = (path23) => statMethod(path23, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -184885,8 +184885,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path22, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
+          const { path: path23, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -184926,20 +184926,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path22, depth) {
+  async _exploreDir(path23, depth) {
     let files;
     try {
-      files = await readdir(path22, this._rdOptions);
+      files = await readdir(path23, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path22 };
+    return { files, depth, path: path23 };
   }
-  async _formatEntry(dirent, path22) {
+  async _formatEntry(dirent, path23) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path22, basename5));
+      const fullPath = presolve(pjoin(path23, basename5));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -185339,16 +185339,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path22, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path23, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path22);
-    emitRaw(rawEvent, evPath, { watchedPath: path22 });
-    if (evPath && path22 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
+    listener(path23);
+    emitRaw(rawEvent, evPath, { watchedPath: path23 });
+    if (evPath && path23 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, evPath));
     }
   };
   try {
-    return fs_watch(path22, {
+    return fs_watch(path23, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -185364,12 +185364,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path22, fullPath, options2, handlers) => {
+var setFsWatchListener = (path23, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path22, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path23, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -185380,7 +185380,7 @@ var setFsWatchListener = (path22, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path22,
+      path23,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -185395,7 +185395,7 @@ var setFsWatchListener = (path22, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open2(path22, "r");
+          const fd = await open2(path23, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -185426,7 +185426,7 @@ var setFsWatchListener = (path22, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path23, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -185448,7 +185448,7 @@ var setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path22, curr));
+          foreach(cont.listeners, (listener2) => listener2(path23, curr));
         }
       })
     };
@@ -185478,13 +185478,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path22, listener) {
+  _watchWithNodeFs(path23, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path22);
-    const basename5 = sp.basename(path22);
+    const directory = sp.dirname(path23);
+    const basename5 = sp.basename(path23);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sp.resolve(path22);
+    const absolutePath = sp.resolve(path23);
     const options2 = {
       persistent: opts.persistent
     };
@@ -185494,12 +185494,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path22, absolutePath, options2, {
+      closer = setFsWatchFileListener(path23, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path22, absolutePath, options2, {
+      closer = setFsWatchListener(path23, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -185521,7 +185521,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path22, newStats) => {
+    const listener = async (path23, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -185535,11 +185535,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path22);
+            this.fsw._closeFile(path23);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path22, closer2);
+              this.fsw._addPathCloser(path23, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -185571,7 +185571,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, path22, item) {
+  async _handleSymlink(entry, directory, path23, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -185581,7 +185581,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path22);
+        linkPath = await fsrealpath(path23);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -185591,12 +185591,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, path22, entry.stats);
+          this.fsw._emit(EV.CHANGE, path23, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path22, entry.stats);
+        this.fsw._emit(EV.ADD, path23, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -185626,9 +185626,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path22 = sp.join(directory, item);
+      let path23 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -185637,8 +185637,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path22 = sp.join(dir, sp.relative(dir, path22));
-        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
+        path23 = sp.join(dir, sp.relative(dir, path23));
+        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve7, reject) => {
@@ -185707,13 +185707,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path22);
+    const wh = this.fsw._getWatchHelpers(path23);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -185729,8 +185729,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path22);
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const absPath = sp.resolve(path23);
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -185740,29 +185740,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         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, path22, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path23), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path22, closer);
+        this.fsw._addPathCloser(path23, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path22;
+        return path23;
       }
     }
   }
@@ -185805,24 +185805,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path22) {
-  if (typeof path22 !== "string")
+function normalizePath(path23) {
+  if (typeof path23 !== "string")
     throw new Error("string expected");
-  path22 = sp2.normalize(path22);
-  path22 = path22.replace(/\\/g, "/");
+  path23 = sp2.normalize(path23);
+  path23 = path23.replace(/\\/g, "/");
   let prepend = false;
-  if (path22.startsWith("//"))
+  if (path23.startsWith("//"))
     prepend = true;
-  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
+  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path22 = "/" + path22;
-  return path22;
+    path23 = "/" + path23;
+  return path23;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path22 = normalizePath(testString);
+  const path23 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path22, stats)) {
+    if (pattern(path23, stats)) {
       return true;
     }
   }
@@ -185860,19 +185860,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-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));
+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));
   } else {
-    return path22;
+    return path23;
   }
 };
-var getAbsolutePath = (path22, cwd) => {
-  if (sp2.isAbsolute(path22)) {
-    return path22;
+var getAbsolutePath = (path23, cwd) => {
+  if (sp2.isAbsolute(path23)) {
+    return path23;
   }
-  return sp2.join(cwd, path22);
+  return sp2.join(cwd, path23);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -185937,10 +185937,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path22, follow, fsw) {
+  constructor(path23, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path22;
-    this.path = path22 = path22.replace(REPLACER_RE, "");
+    const watchPath = path23;
+    this.path = path23 = path23.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -186080,20 +186080,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path22) => {
-        const absPath = getAbsolutePath(path22, cwd);
+      paths = paths.map((path23) => {
+        const absPath = getAbsolutePath(path23, cwd);
         return absPath;
       });
     }
-    paths.forEach((path22) => {
-      this._removeIgnoredPath(path22);
+    paths.forEach((path23) => {
+      this._removeIgnoredPath(path23);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path22) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path23) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -186115,17 +186115,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path22) => {
-      if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
+    paths.forEach((path23) => {
+      if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
         if (cwd)
-          path22 = sp2.join(cwd, path22);
-        path22 = sp2.resolve(path22);
+          path23 = sp2.join(cwd, path23);
+        path23 = sp2.resolve(path23);
       }
-      this._closePath(path22);
-      this._addIgnoredPath(path22);
-      if (this._watched.has(path22)) {
+      this._closePath(path23);
+      this._addIgnoredPath(path23);
+      if (this._watched.has(path23)) {
         this._addIgnoredPath({
-          path: path22,
+          path: path23,
           recursive: true
         });
       }
@@ -186189,38 +186189,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, path22, stats) {
+  async _emit(event, path23, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path22 = sp2.normalize(path22);
+      path23 = sp2.normalize(path23);
     if (opts.cwd)
-      path22 = sp2.relative(opts.cwd, path22);
-    const args = [path22];
+      path23 = sp2.relative(opts.cwd, path23);
+    const args = [path23];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path22))) {
+    if (awf && (pw = this._pendingWrites.get(path23))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path22, [event, ...args]);
+        this._pendingUnlinks.set(path23, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path23) => {
+          this._pendingUnlinks.forEach((entry, path24) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path23);
+            this._pendingUnlinks.delete(path24);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path22);
+        this._pendingUnlinks.delete(path23);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -186238,16 +186238,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 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, path22) : path22;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path23) : path23;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -186278,23 +186278,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, path22, timeout) {
+  _throttle(actionType, path23, 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(path22);
+    const actionPath = action.get(path23);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path22);
+      const item = action.get(path23);
       const count = item ? item.count : 0;
-      action.delete(path22);
+      action.delete(path23);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -186302,7 +186302,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path22, thr);
+    action.set(path23, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -186316,44 +186316,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path22, threshold, event, awfEmit) {
+  _awaitWriteFinish(path23, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path22;
-    if (this.options.cwd && !sp2.isAbsolute(path22)) {
-      fullPath = sp2.join(this.options.cwd, path22);
+    let fullPath = path23;
+    if (this.options.cwd && !sp2.isAbsolute(path23)) {
+      fullPath = sp2.join(this.options.cwd, path23);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path22)) {
+        if (err || !writes.has(path23)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path22).lastChange = now2;
+          writes.get(path23).lastChange = now2;
         }
-        const pw = writes.get(path22);
+        const pw = writes.get(path23);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path22);
+          writes.delete(path23);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path22)) {
-      writes.set(path22, {
+    if (!writes.has(path23)) {
+      writes.set(path23, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path22);
+          writes.delete(path23);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -186364,8 +186364,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path22, stats) {
-    if (this.options.atomic && DOT_RE.test(path22))
+  _isIgnored(path23, stats) {
+    if (this.options.atomic && DOT_RE.test(path23))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -186375,17 +186375,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path22, stats);
+    return this._userIgnored(path23, stats);
   }
-  _isntIgnored(path22, stat4) {
-    return !this._isIgnored(path22, stat4);
+  _isntIgnored(path23, stat4) {
+    return !this._isIgnored(path23, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path22) {
-    return new WatchHelper(path22, this.options.followSymlinks, this);
+  _getWatchHelpers(path23) {
+    return new WatchHelper(path23, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -186417,63 +186417,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    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))
+    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))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path22);
+    const wp = this._getWatchedDir(path23);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path23, 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 = path22;
+    let relPath = path23;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path22);
+      relPath = sp2.relative(this.options.cwd, path23);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path22);
+    this._watched.delete(path23);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path22))
-      this._emit(eventName, path22);
-    this._closePath(path22);
+    if (wasTracked && !this._isIgnored(path23))
+      this._emit(eventName, path23);
+    this._closePath(path23);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path22) {
-    this._closeFile(path22);
-    const dir = sp2.dirname(path22);
-    this._getWatchedDir(dir).remove(sp2.basename(path22));
+  _closePath(path23) {
+    this._closeFile(path23);
+    const dir = sp2.dirname(path23);
+    this._getWatchedDir(dir).remove(sp2.basename(path23));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path22) {
-    const closers = this._closers.get(path22);
+  _closeFile(path23) {
+    const closers = this._closers.get(path23);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path22);
+    this._closers.delete(path23);
   }
-  _addPathCloser(path22, closer) {
+  _addPathCloser(path23, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path22);
+    let list = this._closers.get(path23);
     if (!list) {
       list = [];
-      this._closers.set(path22, list);
+      this._closers.set(path23, list);
     }
     list.push(closer);
   }
@@ -188620,9 +188620,106 @@ function watchConfigFile(configPath, debounceMs, onChange) {
   };
 }
 
-// src/lib/dev/proxy-registry.ts
+// src/lib/dev/subdomain-generator.ts
 import * as fs18 from "fs";
 import * as path15 from "path";
+import { generateSlug } from "random-word-slugs";
+var StableSubdomainAllocator = class {
+  tunnelsDir;
+  tunnelsFilePath;
+  baseSlug = null;
+  constructor(projectRoot, key = "default") {
+    this.tunnelsDir = path15.join(projectRoot, ".specific", "keys", key);
+    this.tunnelsFilePath = path15.join(this.tunnelsDir, "tunnels.json");
+    this.loadTunnels();
+  }
+  loadTunnels() {
+    if (!fs18.existsSync(this.tunnelsFilePath)) {
+      return;
+    }
+    try {
+      const content = fs18.readFileSync(this.tunnelsFilePath, "utf-8");
+      const data = JSON.parse(content);
+      if (data.version === 1 && data.baseSlug) {
+        this.baseSlug = data.baseSlug;
+      }
+    } catch {
+      this.baseSlug = null;
+    }
+  }
+  saveTunnels() {
+    if (!fs18.existsSync(this.tunnelsDir)) {
+      fs18.mkdirSync(this.tunnelsDir, { recursive: true });
+    }
+    const data = {
+      version: 1,
+      baseSlug: this.baseSlug
+    };
+    fs18.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
+  }
+  generateBaseSlug() {
+    return generateSlug(2, {
+      format: "kebab",
+      partsOfSpeech: ["adjective", "noun"],
+      categories: {
+        adjective: ["color", "appearance"],
+        noun: ["animals"]
+      }
+    });
+  }
+  /**
+   * Get the base slug, generating one if needed.
+   */
+  getBaseSlug() {
+    if (!this.baseSlug) {
+      this.baseSlug = this.generateBaseSlug();
+      this.saveTunnels();
+    }
+    return this.baseSlug;
+  }
+  /**
+   * Allocate a subdomain for a service.
+   * If multipleServices is true, appends the service name to the base slug.
+   */
+  allocate(serviceName, multipleServices) {
+    const baseSlug = this.getBaseSlug();
+    if (multipleServices) {
+      return `${baseSlug}-${serviceName}`;
+    }
+    return baseSlug;
+  }
+};
+
+// src/lib/dev/tunnel-manager.ts
+import localtunnel from "localtunnel";
+var TUNNEL_HOST = "https://tunnel.spcf.app";
+async function startTunnel(serviceName, endpointName, port, subdomain, callbacks) {
+  const tunnel = await localtunnel({
+    port,
+    subdomain,
+    host: TUNNEL_HOST
+  });
+  tunnel.on("error", (err) => {
+    callbacks?.onError?.(serviceName, endpointName, err);
+  });
+  tunnel.on("close", () => {
+    callbacks?.onClose?.(serviceName, endpointName);
+  });
+  return {
+    serviceName,
+    endpointName,
+    localPort: port,
+    url: tunnel.url,
+    subdomain,
+    stop: async () => {
+      tunnel.close();
+    }
+  };
+}
+
+// src/lib/dev/proxy-registry.ts
+import * as fs19 from "fs";
+import * as path16 from "path";
 import * as os8 from "os";
 import * as net4 from "net";
 var ProxyRegistryManager = class {
@@ -188633,14 +188730,14 @@ var ProxyRegistryManager = class {
   isOwner = false;
   registryWatcher = null;
   constructor() {
-    this.proxyDir = path15.join(os8.homedir(), ".specific", "proxy");
-    this.ownerPath = path15.join(this.proxyDir, "owner.json");
-    this.registryPath = path15.join(this.proxyDir, "registry.json");
-    this.lockPath = path15.join(this.proxyDir, "registry.lock");
+    this.proxyDir = path16.join(os8.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");
   }
   ensureProxyDir() {
-    if (!fs18.existsSync(this.proxyDir)) {
-      fs18.mkdirSync(this.proxyDir, { recursive: true });
+    if (!fs19.existsSync(this.proxyDir)) {
+      fs19.mkdirSync(this.proxyDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -188697,15 +188794,15 @@ var ProxyRegistryManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs18.openSync(
+        const fd = fs19.openSync(
           this.lockPath,
-          fs18.constants.O_CREAT | fs18.constants.O_EXCL | fs18.constants.O_WRONLY
+          fs19.constants.O_CREAT | fs19.constants.O_EXCL | fs19.constants.O_WRONLY
         );
-        fs18.writeSync(fd, String(process.pid));
-        fs18.closeSync(fd);
+        fs19.writeSync(fd, String(process.pid));
+        fs19.closeSync(fd);
         return () => {
           try {
-            fs18.unlinkSync(this.lockPath);
+            fs19.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -188714,16 +188811,16 @@ var ProxyRegistryManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs18.readFileSync(this.lockPath, "utf-8").trim(),
+              fs19.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs18.unlinkSync(this.lockPath);
+              fs19.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs18.unlinkSync(this.lockPath);
+              fs19.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
@@ -188743,8 +188840,8 @@ var ProxyRegistryManager = class {
   async claimProxyOwnership(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs18.existsSync(this.ownerPath)) {
-        const content = fs18.readFileSync(this.ownerPath, "utf-8");
+      if (fs19.existsSync(this.ownerPath)) {
+        const content = fs19.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (await this.isProxyOwnerHealthy(ownerFile2.owner.pid)) {
           return false;
@@ -188774,11 +188871,11 @@ var ProxyRegistryManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs18.existsSync(this.ownerPath)) {
-        const content = fs18.readFileSync(this.ownerPath, "utf-8");
+      if (fs19.existsSync(this.ownerPath)) {
+        const content = fs19.readFileSync(this.ownerPath, "utf-8");
         const ownerFile = JSON.parse(content);
         if (ownerFile.owner.pid === process.pid) {
-          fs18.unlinkSync(this.ownerPath);
+          fs19.unlinkSync(this.ownerPath);
         }
       }
       this.isOwner = false;
@@ -188790,12 +188887,12 @@ var ProxyRegistryManager = class {
    * Get the current proxy owner.
    */
   async getProxyOwner() {
-    if (!fs18.existsSync(this.ownerPath)) {
+    if (!fs19.existsSync(this.ownerPath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs18.readFileSync(this.ownerPath, "utf-8");
+      const content = fs19.readFileSync(this.ownerPath, "utf-8");
       const ownerFile = JSON.parse(content);
       if (!await this.isProxyOwnerHealthy(ownerFile.owner.pid)) {
         return null;
@@ -188889,7 +188986,7 @@ var ProxyRegistryManager = class {
    */
   watchRegistry(onChange) {
     this.ensureProxyDir();
-    if (!fs18.existsSync(this.registryPath)) {
+    if (!fs19.existsSync(this.registryPath)) {
       const emptyRegistry = {
         version: 1,
         keys: {},
@@ -188933,13 +189030,13 @@ var ProxyRegistryManager = class {
   async attemptElection(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs18.existsSync(this.ownerPath)) {
-        const content = fs18.readFileSync(this.ownerPath, "utf-8");
+      if (fs19.existsSync(this.ownerPath)) {
+        const content = fs19.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (await this.isProxyOwnerHealthy(ownerFile2.owner.pid)) {
           return false;
         }
-        fs18.unlinkSync(this.ownerPath);
+        fs19.unlinkSync(this.ownerPath);
       }
       const ownerFile = {
         version: 1,
@@ -188957,7 +189054,7 @@ var ProxyRegistryManager = class {
     }
   }
   readRegistry() {
-    if (!fs18.existsSync(this.registryPath)) {
+    if (!fs19.existsSync(this.registryPath)) {
       return {
         version: 1,
         keys: {},
@@ -188965,7 +189062,7 @@ var ProxyRegistryManager = class {
       };
     }
     try {
-      const content = fs18.readFileSync(this.registryPath, "utf-8");
+      const content = fs19.readFileSync(this.registryPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return {
@@ -188978,8 +189075,8 @@ var ProxyRegistryManager = class {
   writeFileAtomic(filePath, data) {
     this.ensureProxyDir();
     const tmpPath = filePath + ".tmp";
-    fs18.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    fs18.renameSync(tmpPath, filePath);
+    fs19.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs19.renameSync(tmpPath, filePath);
   }
 };
 
@@ -189085,10 +189182,10 @@ function isInteractive() {
 
 // src/commands/dev.tsx
 var COLORS = ["cyan", "yellow", "green", "magenta", "blue"];
-function DevUI({ instanceKey }) {
+function DevUI({ instanceKey, tunnelEnabled }) {
   const { exit } = useApp2();
   const [state, setState] = useState5(() => {
-    const caExists = caFilesExist();
+    const caExists = tunnelEnabled || caFilesExist();
     return {
       status: caExists ? "loading" : "installing-ca",
       ...caExists ? {} : { caInstallPhase: "installing" },
@@ -189097,7 +189194,9 @@ function DevUI({ instanceKey }) {
       services: [],
       output: [],
       colorMap: /* @__PURE__ */ new Map(),
-      isProxyOwner: false
+      isProxyOwner: false,
+      tunnels: /* @__PURE__ */ new Map(),
+      tunnelStatus: /* @__PURE__ */ new Map()
     };
   });
   useEffect3(() => {
@@ -189129,6 +189228,7 @@ function DevUI({ instanceKey }) {
   const drizzleGatewayRef = useRef(null);
   const registryWatcherCleanupRef = useRef(null);
   const electionIntervalRef = useRef(null);
+  const tunnelsRef = useRef([]);
   const proxyRef = useRef(null);
   const adminServerRef = useRef(null);
   const servicesRef = useRef([]);
@@ -189162,7 +189262,9 @@ function DevUI({ instanceKey }) {
       // Stop Drizzle Gateway
       drizzleGatewayRef.current?.stop(),
       // Stop all resources
-      ...[...resourcesRef.current.values()].map((resource) => resource.stop())
+      ...[...resourcesRef.current.values()].map((resource) => resource.stop()),
+      // Stop all tunnels
+      ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
     if (proxyRegistryRef.current) {
       await proxyRegistryRef.current.unregisterServices(instanceKey);
@@ -189199,7 +189301,9 @@ function DevUI({ instanceKey }) {
       // Stop Drizzle Gateway
       drizzleGatewayRef.current?.stop(),
       // Stop all resources
-      ...[...resourcesRef.current.values()].map((resource) => resource.stop())
+      ...[...resourcesRef.current.values()].map((resource) => resource.stop()),
+      // Stop all tunnels
+      ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
     electricInstancesRef.current = [];
     drizzleGatewayRef.current = null;
@@ -189207,6 +189311,7 @@ function DevUI({ instanceKey }) {
     adminServerRef.current = null;
     servicesRef.current = [];
     resourcesRef.current = /* @__PURE__ */ new Map();
+    tunnelsRef.current = [];
     if (proxyRegistryRef.current) {
       await proxyRegistryRef.current.unregisterServices(instanceKey);
       await proxyRegistryRef.current.releaseProxyOwnership();
@@ -189222,7 +189327,9 @@ function DevUI({ instanceKey }) {
       resourceStatus: /* @__PURE__ */ new Map(),
       services: [],
       proxy: void 0,
-      isProxyOwner: false
+      isProxyOwner: false,
+      tunnels: /* @__PURE__ */ new Map(),
+      tunnelStatus: /* @__PURE__ */ new Map()
     }));
     setReloadTrigger((t) => t + 1);
   };
@@ -189263,10 +189370,10 @@ function DevUI({ instanceKey }) {
   }, [state.status]);
   useEffect3(() => {
     if (state.status !== "running") return;
-    const configPath = path16.join(process.cwd(), "specific.hcl");
+    const configPath = path17.join(process.cwd(), "specific.hcl");
     const watcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs19.readFileSync(configPath, "utf-8");
+        const hcl = fs20.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           triggerReload();
         }).catch((err) => {
@@ -189391,8 +189498,8 @@ function DevUI({ instanceKey }) {
         }));
         return;
       }
-      const configPath = path16.join(process.cwd(), "specific.hcl");
-      if (!fs19.existsSync(configPath)) {
+      const configPath = path17.join(process.cwd(), "specific.hcl");
+      if (!fs20.existsSync(configPath)) {
         writeLog("system", "Waiting for specific.hcl to appear");
         setState((s) => ({
           ...s,
@@ -189411,7 +189518,7 @@ function DevUI({ instanceKey }) {
       }
       let config2;
       try {
-        const hcl = fs19.readFileSync(configPath, "utf-8");
+        const hcl = fs20.readFileSync(configPath, "utf-8");
         config2 = await parseConfig(hcl);
       } catch (err) {
         setState((s) => ({
@@ -189517,7 +189624,7 @@ function DevUI({ instanceKey }) {
           const drizzleGateway = await startDrizzleGateway(
             postgresResources,
             drizzlePort,
-            path16.join(process.cwd(), ".specific", "keys", instanceKey)
+            path17.join(process.cwd(), ".specific", "keys", instanceKey)
           );
           startedDrizzleGateway = drizzleGateway;
           drizzleGatewayRef.current = drizzleGateway;
@@ -189686,136 +189793,196 @@ Add them to the config block in specific.local`);
           }
         }
       }
-      const runningServicePorts = /* @__PURE__ */ new Map();
-      for (const s of services2) {
-        runningServicePorts.set(s.name, s.ports.get("default"));
-      }
-      const projectId = hasProjectId() ? readProjectId() : void 0;
-      const getState = () => ({
-        status: "running",
-        services: config2.services.filter((svc) => runningServicePorts.has(svc.name) || svc.serve).map((svc) => ({
-          name: svc.name,
-          port: runningServicePorts.get(svc.name),
-          exposed: !!svc.serve || svc.endpoints.some((e) => e.public),
-          env: svc.env
-        })),
-        resources: [...resources2.entries()].map(([name, r]) => ({
-          name,
-          type: r.type,
-          port: r.port,
-          host: r.host,
-          syncEnabled: r.type === "postgres" && syncDatabases.has(name)
-        })),
-        projectId
-      });
-      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);
+      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();
+          for (const svc of exposedServices) {
+            tunnelStatusMap.set(svc.name, "connecting");
+          }
+          setState((s) => ({ ...s, tunnelStatus: new Map(tunnelStatusMap) }));
+          for (const svc of exposedServices) {
+            if (cancelled) return;
+            const subdomain = subdomainAllocator.allocate(svc.name, multipleServices);
+            writeLog("system", `Starting tunnel for ${svc.name} on port ${svc.port} (subdomain: ${subdomain})`);
+            try {
+              const tunnel = await startTunnel(
+                svc.name,
+                "default",
+                svc.port,
+                subdomain,
+                {
+                  onError: (serviceName, _endpointName, error) => {
+                    writeLog("system:error", `Tunnel error for ${serviceName}: ${error.message}`);
+                  },
+                  onClose: (serviceName) => {
+                    writeLog("system", `Tunnel closed for ${serviceName}`);
+                  }
+                }
+              );
+              tunnelInstances.push(tunnel);
+              tunnelsRef.current = [...tunnelInstances];
+              tunnelStatusMap.set(svc.name, "connected");
+              setState((s) => ({
+                ...s,
+                tunnels: new Map([...s.tunnels, [svc.name, tunnel]]),
+                tunnelStatus: new Map(tunnelStatusMap)
+              }));
+              writeLog("system", `Tunnel ready for ${svc.name}: ${tunnel.url}`);
+            } catch (err) {
+              const errorMsg = `Failed to start tunnel for ${svc.name}: ${err instanceof Error ? err.message : String(err)}`;
+              writeLog("system:error", errorMsg);
+              tunnelStatusMap.set(svc.name, "error");
+              for (const t of tunnelInstances) {
+                await t.stop();
               }
-              const allKeys = [...knownKeys];
-              const newCertificate = generateCertificate("local.spcf.app", allKeys);
-              proxy2.updateCertificate(newCertificate);
+              setState((s) => ({
+                ...s,
+                status: "error",
+                error: errorMsg,
+                tunnelStatus: new Map(tunnelStatusMap)
+              }));
+              return;
             }
-          });
-          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) => {
+        const runningServicePorts = /* @__PURE__ */ new Map();
+        for (const s of services2) {
+          runningServicePorts.set(s.name, s.ports.get("default"));
+        }
+        const projectId = hasProjectId() ? readProjectId() : void 0;
+        const getState = () => ({
+          status: "running",
+          services: config2.services.filter((svc) => runningServicePorts.has(svc.name) || svc.serve).map((svc) => ({
+            name: svc.name,
+            port: runningServicePorts.get(svc.name),
+            exposed: !!svc.serve || svc.endpoints.some((e) => e.public),
+            env: svc.env
+          })),
+          resources: [...resources2.entries()].map(([name, r]) => ({
+            name,
+            type: r.type,
+            port: r.port,
+            host: r.host,
+            syncEnabled: r.type === "postgres" && syncDatabases.has(name)
+          })),
+          projectId
+        });
+        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 {
-            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;
-            }
+            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;
           }
-          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");
+        } 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;
               }
-              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}`);
+              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);
+          }, 1e3);
+        }
       }
       if (cancelled) return;
       writeLog("system", "Dev server running");
@@ -189961,39 +190128,58 @@ Add them to the config block in specific.local`);
   const staticItems = [
     {
       key: "title",
-      content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "Specific dev server"), instanceKey !== "default" && /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, " [", instanceKey, "]"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (Ctrl+C to stop)"))
+      content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "Specific dev server"), tunnelEnabled && /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, " [tunnel]"), instanceKey !== "default" && /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, " [", instanceKey, "]"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (Ctrl+C to stop)"))
     },
     { key: "space1", content: /* @__PURE__ */ React6.createElement(Text6, null, " ") },
-    // Show admin UI URL
-    {
-      key: "admin",
-      content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Admin:"), /* @__PURE__ */ React6.createElement(Text6, null, " "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "https://", instanceKey === "default" ? "" : `${instanceKey}.`, "local.spcf.app"))
-    },
-    { key: "admin-space", content: /* @__PURE__ */ React6.createElement(Text6, null, " ") },
-    ...services.length > 0 ? [
-      { key: "svc-header", content: /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Services:") },
-      ...services.flatMap((svc) => {
-        const serviceConfig = config.services.find((s) => s.name === svc.name);
-        const endpoints = serviceConfig?.endpoints || [];
-        if (endpoints.length === 0 && svc.ports.size > 0) {
-          const defaultPort = svc.ports.get("default");
-          return [{
-            key: `svc-${svc.name}`,
-            content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, " \u25CF "), /* @__PURE__ */ React6.createElement(Text6, null, svc.name), defaultPort && /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (localhost:", defaultPort, ")"))
-          }];
-        }
-        return endpoints.map((endpoint) => {
-          const port = svc.ports.get(endpoint.name);
-          const displayName = endpoint.name === "default" ? svc.name : `${svc.name}:${endpoint.name}`;
-          const proxyName = endpoint.name === "default" ? svc.name : `${svc.name}-${endpoint.name}`;
+    // Show admin UI URL (only in non-tunnel mode)
+    ...!tunnelEnabled ? [
+      {
+        key: "admin",
+        content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Admin:"), /* @__PURE__ */ React6.createElement(Text6, null, " "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "https://", instanceKey === "default" ? "" : `${instanceKey}.`, "local.spcf.app"))
+      },
+      { key: "admin-space", content: /* @__PURE__ */ React6.createElement(Text6, null, " ") }
+    ] : [],
+    // Services section - different rendering for tunnel mode vs local mode
+    ...tunnelEnabled ? (
+      // Tunnel mode: show tunnel URLs for public services
+      state.tunnels.size > 0 || state.tunnelStatus.size > 0 ? [
+        { key: "svc-header", content: /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Services:") },
+        ...[...state.tunnelStatus.entries()].map(([serviceName, status]) => {
+          const tunnel = state.tunnels.get(serviceName);
           return {
-            key: `svc-${svc.name}-${endpoint.name}`,
-            content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, " \u25CF "), /* @__PURE__ */ React6.createElement(Text6, null, displayName), port ? endpoint.public ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, null, " \u2192 "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "https://", proxyName, instanceKey === "default" ? "" : `.${instanceKey}`, ".local.spcf.app"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (localhost:", port, ")")) : /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (localhost:", port, ")") : null)
+            key: `svc-${serviceName}`,
+            content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: status === "connected" ? "green" : status === "error" ? "red" : "yellow" }, " \u25CF "), /* @__PURE__ */ React6.createElement(Text6, null, serviceName), status === "connected" && tunnel ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, null, " \u2192 "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, tunnel.url)) : status === "connecting" ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " connecting...") : /* @__PURE__ */ React6.createElement(Text6, { color: "red" }, " error"))
           };
-        });
-      }),
-      { key: "space2", content: /* @__PURE__ */ React6.createElement(Text6, null, " ") }
-    ] : [],
+        }),
+        { key: "space2", content: /* @__PURE__ */ React6.createElement(Text6, null, " ") }
+      ] : []
+    ) : (
+      // Local mode: show local URLs
+      services.length > 0 ? [
+        { key: "svc-header", content: /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Services:") },
+        ...services.flatMap((svc) => {
+          const serviceConfig = config.services.find((s) => s.name === svc.name);
+          const endpoints = serviceConfig?.endpoints || [];
+          if (endpoints.length === 0 && svc.ports.size > 0) {
+            const defaultPort = svc.ports.get("default");
+            return [{
+              key: `svc-${svc.name}`,
+              content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, " \u25CF "), /* @__PURE__ */ React6.createElement(Text6, null, svc.name), defaultPort && /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (localhost:", defaultPort, ")"))
+            }];
+          }
+          return endpoints.map((endpoint) => {
+            const port = svc.ports.get(endpoint.name);
+            const displayName = endpoint.name === "default" ? svc.name : `${svc.name}:${endpoint.name}`;
+            const proxyName = endpoint.name === "default" ? svc.name : `${svc.name}-${endpoint.name}`;
+            return {
+              key: `svc-${svc.name}-${endpoint.name}`,
+              content: /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, " \u25CF "), /* @__PURE__ */ React6.createElement(Text6, null, displayName), port ? endpoint.public ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, null, " \u2192 "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "https://", proxyName, instanceKey === "default" ? "" : `.${instanceKey}`, ".local.spcf.app"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (localhost:", port, ")")) : /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (localhost:", port, ")") : null)
+            };
+          });
+        }),
+        { key: "space2", content: /* @__PURE__ */ React6.createElement(Text6, null, " ") }
+      ] : []
+    ),
     ...config.postgres.length > 0 ? [
       { key: "pg-header", content: /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Postgres:") },
       ...config.postgres.map((pg) => {
@@ -190041,13 +190227,13 @@ Add them to the config block in specific.local`);
   ];
   return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Static, { items: staticItems }, (item) => /* @__PURE__ */ React6.createElement(Box6, { key: item.key }, item.content)));
 }
-function devCommand(instanceKey) {
-  render4(/* @__PURE__ */ React6.createElement(DevUI, { instanceKey }));
+function devCommand(instanceKey, tunnelEnabled = false) {
+  render4(/* @__PURE__ */ React6.createElement(DevUI, { instanceKey, tunnelEnabled }));
 }
 
 // src/lib/dev/git-worktree.ts
 import { execSync as execSync2 } from "child_process";
-import * as path17 from "path";
+import * as path18 from "path";
 function isInWorktree() {
   try {
     const commonDir = execSync2("git rev-parse --git-common-dir", {
@@ -190058,8 +190244,8 @@ function isInWorktree() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const resolvedCommonDir = path17.resolve(commonDir);
-    const resolvedGitDir = path17.resolve(gitDir);
+    const resolvedCommonDir = path18.resolve(commonDir);
+    const resolvedGitDir = path18.resolve(gitDir);
     return resolvedCommonDir !== resolvedGitDir;
   } catch {
     return false;
@@ -190074,7 +190260,7 @@ function getWorktreeName() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return path17.basename(gitDir);
+    return path18.basename(gitDir);
   } catch {
     return null;
   }
@@ -190089,35 +190275,35 @@ init_open();
 import React7, { useState as useState6, useEffect as useEffect4, useCallback } from "react";
 import { render as render5, Text as Text7, Box as Box7, useApp as useApp3, useInput as useInput5 } from "ink";
 import Spinner5 from "ink-spinner";
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 
 // src/lib/deploy/build-tester.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync17 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { join as join19 } from "path";
 function getDependencyInstallCommand(build, projectDir) {
   switch (build.base) {
     case "node":
-      if (existsSync17(join18(projectDir, "pnpm-lock.yaml"))) {
+      if (existsSync18(join19(projectDir, "pnpm-lock.yaml"))) {
         return "pnpm install --frozen-lockfile";
-      } else if (existsSync17(join18(projectDir, "yarn.lock"))) {
+      } else if (existsSync18(join19(projectDir, "yarn.lock"))) {
         return "yarn install --frozen-lockfile";
-      } else if (existsSync17(join18(projectDir, "package-lock.json"))) {
+      } else if (existsSync18(join19(projectDir, "package-lock.json"))) {
         return "npm ci";
       } else {
         return "npm install";
       }
     case "python":
-      if (existsSync17(join18(projectDir, "poetry.lock"))) {
+      if (existsSync18(join19(projectDir, "poetry.lock"))) {
         return "poetry install --no-interaction";
-      } else if (existsSync17(join18(projectDir, "Pipfile.lock"))) {
+      } else if (existsSync18(join19(projectDir, "Pipfile.lock"))) {
         return "pipenv install --deploy";
-      } else if (existsSync17(join18(projectDir, "Pipfile"))) {
+      } else if (existsSync18(join19(projectDir, "Pipfile"))) {
         return "pipenv install";
-      } else if (existsSync17(join18(projectDir, "pyproject.toml"))) {
+      } else if (existsSync18(join19(projectDir, "pyproject.toml"))) {
         return "pip install .";
-      } else if (existsSync17(join18(projectDir, "requirements.txt"))) {
+      } else if (existsSync18(join19(projectDir, "requirements.txt"))) {
         return "pip install -r requirements.txt";
       }
       return null;
@@ -190263,8 +190449,8 @@ async function testAllBuilds(builds, projectDir) {
 
 // src/lib/tarball/create.ts
 import { execSync as execSync3 } from "child_process";
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
 function isInsideGitRepository(dir) {
   try {
@@ -190321,10 +190507,10 @@ var EXCLUDED_DIRS = [
 ];
 async function collectPaths(baseDir, currentDir, exclude) {
   const results = [];
-  const entries = await fs20.promises.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs21.promises.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path18.join(currentDir, entry.name);
-    const relativePath = path18.relative(baseDir, fullPath);
+    const fullPath = path19.join(currentDir, entry.name);
+    const relativePath = path19.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (!exclude.includes(entry.name)) {
         results.push(relativePath);
@@ -190339,8 +190525,8 @@ async function collectPaths(baseDir, currentDir, exclude) {
 }
 async function createTarArchive(projectDir) {
   writeLog("tarball", "Creating tarball using tar-vern (non-git project)");
-  const configPath = path18.join(projectDir, "specific.hcl");
-  if (!fs20.existsSync(configPath)) {
+  const configPath = path19.join(projectDir, "specific.hcl");
+  if (!fs21.existsSync(configPath)) {
     throw new Error("specific.hcl not found in project directory");
   }
   const relativePaths = await collectPaths(projectDir, projectDir, EXCLUDED_DIRS);
@@ -190357,8 +190543,8 @@ async function createTarArchive(projectDir) {
 }
 function findWidestContext(projectDir, contexts) {
   if (contexts.length === 0) return ".";
-  const absolute = contexts.map((c) => path18.resolve(projectDir, c));
-  const segments = absolute.map((p) => p.split(path18.sep).filter(Boolean));
+  const absolute = contexts.map((c) => path19.resolve(projectDir, c));
+  const segments = absolute.map((p) => p.split(path19.sep).filter(Boolean));
   const firstSegments = segments[0];
   if (!firstSegments) return ".";
   const minLen = Math.min(...segments.map((s) => s.length));
@@ -190372,12 +190558,12 @@ function findWidestContext(projectDir, contexts) {
     }
   }
   const ancestorSegments = firstSegments.slice(0, commonLength);
-  const ancestor = path18.sep + ancestorSegments.join(path18.sep);
-  return path18.relative(projectDir, ancestor) || ".";
+  const ancestor = path19.sep + ancestorSegments.join(path19.sep);
+  return path19.relative(projectDir, ancestor) || ".";
 }
 async function createProjectTarball(projectDir, context = ".") {
-  const contextDir = path18.resolve(projectDir, context);
-  const appPath = path18.relative(contextDir, projectDir) || ".";
+  const contextDir = path19.resolve(projectDir, context);
+  const appPath = path19.relative(contextDir, projectDir) || ".";
   writeLog("tarball", `Context: ${contextDir}, appPath: ${appPath}`);
   let tarball;
   if (isInsideGitRepository(contextDir)) {
@@ -191264,14 +191450,14 @@ ${errorMsg}`
   ), phase === "error" && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "red" }, "Error: ", error)), phase === "success" && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { color: "green" }, "Deployment successful!"), deployment?.publicUrls && Object.keys(deployment.publicUrls).length > 0 && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { bold: true }, "Public URLs:"), Object.entries(deployment.publicUrls).map(([name, url]) => /* @__PURE__ */ React7.createElement(Text7, { key: name }, "  ", name, ": ", /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, url))))));
 }
 async function deployCommand(environment, options2) {
-  const configPath = path19.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(
@@ -191295,8 +191481,8 @@ async function deployCommand(environment, options2) {
 
 // src/commands/exec.tsx
 import { spawn as spawn6 } from "child_process";
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 async function execCommand(serviceName, command, instanceKey = "default") {
   if (command.length === 0) {
     console.error(
@@ -191324,14 +191510,14 @@ async function execCommand(serviceName, command, instanceKey = "default") {
       }
     }
   };
-  const configPath = path20.join(process.cwd(), "specific.hcl");
-  if (!fs22.existsSync(configPath)) {
+  const configPath = path21.join(process.cwd(), "specific.hcl");
+  if (!fs23.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
   try {
-    const hcl = fs22.readFileSync(configPath, "utf-8");
+    const hcl = fs23.readFileSync(configPath, "utf-8");
     config = await parseConfig(hcl);
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
@@ -191525,21 +191711,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 fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 function CleanUI({ instanceKey }) {
   const [state, setState] = useState7({ status: "checking" });
   useEffect5(() => {
     async function clean() {
       const projectRoot = process.cwd();
-      const specificDir = path21.join(projectRoot, ".specific");
-      if (!fs23.existsSync(specificDir)) {
+      const specificDir = path22.join(projectRoot, ".specific");
+      if (!fs24.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
-        const keyDir = path21.join(specificDir, "keys", instanceKey);
-        if (!fs23.existsSync(keyDir)) {
+        const keyDir = path22.join(specificDir, "keys", instanceKey);
+        if (!fs24.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -191555,7 +191741,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs23.rmSync(keyDir, { recursive: true, force: true });
+          fs24.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191564,10 +191750,10 @@ function CleanUI({ instanceKey }) {
           });
         }
       } 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()
+        const keysDir = path22.join(specificDir, "keys");
+        if (fs24.existsSync(keysDir)) {
+          const keys = fs24.readdirSync(keysDir).filter(
+            (f) => fs24.statSync(path22.join(keysDir, f)).isDirectory()
           );
           for (const key of keys) {
             const stateManager2 = new InstanceStateManager(projectRoot, key);
@@ -191592,7 +191778,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs23.rmSync(specificDir, { recursive: true, force: true });
+          fs24.rmSync(specificDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191679,13 +191865,13 @@ 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.47").enablePositionalOptions();
+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.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)").action((options2) => {
+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) => {
   const key = options2.key ?? getDefaultKey();
-  devCommand(key);
+  devCommand(key, options2.tunnel ?? false);
 });
 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);