npm - @specific.dev/cli - Versions diffs - 0.1.102 → 0.1.103 - Mend

@specific.dev/cli 0.1.102 → 0.1.103

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/dist/cli.js CHANGED Viewed

@@ -520,10 +520,10 @@ ${frame}`;
 });
 // node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 function hasDockerEnv() {
   try {
-    fs13.statSync("/.dockerenv");
+    fs14.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -531,7 +531,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs13.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs14.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -549,7 +549,7 @@ var init_is_docker = __esm({
 });
 // node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 function isInsideContainer() {
   if (cachedResult === void 0) {
     cachedResult = hasContainerEnv() || isDocker();
@@ -562,7 +562,7 @@ var init_is_inside_container = __esm({
     init_is_docker();
     hasContainerEnv = () => {
       try {
-        fs14.statSync("/run/.containerenv");
+        fs15.statSync("/run/.containerenv");
         return true;
       } catch {
         return false;
@@ -574,7 +574,7 @@ var init_is_inside_container = __esm({
 // node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
 import process2 from "node:process";
 import os3 from "node:os";
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 var isWsl, is_wsl_default;
 var init_is_wsl = __esm({
   "node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js"() {
@@ -590,7 +590,7 @@ var init_is_wsl = __esm({
         return true;
       }
       try {
-        return fs15.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+        return fs16.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
       } catch {
         return false;
       }
@@ -660,7 +660,7 @@ var init_utilities = __esm({
 // node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js
 import { promisify as promisify2 } from "node:util";
 import childProcess2 from "node:child_process";
-import fs16, { constants as fsConstants } from "node:fs/promises";
+import fs17, { constants as fsConstants } from "node:fs/promises";
 var execFile2, wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell, wslDefaultBrowser, convertWslPathToWindows;
 var init_wsl_utils = __esm({
   "node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js"() {
@@ -679,14 +679,14 @@ var init_wsl_utils = __esm({
         const configFilePath = "/etc/wsl.conf";
         let isConfigFileExists = false;
         try {
-          await fs16.access(configFilePath, fsConstants.F_OK);
+          await fs17.access(configFilePath, fsConstants.F_OK);
           isConfigFileExists = true;
         } catch {
         }
         if (!isConfigFileExists) {
           return defaultMountPoint;
         }
-        const configContent = await fs16.readFile(configFilePath, { encoding: "utf8" });
+        const configContent = await fs17.readFile(configFilePath, { encoding: "utf8" });
         const parsedMountPoint = parseMountPointFromConfig(configContent);
         if (parsedMountPoint === void 0) {
           return defaultMountPoint;
@@ -705,7 +705,7 @@ var init_wsl_utils = __esm({
       canAccessPowerShellPromise ??= (async () => {
         try {
           const psPath = await powerShellPath2();
-          await fs16.access(psPath, fsConstants.X_OK);
+          await fs17.access(psPath, fsConstants.X_OK);
           return true;
         } catch {
           return false;
@@ -719,15 +719,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path26) => {
-      if (/^[a-z]+:\/\//i.test(path26)) {
-        return path26;
+    convertWslPathToWindows = async (path27) => {
+      if (/^[a-z]+:\/\//i.test(path27)) {
+        return path27;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path26], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path27], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path26;
+        return path27;
       }
     };
   }
@@ -913,10 +913,10 @@ __export(open_exports, {
   openApp: () => openApp
 });
 import process8 from "node:process";
-import path15 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import childProcess3 from "node:child_process";
-import fs17, { constants as fsConstants2 } from "node:fs/promises";
+import fs18, { constants as fsConstants2 } from "node:fs/promises";
 function detectArchBinary(binary) {
   if (typeof binary === "string" || Array.isArray(binary)) {
     return binary;
@@ -946,8 +946,8 @@ var init_open = __esm({
     init_is_inside_container();
     init_is_in_ssh();
     fallbackAttemptSymbol = Symbol("fallbackAttempt");
-    __dirname2 = import.meta.url ? path15.dirname(fileURLToPath2(import.meta.url)) : "";
-    localXdgOpenPath = path15.join(__dirname2, "xdg-open");
+    __dirname2 = import.meta.url ? path16.dirname(fileURLToPath2(import.meta.url)) : "";
+    localXdgOpenPath = path16.join(__dirname2, "xdg-open");
     ({ platform: platform2, arch: arch2 } = process8);
     tryEachApp = async (apps2, opener) => {
       if (apps2.length === 0) {
@@ -1095,7 +1095,7 @@ var init_open = __esm({
           const isBundled = !__dirname2 || __dirname2 === "/";
           let exeLocalXdgOpen = false;
           try {
-            await fs17.access(localXdgOpenPath, fsConstants2.X_OK);
+            await fs18.access(localXdgOpenPath, fsConstants2.X_OK);
             exeLocalXdgOpen = true;
           } catch {
           }
@@ -1235,8 +1235,8 @@ var require_dist2 = __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 fs28 = $global.require("fs");
-        "object" == typeof fs28 && null !== fs28 && 0 !== Object.keys(fs28).length && ($global.fs = fs28);
+        var fs29 = $global.require("fs");
+        "object" == typeof fs29 && null !== fs29 && 0 !== Object.keys(fs29).length && ($global.fs = fs29);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183429,8 +183429,8 @@ import { Command } from "commander";
 // src/commands/init.tsx
 import React2, { useState, useEffect } from "react";
 import { render as render2, Text as Text2, Box as Box2, useInput, useApp } from "ink";
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 // node_modules/.pnpm/@specific+sdk@file+..+sdk/node_modules/@specific/sdk/dist/index.js
 import * as fs from "fs";
@@ -183440,8 +183440,8 @@ import { execSync } from "child_process";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 // node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
@@ -183533,7 +183533,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path26) => statMethod(path26, { bigint: true });
+      this._stat = (path27) => statMethod(path27, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -183558,8 +183558,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path26, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path26));
+          const { path: path27, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path27));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -183599,20 +183599,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path26, depth) {
+  async _exploreDir(path27, depth) {
     let files;
     try {
-      files = await readdir(path26, this._rdOptions);
+      files = await readdir(path27, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path26 };
+    return { files, depth, path: path27 };
   }
-  async _formatEntry(dirent, path26) {
+  async _formatEntry(dirent, path27) {
     let entry;
     const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path26, basename6));
+      const fullPath = presolve(pjoin(path27, basename6));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -184012,16 +184012,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path26, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path27, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path26);
-    emitRaw(rawEvent, evPath, { watchedPath: path26 });
-    if (evPath && path26 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path26, evPath), KEY_LISTENERS, sp.join(path26, evPath));
+    listener(path27);
+    emitRaw(rawEvent, evPath, { watchedPath: path27 });
+    if (evPath && path27 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path27, evPath), KEY_LISTENERS, sp.join(path27, evPath));
     }
   };
   try {
-    return fs_watch(path26, {
+    return fs_watch(path27, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -184037,12 +184037,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path26, fullPath, options2, handlers) => {
+var setFsWatchListener = (path27, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path26, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path27, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -184053,7 +184053,7 @@ var setFsWatchListener = (path26, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path26,
+      path27,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -184068,7 +184068,7 @@ var setFsWatchListener = (path26, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path26, "r");
+          const fd = await open(path27, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -184099,7 +184099,7 @@ var setFsWatchListener = (path26, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path26, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path27, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -184121,7 +184121,7 @@ var setFsWatchFileListener = (path26, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path26, curr));
+          foreach(cont.listeners, (listener2) => listener2(path27, curr));
         }
       })
     };
@@ -184151,13 +184151,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path26, listener) {
+  _watchWithNodeFs(path27, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path26);
-    const basename6 = sp.basename(path26);
+    const directory = sp.dirname(path27);
+    const basename6 = sp.basename(path27);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename6);
-    const absolutePath = sp.resolve(path26);
+    const absolutePath = sp.resolve(path27);
     const options2 = {
       persistent: opts.persistent
     };
@@ -184167,12 +184167,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path26, absolutePath, options2, {
+      closer = setFsWatchFileListener(path27, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path26, absolutePath, options2, {
+      closer = setFsWatchListener(path27, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -184194,7 +184194,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename6))
       return;
-    const listener = async (path26, newStats) => {
+    const listener = async (path27, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -184208,11 +184208,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path26);
+            this.fsw._closeFile(path27);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path26, closer2);
+              this.fsw._addPathCloser(path27, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -184244,7 +184244,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, path26, item) {
+  async _handleSymlink(entry, directory, path27, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -184254,7 +184254,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path26);
+        linkPath = await fsrealpath(path27);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -184264,12 +184264,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, path26, entry.stats);
+          this.fsw._emit(EV.CHANGE, path27, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path26, entry.stats);
+        this.fsw._emit(EV.ADD, path27, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -184299,9 +184299,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path26 = sp.join(directory, item);
+      let path27 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path26, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path27, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -184310,8 +184310,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path26 = sp.join(dir, sp.relative(dir, path26));
-        this._addToNodeFs(path26, initialAdd, wh, depth + 1);
+        path27 = sp.join(dir, sp.relative(dir, path27));
+        this._addToNodeFs(path27, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve9, reject) => {
@@ -184380,13 +184380,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path26, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path27, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path26) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path27) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path26);
+    const wh = this.fsw._getWatchHelpers(path27);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -184402,8 +184402,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path26);
-        const targetPath = follow ? await fsrealpath(path26) : path26;
+        const absPath = sp.resolve(path27);
+        const targetPath = follow ? await fsrealpath(path27) : path27;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -184413,29 +184413,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path26) : path26;
+        const targetPath = follow ? await fsrealpath(path27) : path27;
         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, path26, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path27, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path26), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path27), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path26, closer);
+        this.fsw._addPathCloser(path27, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path26;
+        return path27;
       }
     }
   }
@@ -184478,24 +184478,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path26) {
-  if (typeof path26 !== "string")
+function normalizePath(path27) {
+  if (typeof path27 !== "string")
     throw new Error("string expected");
-  path26 = sp2.normalize(path26);
-  path26 = path26.replace(/\\/g, "/");
+  path27 = sp2.normalize(path27);
+  path27 = path27.replace(/\\/g, "/");
   let prepend = false;
-  if (path26.startsWith("//"))
+  if (path27.startsWith("//"))
     prepend = true;
-  path26 = path26.replace(DOUBLE_SLASH_RE, "/");
+  path27 = path27.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path26 = "/" + path26;
-  return path26;
+    path27 = "/" + path27;
+  return path27;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path26 = normalizePath(testString);
+  const path27 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path26, stats)) {
+    if (pattern(path27, stats)) {
       return true;
     }
   }
@@ -184533,19 +184533,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path26) => toUnix(sp2.normalize(toUnix(path26)));
-var normalizeIgnored = (cwd = "") => (path26) => {
-  if (typeof path26 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path26) ? path26 : sp2.join(cwd, path26));
+var normalizePathToUnix = (path27) => toUnix(sp2.normalize(toUnix(path27)));
+var normalizeIgnored = (cwd = "") => (path27) => {
+  if (typeof path27 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path27) ? path27 : sp2.join(cwd, path27));
   } else {
-    return path26;
+    return path27;
   }
 };
-var getAbsolutePath = (path26, cwd) => {
-  if (sp2.isAbsolute(path26)) {
-    return path26;
+var getAbsolutePath = (path27, cwd) => {
+  if (sp2.isAbsolute(path27)) {
+    return path27;
   }
-  return sp2.join(cwd, path26);
+  return sp2.join(cwd, path27);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -184610,10 +184610,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path26, follow, fsw) {
+  constructor(path27, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path26;
-    this.path = path26 = path26.replace(REPLACER_RE, "");
+    const watchPath = path27;
+    this.path = path27 = path27.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -184753,20 +184753,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path26) => {
-        const absPath = getAbsolutePath(path26, cwd);
+      paths = paths.map((path27) => {
+        const absPath = getAbsolutePath(path27, cwd);
         return absPath;
       });
     }
-    paths.forEach((path26) => {
-      this._removeIgnoredPath(path26);
+    paths.forEach((path27) => {
+      this._removeIgnoredPath(path27);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path26) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path26, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path27) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path27, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -184788,17 +184788,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path26) => {
-      if (!sp2.isAbsolute(path26) && !this._closers.has(path26)) {
+    paths.forEach((path27) => {
+      if (!sp2.isAbsolute(path27) && !this._closers.has(path27)) {
         if (cwd)
-          path26 = sp2.join(cwd, path26);
-        path26 = sp2.resolve(path26);
+          path27 = sp2.join(cwd, path27);
+        path27 = sp2.resolve(path27);
       }
-      this._closePath(path26);
-      this._addIgnoredPath(path26);
-      if (this._watched.has(path26)) {
+      this._closePath(path27);
+      this._addIgnoredPath(path27);
+      if (this._watched.has(path27)) {
         this._addIgnoredPath({
-          path: path26,
+          path: path27,
           recursive: true
         });
       }
@@ -184862,38 +184862,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, path26, stats) {
+  async _emit(event, path27, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path26 = sp2.normalize(path26);
+      path27 = sp2.normalize(path27);
     if (opts.cwd)
-      path26 = sp2.relative(opts.cwd, path26);
-    const args = [path26];
+      path27 = sp2.relative(opts.cwd, path27);
+    const args = [path27];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path26))) {
+    if (awf && (pw = this._pendingWrites.get(path27))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path26, [event, ...args]);
+        this._pendingUnlinks.set(path27, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path27) => {
+          this._pendingUnlinks.forEach((entry, path28) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path27);
+            this._pendingUnlinks.delete(path28);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path26)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path27)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path26);
+        this._pendingUnlinks.delete(path27);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -184911,16 +184911,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path26, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path27, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path26, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path27, 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, path26) : path26;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path27) : path27;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -184951,23 +184951,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, path26, timeout) {
+  _throttle(actionType, path27, 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(path26);
+    const actionPath = action.get(path27);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path26);
+      const item = action.get(path27);
       const count = item ? item.count : 0;
-      action.delete(path26);
+      action.delete(path27);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -184975,7 +184975,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path26, thr);
+    action.set(path27, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -184989,44 +184989,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path26, threshold, event, awfEmit) {
+  _awaitWriteFinish(path27, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path26;
-    if (this.options.cwd && !sp2.isAbsolute(path26)) {
-      fullPath = sp2.join(this.options.cwd, path26);
+    let fullPath = path27;
+    if (this.options.cwd && !sp2.isAbsolute(path27)) {
+      fullPath = sp2.join(this.options.cwd, path27);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path26)) {
+        if (err || !writes.has(path27)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path26).lastChange = now2;
+          writes.get(path27).lastChange = now2;
         }
-        const pw = writes.get(path26);
+        const pw = writes.get(path27);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path26);
+          writes.delete(path27);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path26)) {
-      writes.set(path26, {
+    if (!writes.has(path27)) {
+      writes.set(path27, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path26);
+          writes.delete(path27);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -185037,8 +185037,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path26, stats) {
-    if (this.options.atomic && DOT_RE.test(path26))
+  _isIgnored(path27, stats) {
+    if (this.options.atomic && DOT_RE.test(path27))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -185048,17 +185048,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path26, stats);
+    return this._userIgnored(path27, stats);
   }
-  _isntIgnored(path26, stat4) {
-    return !this._isIgnored(path26, stat4);
+  _isntIgnored(path27, stat4) {
+    return !this._isIgnored(path27, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path26) {
-    return new WatchHelper(path26, this.options.followSymlinks, this);
+  _getWatchHelpers(path27) {
+    return new WatchHelper(path27, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -185090,63 +185090,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path26 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path26);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path26) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path26, 100))
+    const path27 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path27);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path27) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path27, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path26);
+    const wp = this._getWatchedDir(path27);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path26, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path27, 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 = path26;
+    let relPath = path27;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path26);
+      relPath = sp2.relative(this.options.cwd, path27);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path26);
+    this._watched.delete(path27);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path26))
-      this._emit(eventName, path26);
-    this._closePath(path26);
+    if (wasTracked && !this._isIgnored(path27))
+      this._emit(eventName, path27);
+    this._closePath(path27);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path26) {
-    this._closeFile(path26);
-    const dir = sp2.dirname(path26);
-    this._getWatchedDir(dir).remove(sp2.basename(path26));
+  _closePath(path27) {
+    this._closeFile(path27);
+    const dir = sp2.dirname(path27);
+    this._getWatchedDir(dir).remove(sp2.basename(path27));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path26) {
-    const closers = this._closers.get(path26);
+  _closeFile(path27) {
+    const closers = this._closers.get(path27);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path26);
+    this._closers.delete(path27);
   }
-  _addPathCloser(path26, closer) {
+  _addPathCloser(path27, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path26);
+    let list = this._closers.get(path27);
     if (!list) {
       list = [];
-      this._closers.set(path26, list);
+      this._closers.set(path27, list);
     }
     list.push(closer);
   }
@@ -185196,6 +185196,8 @@ import * as fs7 from "fs";
 import * as path7 from "path";
 import { fileURLToPath } from "url";
 import * as net2 from "net";
+import * as fs8 from "fs";
+import * as path9 from "path";
 import { spawn as spawn3 } from "child_process";
 import { readFile as readFile2, writeFile as writeFile2, mkdir } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
@@ -185204,26 +185206,26 @@ import * as crypto from "crypto";
 import * as http2 from "http";
 import * as crypto2 from "crypto";
 import * as net3 from "net";
-import * as fs8 from "fs";
-import * as path9 from "path";
-import { spawn as spawn4 } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
 import * as fs9 from "fs";
 import * as path10 from "path";
-import { spawnSync } from "child_process";
+import { spawn as spawn4 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
 import * as fs10 from "fs";
 import * as path11 from "path";
+import { spawnSync } from "child_process";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import * as net4 from "net";
 import { spawn as spawn5 } from "child_process";
 import * as net5 from "net";
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs12 from "fs";
+import * as path13 from "path";
 import { generateSlug } from "random-word-slugs";
 import { EventEmitter as EventEmitter2 } from "node:events";
 import * as net6 from "node:net";
 import { EventEmitter as EventEmitter22 } from "events";
 import { execSync as execSync2 } from "child_process";
-import * as path14 from "path";
+import * as path15 from "path";
 var __create2 = Object.create;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -185264,8 +185266,8 @@ var require_dist = __commonJS2({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require2 : $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 fs132 = $global.require("fs");
-        "object" == typeof fs132 && null !== fs132 && 0 !== Object.keys(fs132).length && ($global.fs = fs132);
+        var fs142 = $global.require("fs");
+        "object" == typeof fs142 && null !== fs142 && 0 !== Object.keys(fs142).length && ($global.fs = fs142);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -370384,7 +370386,7 @@ function findMissingSecrets(secretsDef, preparedSecrets, usedSecrets) {
   }
   return missing;
 }
-async function startElectric(postgres, port, options2) {
+async function startElectric(postgres, port, dataDir, options2) {
   if (postgres.type !== "postgres") {
     throw new Error(
       `Electric sync only works with postgres, not ${postgres.type}`
@@ -370397,10 +370399,13 @@ async function startElectric(postgres, port, options2) {
   );
   const secret = generateRandomString(32);
   const host = "127.0.0.1";
+  const storageDir = path9.join(process.cwd(), dataDir, `electric-${postgres.name}`);
+  fs8.rmSync(storageDir, { recursive: true, force: true });
   writeLog("electric", `Starting Electric for database "${postgres.name}"`);
   writeLog("electric", `DATABASE_URL: ${postgres.url}`);
   writeLog("electric", `ELECTRIC_PORT: ${port}`);
   writeLog("electric", `ELECTRIC_SECRET: ${secret}`);
+  writeLog("electric", `ELECTRIC_STORAGE_DIR: ${storageDir}`);
   writeLog("electric", `Binary: ${binary.executables["electric"]}`);
   const electric = spawn3(binary.executables["electric"], [], {
     stdio: ["ignore", "pipe", "pipe"],
@@ -370409,6 +370414,7 @@ async function startElectric(postgres, port, options2) {
       DATABASE_URL: postgres.url,
       ELECTRIC_SECRET: secret,
       ELECTRIC_PORT: String(port),
+      ELECTRIC_STORAGE_DIR: storageDir,
       ELECTRIC_PERSISTENT_STATE: "MEMORY",
       ELECTRIC_STORAGE: "MEMORY"
     }
@@ -370629,13 +370635,13 @@ async function startDrizzleGateway(postgresInstances, port, configDir, options2)
     options2?.onProgress
   );
   const host = "127.0.0.1";
-  const drizzleConfigDir = path9.join(configDir, "drizzle-gateway");
-  if (!fs8.existsSync(drizzleConfigDir)) {
-    fs8.mkdirSync(drizzleConfigDir, { recursive: true });
+  const drizzleConfigDir = path10.join(configDir, "drizzle-gateway");
+  if (!fs9.existsSync(drizzleConfigDir)) {
+    fs9.mkdirSync(drizzleConfigDir, { recursive: true });
   }
   const storeJson = generateStoreJson(postgresInstances);
-  const storeJsonPath = path9.join(drizzleConfigDir, "store.json");
-  fs8.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
+  const storeJsonPath = path10.join(drizzleConfigDir, "store.json");
+  fs9.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
   writeLog("drizzle-gateway", `Starting Drizzle Gateway`);
   writeLog("drizzle-gateway", `STORE_PATH: ${drizzleConfigDir}`);
   writeLog("drizzle-gateway", `PORT: ${port}`);
@@ -370735,11 +370741,11 @@ function detectSyncDatabases(config) {
 }
 function getMigrationFiles(dir, log) {
   log(`Scanning migrations directory: ${dir}`);
-  if (!fs9.existsSync(dir)) {
+  if (!fs10.existsSync(dir)) {
     log(`Migrations directory does not exist: ${dir}`);
     return [];
   }
-  const files = fs9.readdirSync(dir);
+  const files = fs10.readdirSync(dir);
   log(`Found ${files.length} files in directory`);
   const tomlFiles = files.filter((f) => f.endsWith(".toml")).sort((a, b) => a.localeCompare(b));
   log(`Found ${tomlFiles.length} .toml migration files: ${tomlFiles.join(", ") || "(none)"}`);
@@ -370789,7 +370795,7 @@ function runReshape(args, databaseUrl, migrationsDir, reshapeBinaryPath, log) {
 }
 function makeReadOnly(filePath, log) {
   try {
-    fs9.chmodSync(filePath, 292);
+    fs10.chmodSync(filePath, 292);
     log(`Set file permissions to read-only (444): ${filePath}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -370850,7 +370856,7 @@ function createReshapeWatcher(options2) {
       log(`Successfully completed ${currentMigrationFiles.length - 1} migration(s)`);
       log(`Making completed migration files read-only...`);
       for (let i = 0; i < currentMigrationFiles.length - 1; i++) {
-        const filePath = path10.join(migrationsDir, currentMigrationFiles[i]);
+        const filePath = path11.join(migrationsDir, currentMigrationFiles[i]);
         makeReadOnly(filePath, log);
       }
       log(`Starting latest migration "${lastMigrationName}" (will not be completed, allowing iteration)`);
@@ -370875,9 +370881,9 @@ function createReshapeWatcher(options2) {
   };
   const startWatching = () => {
     log(`Starting file watcher for migrations directory...`);
-    if (!fs9.existsSync(migrationsDir)) {
+    if (!fs10.existsSync(migrationsDir)) {
       log(`Migrations directory does not exist, creating: ${migrationsDir}`);
-      fs9.mkdirSync(migrationsDir, { recursive: true });
+      fs10.mkdirSync(migrationsDir, { recursive: true });
     }
     log(`Watching directory: ${migrationsDir}`);
     watcher = chokidar_default.watch(migrationsDir, {
@@ -370890,7 +370896,7 @@ function createReshapeWatcher(options2) {
       }
     });
     watcher.on("change", (filePath) => {
-      const filename = path10.basename(filePath);
+      const filename = path11.basename(filePath);
       if (!filename.endsWith(".toml")) return;
       log(`File change detected: ${filename}`);
       log(`  Full path: ${filePath}`);
@@ -370921,7 +370927,7 @@ function createReshapeWatcher(options2) {
       }
     });
     watcher.on("add", (filePath) => {
-      const filename = path10.basename(filePath);
+      const filename = path11.basename(filePath);
       if (!filename.endsWith(".toml")) return;
       log(`New file detected: ${filename}`);
       log(`  Full path: ${filePath}`);
@@ -370945,7 +370951,7 @@ function createReshapeWatcher(options2) {
           return;
         }
         log(`Previous migration completed successfully`);
-        const completedPath = path10.join(migrationsDir, startedMigration);
+        const completedPath = path11.join(migrationsDir, startedMigration);
         makeReadOnly(completedPath, log);
       } else {
         log(`No previous migration was started`);
@@ -370970,7 +370976,7 @@ function createReshapeWatcher(options2) {
       onSearchPathChanged(newSearchPath);
     });
     watcher.on("unlink", (filePath) => {
-      const filename = path10.basename(filePath);
+      const filename = path11.basename(filePath);
       if (!filename.endsWith(".toml")) return;
       log(`File deleted: ${filename}`);
       log(`  Full path: ${filePath}`);
@@ -371012,10 +371018,10 @@ function createReshapeWatcher(options2) {
 }
 async function startTemporalDevServer(temporals, grpcPort, uiPort, dataDir, onProgress) {
   const binary = await ensureBinary(temporalBinary, void 0, onProgress);
-  const dbPath = path11.join(process.cwd(), dataDir, "temporal.db");
-  const dbDir = path11.dirname(dbPath);
-  if (!fs10.existsSync(dbDir)) {
-    fs10.mkdirSync(dbDir, { recursive: true });
+  const dbPath = path12.join(process.cwd(), dataDir, "temporal.db");
+  const dbDir = path12.dirname(dbPath);
+  if (!fs11.existsSync(dbDir)) {
+    fs11.mkdirSync(dbDir, { recursive: true });
   }
   const host = "127.0.0.1";
   const namespaceArgs = temporals.flatMap((t) => ["--namespace", t.name]);
@@ -371303,7 +371309,7 @@ async function startResources(options2) {
       const electricPort = portAllocator.allocate(`electric:${pgName}`);
       log(`Starting Electric sync for "${pgName}" on port ${electricPort}`);
       callbacks.onElectricStarting?.(pgName);
-      const electricInstance = await startElectric(pg, electricPort);
+      const electricInstance = await startElectric(pg, electricPort, dataDir);
       electric.set(pgName, electricInstance);
       startedElectric.push(electricInstance);
       pg.syncUrl = electricInstance.url;
@@ -371408,16 +371414,16 @@ var StableSubdomainAllocator = class {
   tunnelsFilePath;
   baseSlug = null;
   constructor(projectRoot, key = "default") {
-    this.tunnelsDir = path12.join(projectRoot, ".specific", "keys", key);
-    this.tunnelsFilePath = path12.join(this.tunnelsDir, "tunnels.json");
+    this.tunnelsDir = path13.join(projectRoot, ".specific", "keys", key);
+    this.tunnelsFilePath = path13.join(this.tunnelsDir, "tunnels.json");
     this.loadTunnels();
   }
   loadTunnels() {
-    if (!fs11.existsSync(this.tunnelsFilePath)) {
+    if (!fs12.existsSync(this.tunnelsFilePath)) {
       return;
     }
     try {
-      const content = fs11.readFileSync(this.tunnelsFilePath, "utf-8");
+      const content = fs12.readFileSync(this.tunnelsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.baseSlug) {
         this.baseSlug = data.baseSlug;
@@ -371427,14 +371433,14 @@ var StableSubdomainAllocator = class {
     }
   }
   saveTunnels() {
-    if (!fs11.existsSync(this.tunnelsDir)) {
-      fs11.mkdirSync(this.tunnelsDir, { recursive: true });
+    if (!fs12.existsSync(this.tunnelsDir)) {
+      fs12.mkdirSync(this.tunnelsDir, { recursive: true });
     }
     const data = {
       version: 1,
       baseSlug: this.baseSlug
     };
-    fs11.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
+    fs12.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
   }
   generateBaseSlug() {
     return generateSlug(2, {
@@ -371918,10 +371924,10 @@ var DevEnvironment = class extends TypedEventEmitter {
   }
   // ── Private: config file watcher ───────────────────────────────────────────
   startConfigWatcher() {
-    const configPath = path13.join(this.projectDir, "specific.hcl");
+    const configPath = path14.join(this.projectDir, "specific.hcl");
     this.configWatcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs12.readFileSync(configPath, "utf-8");
+        const hcl = fs13.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           this.reload();
         }).catch((err) => {
@@ -371960,8 +371966,8 @@ var DevEnvironment = class extends TypedEventEmitter {
       this.emit("error", new Error(msg));
       return;
     }
-    const configPath = path13.join(this.projectDir, "specific.hcl");
-    if (!fs12.existsSync(configPath)) {
+    const configPath = path14.join(this.projectDir, "specific.hcl");
+    if (!fs13.existsSync(configPath)) {
       this.systemLog("Waiting for specific.hcl to appear");
       this.setStatus("waiting");
       const dirWatcher = chokidar_default.watch(configPath, {
@@ -371982,7 +371988,7 @@ var DevEnvironment = class extends TypedEventEmitter {
       return;
     }
     let config;
-    const hcl = fs12.readFileSync(configPath, "utf-8");
+    const hcl = fs13.readFileSync(configPath, "utf-8");
     try {
       config = await parseConfig(hcl);
     } catch (err) {
@@ -371992,9 +371998,9 @@ var DevEnvironment = class extends TypedEventEmitter {
       return;
     }
     if (this.cancelled) return;
-    const localFilePath = path13.join(this.projectDir, "specific.local");
-    if (fs12.existsSync(localFilePath)) {
-      const localContent = fs12.readFileSync(localFilePath, "utf-8");
+    const localFilePath = path14.join(this.projectDir, "specific.local");
+    if (fs13.existsSync(localFilePath)) {
+      const localContent = fs13.readFileSync(localFilePath, "utf-8");
       try {
         await parseLocalFile(localContent);
       } catch (err) {
@@ -372111,7 +372117,7 @@ var DevEnvironment = class extends TypedEventEmitter {
         const drizzleGateway = await startDrizzleGateway(
           postgresResources,
           drizzlePort,
-          path13.join(this.projectDir, ".specific", "keys", this.instanceKey)
+          path14.join(this.projectDir, ".specific", "keys", this.instanceKey)
         );
         this.drizzleGateway = drizzleGateway;
         this.systemLog(`Database viewer ready at ${drizzleGateway.url}`);
@@ -372131,7 +372137,7 @@ var DevEnvironment = class extends TypedEventEmitter {
       if (pg.reshape?.enabled) {
         const resource = resources.get(pg.name);
         if (!resource) continue;
-        const migrationsDir = path13.resolve(
+        const migrationsDir = path14.resolve(
           this.projectDir,
           pg.reshape.migrations_dir ?? "migrations"
         );
@@ -372334,13 +372340,13 @@ Add them to the config block in specific.local`
     const runningServices = [];
     const resolveServiceCwd = (service) => {
       if (service.root)
-        return path13.resolve(this.projectDir, service.root);
+        return path14.resolve(this.projectDir, service.root);
       if (service.build) {
         const build = config.builds.find(
           (b) => b.name === service.build.name
         );
         if (build?.root)
-          return path13.resolve(this.projectDir, build.root);
+          return path14.resolve(this.projectDir, build.root);
       }
       return this.projectDir;
     };
@@ -372561,8 +372567,8 @@ function isInWorktree() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const resolvedCommonDir = path14.resolve(commonDir);
-    const resolvedGitDir = path14.resolve(gitDir);
+    const resolvedCommonDir = path15.resolve(commonDir);
+    const resolvedGitDir = path15.resolve(gitDir);
     return resolvedCommonDir !== resolvedGitDir;
   } catch {
     return false;
@@ -372577,7 +372583,7 @@ function getWorktreeName() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return path14.basename(gitDir);
+    return path15.basename(gitDir);
   } catch {
     return null;
   }
@@ -372632,8 +372638,8 @@ function writeProjectId(projectId, projectDir = process.cwd()) {
 }
 // src/lib/auth/credentials.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 import * as os4 from "os";
 // src/lib/auth/errors.ts
@@ -372877,18 +372883,18 @@ function performLogin(options2 = {}) {
 // src/lib/auth/credentials.ts
 function getUserCredentialsDir() {
-  return path16.join(os4.homedir(), ".specific");
+  return path17.join(os4.homedir(), ".specific");
 }
 function getCredentialsPath() {
-  return path16.join(getUserCredentialsDir(), "credentials.json");
+  return path17.join(getUserCredentialsDir(), "credentials.json");
 }
 function readUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (!fs18.existsSync(credentialsPath)) {
+  if (!fs19.existsSync(credentialsPath)) {
     return null;
   }
   try {
-    const content = fs18.readFileSync(credentialsPath, "utf-8");
+    const content = fs19.readFileSync(credentialsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -372896,18 +372902,18 @@ function readUserCredentials() {
 }
 function writeUserCredentials(credentials) {
   const dir = getUserCredentialsDir();
-  if (!fs18.existsSync(dir)) {
-    fs18.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs19.existsSync(dir)) {
+    fs19.mkdirSync(dir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
-  fs18.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs19.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
 function clearUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (fs18.existsSync(credentialsPath)) {
-    fs18.unlinkSync(credentialsPath);
+  if (fs19.existsSync(credentialsPath)) {
+    fs19.unlinkSync(credentialsPath);
   }
 }
 function isLoggedIn() {
@@ -373033,7 +373039,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.102",
+      cli_version: "0.1.103",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId()
@@ -373064,67 +373070,67 @@ var options = [
   { id: "other", label: "Other / Manual" }
 ];
 function isGitProject() {
-  const gitPath = path17.join(process.cwd(), ".git");
-  return fs19.existsSync(gitPath);
+  const gitPath = path18.join(process.cwd(), ".git");
+  return fs20.existsSync(gitPath);
 }
 function detectExistingAgents() {
   const detected = {};
-  const cursorDir = path17.join(process.cwd(), ".cursor");
-  if (fs19.existsSync(cursorDir)) {
+  const cursorDir = path18.join(process.cwd(), ".cursor");
+  if (fs20.existsSync(cursorDir)) {
     detected["cursor"] = true;
   }
-  const claudeDir = path17.join(process.cwd(), ".claude");
-  const claudeMd = path17.join(process.cwd(), "CLAUDE.md");
-  if (fs19.existsSync(claudeDir) || fs19.existsSync(claudeMd)) {
+  const claudeDir = path18.join(process.cwd(), ".claude");
+  const claudeMd = path18.join(process.cwd(), "CLAUDE.md");
+  if (fs20.existsSync(claudeDir) || fs20.existsSync(claudeMd)) {
     detected["claude"] = true;
   }
-  const agentsMd = path17.join(process.cwd(), "AGENTS.md");
-  if (fs19.existsSync(agentsMd)) {
+  const agentsMd = path18.join(process.cwd(), "AGENTS.md");
+  if (fs20.existsSync(agentsMd)) {
     detected["codex"] = true;
   }
   return detected;
 }
 function appendOrCreateFile(filePath, content) {
-  if (fs19.existsSync(filePath)) {
-    const existing = fs19.readFileSync(filePath, "utf-8");
+  if (fs20.existsSync(filePath)) {
+    const existing = fs20.readFileSync(filePath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    fs19.writeFileSync(filePath, existing + separator + content + "\n");
+    fs20.writeFileSync(filePath, existing + separator + content + "\n");
     return "modified";
   } else {
-    fs19.writeFileSync(filePath, content + "\n");
+    fs20.writeFileSync(filePath, content + "\n");
     return "created";
   }
 }
 function addToGitignore() {
-  const gitignorePath = path17.join(process.cwd(), ".gitignore");
+  const gitignorePath = path18.join(process.cwd(), ".gitignore");
   const entries = [".specific", "specific.local"];
-  if (fs19.existsSync(gitignorePath)) {
-    const existing = fs19.readFileSync(gitignorePath, "utf-8");
+  if (fs20.existsSync(gitignorePath)) {
+    const existing = fs20.readFileSync(gitignorePath, "utf-8");
     const lines = existing.split("\n").map((l) => l.trim());
     const missingEntries = entries.filter((entry) => !lines.includes(entry));
     if (missingEntries.length === 0) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "" : "\n";
-    fs19.writeFileSync(
+    fs20.writeFileSync(
       gitignorePath,
       existing + separator + missingEntries.join("\n") + "\n"
     );
     return "modified";
   } else {
-    fs19.writeFileSync(gitignorePath, entries.join("\n") + "\n");
+    fs20.writeFileSync(gitignorePath, entries.join("\n") + "\n");
     return "created";
   }
 }
 function configureClaudeCodePermissions() {
-  const claudeDir = path17.join(process.cwd(), ".claude");
-  const settingsPath = path17.join(claudeDir, "settings.local.json");
+  const claudeDir = path18.join(process.cwd(), ".claude");
+  const settingsPath = path18.join(claudeDir, "settings.local.json");
   const permissions = ["Bash(specific docs:*)", "Bash(specific check:*)"];
-  if (fs19.existsSync(settingsPath)) {
-    const existing = JSON.parse(fs19.readFileSync(settingsPath, "utf-8"));
+  if (fs20.existsSync(settingsPath)) {
+    const existing = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
     const allowList = existing?.permissions?.allow || [];
     const missingPermissions = permissions.filter(
       (p) => !allowList.includes(p)
@@ -373139,39 +373145,39 @@ function configureClaudeCodePermissions() {
       existing.permissions.allow = [];
     }
     existing.permissions.allow.push(...missingPermissions);
-    fs19.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    fs20.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
     return "modified";
   }
-  if (!fs19.existsSync(claudeDir)) {
-    fs19.mkdirSync(claudeDir);
+  if (!fs20.existsSync(claudeDir)) {
+    fs20.mkdirSync(claudeDir);
   }
   const settings = {
     permissions: {
       allow: permissions
     }
   };
-  fs19.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs20.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return "created";
 }
 function createCursorRule() {
-  const cursorDir = path17.join(process.cwd(), ".cursor");
-  const rulesDir = path17.join(cursorDir, "rules");
-  const mdcPath = path17.join(rulesDir, "specific.mdc");
-  if (fs19.existsSync(mdcPath)) {
-    const existing = fs19.readFileSync(mdcPath, "utf-8");
+  const cursorDir = path18.join(process.cwd(), ".cursor");
+  const rulesDir = path18.join(cursorDir, "rules");
+  const mdcPath = path18.join(rulesDir, "specific.mdc");
+  if (fs20.existsSync(mdcPath)) {
+    const existing = fs20.readFileSync(mdcPath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
-    fs19.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+    fs20.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
     return "modified";
   }
-  if (!fs19.existsSync(cursorDir)) {
-    fs19.mkdirSync(cursorDir);
+  if (!fs20.existsSync(cursorDir)) {
+    fs20.mkdirSync(cursorDir);
   }
-  if (!fs19.existsSync(rulesDir)) {
-    fs19.mkdirSync(rulesDir);
+  if (!fs20.existsSync(rulesDir)) {
+    fs20.mkdirSync(rulesDir);
   }
-  fs19.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+  fs20.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
   return "created";
 }
 function configureAgents(checked) {
@@ -373187,7 +373193,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".cursor/rules/specific.mdc");
   }
   if (checked["claude"]) {
-    const claudeMdPath = path17.join(process.cwd(), "CLAUDE.md");
+    const claudeMdPath = path18.join(process.cwd(), "CLAUDE.md");
     const status = appendOrCreateFile(claudeMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("CLAUDE.md");
     else if (status === "modified") agents.filesModified.push("CLAUDE.md");
@@ -373198,7 +373204,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".claude/settings.local.json");
   }
   if (checked["codex"]) {
-    const agentsMdPath = path17.join(process.cwd(), "AGENTS.md");
+    const agentsMdPath = path18.join(process.cwd(), "AGENTS.md");
     const status = appendOrCreateFile(agentsMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("AGENTS.md");
     else if (status === "modified") agents.filesModified.push("AGENTS.md");
@@ -373352,7 +373358,7 @@ Valid agents: ${VALID_AGENT_IDS.join(", ")}`
 // src/commands/docs.tsx
 import { readFileSync as readFileSync9, existsSync as existsSync17 } from "fs";
-import { join as join18, dirname as dirname8 } from "path";
+import { join as join19, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 // src/lib/beta/registry.ts
@@ -373369,10 +373375,10 @@ var BETA_REGISTRY = [
 // src/lib/beta/storage.ts
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync16, mkdirSync as mkdirSync12 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var BETAS_FILE = ".specific/betas.json";
 function loadEnabledBetas(projectDir = process.cwd()) {
-  const filePath = join17(projectDir, BETAS_FILE);
+  const filePath = join18(projectDir, BETAS_FILE);
   if (!existsSync16(filePath)) {
     return [];
   }
@@ -373396,26 +373402,26 @@ function disableBeta(name, projectDir = process.cwd()) {
   saveBetas(enabled, projectDir);
 }
 function saveBetas(enabled, projectDir) {
-  const specificDir = join17(projectDir, ".specific");
+  const specificDir = join18(projectDir, ".specific");
   if (!existsSync16(specificDir)) {
     mkdirSync12(specificDir, { recursive: true });
   }
   const data = { enabled };
   writeFileSync7(
-    join17(projectDir, BETAS_FILE),
+    join18(projectDir, BETAS_FILE),
     JSON.stringify(data, null, 2) + "\n"
   );
 }
 // src/commands/docs.tsx
 var __dirname3 = dirname8(fileURLToPath3(import.meta.url));
-var docsDir = join18(__dirname3, "docs");
+var docsDir = join19(__dirname3, "docs");
 var _embeddedDocs = null;
-function docsCommand(path26) {
-  const content = resolveDocContent(path26);
+function docsCommand(path27) {
+  const content = resolveDocContent(path27);
   if (!content) {
     console.error(
-      `Documentation not found: ${path26 || "index"}
+      `Documentation not found: ${path27 || "index"}
 Run 'specific docs' to see available topics.`
     );
@@ -373433,31 +373439,31 @@ function filterBetaTags(content, enabledBetas) {
     }
   );
 }
-function resolveDocContent(path26) {
-  const normalized = path26?.replace(/^\/+|\/+$/g, "") || void 0;
+function resolveDocContent(path27) {
+  const normalized = path27?.replace(/^\/+|\/+$/g, "") || void 0;
   if (_embeddedDocs) {
     return resolveEmbeddedDoc(normalized);
   }
   return resolveFilesystemDoc(normalized);
 }
-function resolveEmbeddedDoc(path26) {
-  if (!path26) {
+function resolveEmbeddedDoc(path27) {
+  if (!path27) {
     return _embeddedDocs.get("index.md") ?? null;
   }
-  const direct = _embeddedDocs.get(`${path26}.md`);
+  const direct = _embeddedDocs.get(`${path27}.md`);
   if (direct) return direct;
-  return _embeddedDocs.get(`${path26}/index.md`) ?? null;
+  return _embeddedDocs.get(`${path27}/index.md`) ?? null;
 }
-function resolveFilesystemDoc(path26) {
-  if (!path26) {
-    const indexPath2 = join18(docsDir, "index.md");
+function resolveFilesystemDoc(path27) {
+  if (!path27) {
+    const indexPath2 = join19(docsDir, "index.md");
     return existsSync17(indexPath2) ? readFileSync9(indexPath2, "utf-8") : null;
   }
-  const directPath = join18(docsDir, `${path26}.md`);
+  const directPath = join19(docsDir, `${path27}.md`);
   if (existsSync17(directPath)) {
     return readFileSync9(directPath, "utf-8");
   }
-  const indexPath = join18(docsDir, path26, "index.md");
+  const indexPath = join19(docsDir, path27, "index.md");
   if (existsSync17(indexPath)) {
     return readFileSync9(indexPath, "utf-8");
   }
@@ -373468,8 +373474,8 @@ function resolveFilesystemDoc(path26) {
 import React3, { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render3, Text as Text3, Box as Box3 } from "ink";
 import Spinner2 from "ink-spinner";
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 import { execFile as execFile7 } from "child_process";
 // node_modules/.pnpm/@specific+config@file+..+config/node_modules/@specific/config/dist/parser.js
@@ -374141,20 +374147,20 @@ function CheckUI() {
   const [state, setState] = useState2({ status: "loading" });
   useEffect2(() => {
     async function load() {
-      const configPath = path18.join(process.cwd(), "specific.hcl");
-      if (!fs20.existsSync(configPath)) {
+      const configPath = path19.join(process.cwd(), "specific.hcl");
+      if (!fs21.existsSync(configPath)) {
         setState({
           status: "error",
           error: "No specific.hcl found in current directory"
         });
         return;
       }
-      const hcl = fs20.readFileSync(configPath, "utf-8");
+      const hcl = fs21.readFileSync(configPath, "utf-8");
       try {
         const config2 = await parseConfig2(hcl);
-        const localPath = path18.join(process.cwd(), LOCAL_FILE);
-        if (fs20.existsSync(localPath)) {
-          const localContent = fs20.readFileSync(localPath, "utf-8");
+        const localPath = path19.join(process.cwd(), LOCAL_FILE);
+        if (fs21.existsSync(localPath)) {
+          const localContent = fs21.readFileSync(localPath, "utf-8");
           try {
             await parseLocalFile(localContent);
           } catch (localErr) {
@@ -374167,8 +374173,8 @@ function CheckUI() {
         }
         for (const build of config2.builds) {
           if (build.dockerfile) {
-            const dockerfilePath = path18.resolve(process.cwd(), build.dockerfile);
-            if (!fs20.existsSync(dockerfilePath)) {
+            const dockerfilePath = path19.resolve(process.cwd(), build.dockerfile);
+            if (!fs21.existsSync(dockerfilePath)) {
               setState({
                 status: "error",
                 error: `Build "${build.name}": Dockerfile not found at "${build.dockerfile}" (resolved to ${dockerfilePath})`
@@ -374180,11 +374186,11 @@ function CheckUI() {
         const reshapeChecks2 = [];
         for (const pg of config2.postgres) {
           if (pg.reshape?.enabled) {
-            const migrationsDir = path18.resolve(
+            const migrationsDir = path19.resolve(
               process.cwd(),
               pg.reshape.migrations_dir ?? "migrations"
             );
-            if (!fs20.existsSync(migrationsDir)) {
+            if (!fs21.existsSync(migrationsDir)) {
               reshapeChecks2.push({
                 databaseName: pg.name,
                 migrationsDir: pg.reshape.migrations_dir ?? "migrations",
@@ -374791,8 +374797,8 @@ 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 useInput4 } from "ink";
 import Spinner4 from "ink-spinner";
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -375845,13 +375851,13 @@ ${status.error.output}`);
   }
 }
 async function deployCommand(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;
-  const hcl = fs21.readFileSync(configPath, "utf-8");
+  const hcl = fs22.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig2(hcl);
   } catch (err) {
@@ -375881,8 +375887,8 @@ async function deployCommand(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";
 function startSpinner(text) {
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let i = 0;
@@ -375923,13 +375929,13 @@ 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;
-  const hcl = fs22.readFileSync(configPath, "utf-8");
+  const hcl = fs23.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig2(hcl);
   } catch (err) {
@@ -376067,11 +376073,11 @@ async function execCommand(serviceName, command, instanceKey = "default") {
   process.on("SIGTERM", () => handleSignal("SIGTERM"));
   let effectiveCwd = process.cwd();
   if (service.root) {
-    effectiveCwd = path20.resolve(process.cwd(), service.root);
+    effectiveCwd = path21.resolve(process.cwd(), service.root);
   } else if (service.build) {
     const build = config.builds.find((b) => b.name === service.build.name);
     if (build?.root) {
-      effectiveCwd = path20.resolve(process.cwd(), build.root);
+      effectiveCwd = path21.resolve(process.cwd(), build.root);
     }
   }
   spinner?.stop();
@@ -376100,8 +376106,8 @@ async function execCommand(serviceName, command, instanceKey = "default") {
 // src/commands/psql.tsx
 import { spawn as spawn7 } from "child_process";
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []) {
   let startedResources = [];
   let ownsInstances = false;
@@ -376118,13 +376124,13 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
       }
     }
   };
-  const configPath = path21.join(process.cwd(), "specific.hcl");
-  if (!fs23.existsSync(configPath)) {
+  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);
   }
   let config;
-  const hcl = fs23.readFileSync(configPath, "utf-8");
+  const hcl = fs24.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig2(hcl);
   } catch (err) {
@@ -376249,8 +376255,8 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
 // src/commands/reshape.tsx
 import { spawn as spawn8 } from "child_process";
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 var VALID_ACTIONS = ["start", "complete", "status", "abort", "check"];
 var MIGRATION_SUBCOMMANDS = ["start", "complete", "abort"];
 var OFFLINE_ACTIONS = ["check"];
@@ -376270,13 +376276,13 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
     process.exit(1);
   }
   const isOfflineAction = OFFLINE_ACTIONS.includes(action);
-  const configPath = path22.join(process.cwd(), "specific.hcl");
+  const configPath = path23.join(process.cwd(), "specific.hcl");
   let config;
   let migrationsDir = "migrations";
   let targetDb;
   try {
-    if (fs24.existsSync(configPath)) {
-      const configContent = fs24.readFileSync(configPath, "utf-8");
+    if (fs25.existsSync(configPath)) {
+      const configContent = fs25.readFileSync(configPath, "utf-8");
       config = await parseConfig2(configContent);
       if (databaseName) {
         const postgresConfig = config.postgres.find((p) => p.name === databaseName);
@@ -376411,9 +376417,9 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
   }
   const isMigrationSubcommand = MIGRATION_SUBCOMMANDS.includes(action);
   const reshapeArgs = isMigrationSubcommand ? ["migration", action] : [action];
-  const fullMigrationsPath = path22.join(process.cwd(), migrationsDir);
+  const fullMigrationsPath = path23.join(process.cwd(), migrationsDir);
   if (action === "check" || action === "start") {
-    if (fs24.existsSync(fullMigrationsPath)) {
+    if (fs25.existsSync(fullMigrationsPath)) {
       reshapeArgs.push("--dirs", fullMigrationsPath);
     } else if (action === "check") {
       console.error(`Error: Migrations directory not found: ${fullMigrationsPath}`);
@@ -376463,21 +376469,21 @@ async function reshapeCommand(action, 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 Spinner5 from "ink-spinner";
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 function CleanUI({ instanceKey }) {
   const [state, setState] = useState7({ status: "checking" });
   useEffect5(() => {
     async function clean() {
       const projectRoot = process.cwd();
-      const specificDir = path23.join(projectRoot, ".specific");
-      if (!fs25.existsSync(specificDir)) {
+      const specificDir = path24.join(projectRoot, ".specific");
+      if (!fs26.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
-        const keyDir = path23.join(specificDir, "keys", instanceKey);
-        if (!fs25.existsSync(keyDir)) {
+        const keyDir = path24.join(specificDir, "keys", instanceKey);
+        if (!fs26.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -376493,7 +376499,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs25.rmSync(keyDir, { recursive: true, force: true });
+          fs26.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -376502,13 +376508,13 @@ function CleanUI({ instanceKey }) {
           });
         }
       } else {
-        const keysDir = path23.join(specificDir, "keys");
-        if (!fs25.existsSync(keysDir)) {
+        const keysDir = path24.join(specificDir, "keys");
+        if (!fs26.existsSync(keysDir)) {
           setState({ status: "nothing" });
           return;
         }
-        const keys = fs25.readdirSync(keysDir).filter(
-          (f) => fs25.statSync(path23.join(keysDir, f)).isDirectory()
+        const keys = fs26.readdirSync(keysDir).filter(
+          (f) => fs26.statSync(path24.join(keysDir, f)).isDirectory()
         );
         for (const key of keys) {
           const stateManager2 = new InstanceStateManager(projectRoot, key);
@@ -376532,7 +376538,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs25.rmSync(keysDir, { recursive: true, force: true });
+          fs26.rmSync(keysDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -376697,8 +376703,8 @@ import { render as render9, Text as Text11, Box as Box10, useApp as useApp6 } fr
 import Spinner6 from "ink-spinner";
 // src/lib/update.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 var BINARIES_BASE_URL = "https://binaries.specific.dev/cli";
 function compareVersions(a, b) {
   const partsA = a.split(".").map(Number);
@@ -376712,7 +376718,7 @@ function compareVersions(a, b) {
   return 0;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.102";
+  const currentVersion = "0.1.103";
   const response = await fetch(`${BINARIES_BASE_URL}/latest?t=${Date.now()}`);
   if (!response.ok) {
     throw new Error(`Failed to check for updates: HTTP ${response.status}`);
@@ -376726,9 +376732,9 @@ function getCurrentBinaryPath() {
 }
 function isBinaryWritable() {
   const binaryPath = getCurrentBinaryPath();
-  const dir = path24.dirname(binaryPath);
+  const dir = path25.dirname(binaryPath);
   try {
-    fs26.accessSync(dir, fs26.constants.W_OK);
+    fs27.accessSync(dir, fs27.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -376736,24 +376742,24 @@ function isBinaryWritable() {
 }
 async function performUpdate(version, onProgress) {
   const binaryPath = getCurrentBinaryPath();
-  const binaryDir = path24.dirname(binaryPath);
-  const tempPath = path24.join(binaryDir, `.specific-update-${process.pid}`);
+  const binaryDir = path25.dirname(binaryPath);
+  const tempPath = path25.join(binaryDir, `.specific-update-${process.pid}`);
   try {
     const { platform: platform3, arch: arch3 } = getPlatformInfo();
     const url = `${BINARIES_BASE_URL}/${version}/specific-${platform3}-${arch3}`;
     await downloadFile(url, tempPath, onProgress);
-    const stat4 = fs26.statSync(tempPath);
+    const stat4 = fs27.statSync(tempPath);
     if (stat4.size === 0) {
       throw new Error("Downloaded binary is empty");
     }
-    fs26.chmodSync(tempPath, 493);
+    fs27.chmodSync(tempPath, 493);
     onProgress?.({ phase: "finalizing" });
-    fs26.unlinkSync(binaryPath);
-    fs26.renameSync(tempPath, binaryPath);
+    fs27.unlinkSync(binaryPath);
+    fs27.renameSync(tempPath, binaryPath);
   } catch (error) {
     try {
-      if (fs26.existsSync(tempPath)) {
-        fs26.unlinkSync(tempPath);
+      if (fs27.existsSync(tempPath)) {
+        fs27.unlinkSync(tempPath);
       }
     } catch {
     }
@@ -376763,21 +376769,21 @@ async function performUpdate(version, onProgress) {
 // src/lib/background-update.ts
 import { spawn as spawn9 } from "child_process";
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 import * as os6 from "os";
-var SPECIFIC_DIR = path25.join(os6.homedir(), ".specific");
-var RATE_LIMIT_FILE = path25.join(SPECIFIC_DIR, "last-update-check");
-var LOCK_FILE = path25.join(SPECIFIC_DIR, "update.lock");
+var SPECIFIC_DIR = path26.join(os6.homedir(), ".specific");
+var RATE_LIMIT_FILE = path26.join(SPECIFIC_DIR, "last-update-check");
+var LOCK_FILE = path26.join(SPECIFIC_DIR, "update.lock");
 var RATE_LIMIT_MS = 60 * 60 * 1e3;
 var STALE_LOCK_MS = 10 * 60 * 1e3;
 function writeCheckTimestamp() {
-  fs27.mkdirSync(SPECIFIC_DIR, { recursive: true });
-  fs27.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
+  fs28.mkdirSync(SPECIFIC_DIR, { recursive: true });
+  fs28.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
 }
 function isRateLimited() {
   try {
-    const content = fs27.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
+    const content = fs28.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
     const lastCheck = parseInt(content, 10);
     if (isNaN(lastCheck)) return false;
     return Date.now() - lastCheck < RATE_LIMIT_MS;
@@ -376980,7 +376986,7 @@ async function projectListCommand() {
 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.102").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.103").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").addHelpText("after", `
 Examples:
   $ specific init