@specific.dev/cli 0.1.125 → 0.1.127

package/dist/cli.js

@@ -185179,25 +185179,26 @@ var chokidar_default = { watch, FSWatcher };
 var import_code_frame = __toESM(require_lib2(), 1);
 import * as fs5 from "fs";
 import * as path5 from "path";
-import * as net from "net";
+import * as net2 from "net";
 import { spawn } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
 import * as os2 from "os";
 import { createReadStream } from "fs";
 import { createTarExtractor, extractTo } from "tar-vern";
+import * as net from "net";
+import { execFile } from "child_process";
+import { promisify } from "util";
 import { spawn as spawn2 } from "child_process";
 import { readFile, writeFile } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import * as fs6 from "fs";
 import * as path6 from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
 import * as http from "http";
 import * as fs7 from "fs";
 import * as path7 from "path";
 import { fileURLToPath } from "url";
-import * as net2 from "net";
+import * as net3 from "net";
 import * as fs8 from "fs";
 import * as path9 from "path";
 import { spawn as spawn3 } from "child_process";
@@ -185207,7 +185208,7 @@ import * as path8 from "path";
 import * as crypto from "crypto";
 import * as http2 from "http";
 import * as crypto2 from "crypto";
-import * as net3 from "net";
+import * as net4 from "net";
 import * as fs9 from "fs";
 import * as path10 from "path";
 import { spawn as spawn4 } from "child_process";
@@ -185217,14 +185218,14 @@ 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 { spawn as spawn5 } from "child_process";
+import * as net6 from "net";
 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 * as net7 from "node:net";
 import { EventEmitter as EventEmitter22 } from "events";
 import { execSync as execSync2 } from "child_process";
 import * as path15 from "path";
@@ -369275,14 +369276,22 @@ var temporalBinary = {
   stripComponents: 0,
   executables: ["temporal"]
 };
-function killProcess(proc) {
+function killProcess(proc, opts = {}) {
   return new Promise((resolve52) => {
     if (proc.killed || proc.exitCode !== null) {
       resolve52();
       return;
     }
     proc.once("exit", () => resolve52());
-    proc.kill("SIGKILL");
+    if (opts.detached && proc.pid) {
+      try {
+        process.kill(-proc.pid, "SIGKILL");
+      } catch {
+        proc.kill("SIGKILL");
+      }
+    } else {
+      proc.kill("SIGKILL");
+    }
   });
 }
 function killProcessGroup(pid) {
@@ -369291,6 +369300,143 @@ function killProcessGroup(pid) {
   } catch {
   }
 }
+var execFileAsync = promisify(execFile);
+function isPortInUse(host, port) {
+  return new Promise((resolve52) => {
+    const socket = new net.Socket();
+    socket.setTimeout(1e3);
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve52(true);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve52(false);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve52(false);
+    });
+    socket.connect(port, host);
+  });
+}
+async function waitForPortFree(host, port, timeoutMs = 3e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!await isPortInUse(host, port)) return true;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return !await isPortInUse(host, port);
+}
+async function getListenersOnPort(port) {
+  let pids = [];
+  try {
+    const { stdout } = await execFileAsync(
+      "lsof",
+      ["-i", `:${port}`, "-sTCP:LISTEN", "-t"],
+      { timeout: 5e3 }
+    );
+    pids = stdout.trim().split("\n").map((l) => parseInt(l.trim(), 10)).filter((n) => !isNaN(n));
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const pid of pids) {
+    results.push({ pid, command: await resolveCommand(pid) });
+  }
+  return results;
+}
+async function resolveCommand(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ps",
+      ["-p", String(pid), "-o", "command="],
+      { timeout: 1e3 }
+    );
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function reclaimSpecificOrphanOnPort(port) {
+  const listeners = await getListenersOnPort(port);
+  let killed = false;
+  for (const { pid, command } of listeners) {
+    if (!isOwnedBySpecific(command)) continue;
+    try {
+      process.kill(-pid, "SIGKILL");
+      killed = true;
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+        killed = true;
+      } catch {
+      }
+    }
+  }
+  return killed;
+}
+function isOwnedBySpecific(argv) {
+  return argv.includes("/.specific/bin/") || argv.includes("/.burrito/electric_");
+}
+async function killSpecificProcessesReferencing(needle) {
+  if (!needle) return 0;
+  let stdout = "";
+  try {
+    const result = await execFileAsync("ps", ["-A", "-o", "pid=,command="], {
+      timeout: 5e3,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    stdout = result.stdout;
+  } catch {
+    return 0;
+  }
+  const self2 = process.pid;
+  const candidates = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    const space = line.indexOf(" ");
+    if (space <= 0) continue;
+    const pid = parseInt(line.slice(0, space), 10);
+    if (isNaN(pid) || pid === self2) continue;
+    const command = line.slice(space + 1);
+    if (!isOwnedBySpecific(command)) continue;
+    if (command.includes(needle) || await processOpensPathUnder(pid, needle)) {
+      candidates.push(pid);
+    }
+  }
+  let killed = 0;
+  for (const pid of candidates) {
+    try {
+      process.kill(-pid, "SIGKILL");
+      killed++;
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+        killed++;
+      } catch {
+      }
+    }
+  }
+  return killed;
+}
+async function processOpensPathUnder(pid, prefix) {
+  try {
+    const { stdout } = await execFileAsync("lsof", ["-p", String(pid), "-F", "n"], {
+      timeout: 3e3,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    for (const raw of stdout.split("\n")) {
+      if (raw.length > 1 && raw[0] === "n" && raw.slice(1).startsWith(prefix)) {
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
 async function startPostgres(pg, port, dataDir, onProgress) {
   const binary = await ensureBinary(postgresBinary, void 0, onProgress);
   const dbDataPath = path5.join(process.cwd(), dataDir, pg.name);
@@ -369299,6 +369445,7 @@ async function startPostgres(pg, port, dataDir, onProgress) {
   const password = "postgres";
   const libraryEnv = getLibraryEnv(binary);
   const env2 = { ...process.env, ...libraryEnv };
+  reclaimOrphanedPostmaster(dbDataPath);
   const pgConfPath = path5.join(dbDataPath, "postgresql.conf");
   const dataValid = fs5.existsSync(pgConfPath);
   if (!dataValid) {
@@ -369314,6 +369461,10 @@ async function startPostgres(pg, port, dataDir, onProgress) {
     } catch {
     }
   }
+  if (await isPortInUse(host, port)) {
+    await reclaimSpecificOrphanOnPort(port);
+    await waitForPortFree(host, port, 1e3);
+  }
   const postgres = spawn(
     binary.executables["postgres"],
     [
@@ -369332,9 +369483,11 @@ async function startPostgres(pg, port, dataDir, onProgress) {
     ],
     {
       stdio: ["ignore", "pipe", "pipe"],
-      env: env2
+      env: env2,
+      detached: true
     }
   );
+  postgres.unref();
   pipeProcess("postgres", postgres);
   await Promise.race([
     waitForTcpPort(host, port),
@@ -369358,21 +369511,28 @@ async function startPostgres(pg, port, dataDir, onProgress) {
     dbName: pg.name,
     url: `postgres://${user}:${password}@${host}:${port}/${pg.name}`,
     pid: postgres.pid,
+    detached: true,
     async stop() {
-      return killProcess(postgres);
+      return killProcess(postgres, { detached: true });
     }
   };
 }
 async function startRedis(redis, port, onProgress) {
   const binary = await ensureBinary(redisBinary, void 0, onProgress);
   const host = "127.0.0.1";
+  if (await isPortInUse(host, port)) {
+    await reclaimSpecificOrphanOnPort(port);
+    await waitForPortFree(host, port, 1e3);
+  }
   const redisProc = spawn(
     binary.executables["redis-server"],
     ["--port", String(port), "--bind", host, "--daemonize", "no"],
     {
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
     }
   );
+  redisProc.unref();
   pipeProcess("redis", redisProc);
   await waitForTcpPort(host, port);
   return {
@@ -369385,8 +369545,9 @@ async function startRedis(redis, port, onProgress) {
     dbName: redis.name,
     url: `redis://${host}:${port}`,
     pid: redisProc.pid,
+    detached: true,
     async stop() {
-      return killProcess(redisProc);
+      return killProcess(redisProc, { detached: true });
     }
   };
 }
@@ -369474,6 +369635,39 @@ async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
     proc.stdin?.end();
   });
 }
+function reclaimOrphanedPostmaster(dbDataPath) {
+  const pidFile = path5.join(dbDataPath, "postmaster.pid");
+  if (!fs5.existsSync(pidFile)) return;
+  let pid;
+  try {
+    const firstLine = fs5.readFileSync(pidFile, "utf-8").split("\n")[0] ?? "";
+    pid = parseInt(firstLine.trim(), 10);
+  } catch {
+    return;
+  }
+  if (isNaN(pid) || pid <= 0) return;
+  let alive = false;
+  try {
+    process.kill(pid, 0);
+    alive = true;
+  } catch (e) {
+    alive = e.code !== "ESRCH";
+  }
+  if (alive) {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+  try {
+    fs5.unlinkSync(pidFile);
+  } catch {
+  }
+}
 async function waitForTcpPort(host, port, timeoutMs = 3e4) {
   const startTime = Date.now();
   while (Date.now() - startTime < timeoutMs) {
@@ -369487,7 +369681,7 @@ async function waitForTcpPort(host, port, timeoutMs = 3e4) {
 }
 function checkTcpPort(host, port) {
   return new Promise((resolve52) => {
-    const socket = new net.Socket();
+    const socket = new net2.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
@@ -369882,31 +370076,59 @@ function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpo
   }
   return resolved;
 }
-function resolveEnvForExec(env2, resources, secrets, configs) {
+function resolveEnvForExec(env2, resources, secrets, configs, runningContext) {
   if (!env2) {
     return { env: {}, missingSecrets: [], missingConfigs: [] };
   }
   const resolved = {};
   const missingSecrets = [];
   const missingConfigs = [];
+  const canResolveRef = (ref) => {
+    if (!runningContext) return false;
+    switch (ref.type) {
+      case "port":
+        return runningContext.servicePort !== void 0;
+      case "endpoint":
+        return runningContext.currentServicePorts !== void 0;
+      case "service": {
+        if (!runningContext.serviceEndpoints) return false;
+        if (ref.attribute === "public_url" && !runningContext.publicUrls) return false;
+        return true;
+      }
+      case "volume":
+        return false;
+      default:
+        return true;
+    }
+  };
+  const isSkippableType = (type) => type === "port" || type === "endpoint" || type === "service" || type === "volume";
   for (const [key, value] of Object.entries(env2)) {
     if (typeof value === "string") {
       resolved[key] = value;
       continue;
     }
-    if (value.type === "port" || value.type === "endpoint" || value.type === "service" || value.type === "volume") {
+    if (isSkippableType(value.type) && !canResolveRef(value)) {
       continue;
     }
     if (value.type === "interpolated") {
-      const hasSkippableRef = value.parts.some(
-        (part) => part.type === "ref" && (part.ref.type === "port" || part.ref.type === "endpoint" || part.ref.type === "service" || part.ref.type === "volume")
+      const hasUnresolvableRef = value.parts.some(
+        (part) => part.type === "ref" && isSkippableType(part.ref.type) && !canResolveRef(part.ref)
       );
-      if (hasSkippableRef) {
+      if (hasUnresolvableRef) {
         continue;
       }
     }
     try {
-      resolved[key] = resolveEnvValue(value, resources, secrets, configs);
+      resolved[key] = resolveEnvValue(
+        value,
+        resources,
+        secrets,
+        configs,
+        runningContext?.servicePort,
+        runningContext?.serviceEndpoints,
+        runningContext?.currentServicePorts,
+        runningContext?.publicUrls
+      );
     } catch (err) {
       if (err instanceof MissingSecretError) {
         missingSecrets.push({ name: err.secretName, envVar: key });
@@ -369987,7 +370209,6 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     }
   };
 }
-var execFileAsync = promisify(execFile);
 var InstanceStateManager = class {
   stateDir;
   statePath;
@@ -370079,8 +370300,20 @@ var InstanceStateManager = class {
       releaseLock();
     }
   }
+  /**
+   * Kill every Specific-owned process (postgres, redis, electric, temporal,
+   * drizzle-gateway) whose command line references this key's data
+   * directory. This is the safety net for when state.json is missing or
+   * incomplete — the port allocator can pick a different block on restart,
+   * so port-based cleanup alone isn't enough. We identify orphans by their
+   * data-dir/config-dir argument, which is stable across runs.
+   */
+  async sweepKeyDirOrphans() {
+    await killSpecificProcessesReferencing(this.stateDir);
+  }
   async cleanStaleState() {
     if (!fs6.existsSync(this.statePath)) {
+      await this.sweepKeyDirOrphans();
       return false;
     }
     const releaseLock = await this.acquireLock();
@@ -370089,6 +370322,7 @@ var InstanceStateManager = class {
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
         await this.killOrphanedProcesses(state);
+        await this.sweepKeyDirOrphans();
         fs6.unlinkSync(this.statePath);
         return true;
       }
@@ -370118,18 +370352,22 @@ var InstanceStateManager = class {
       }
     }
     for (const db of Object.values(state.databases)) {
-      if (db.syncUrl) {
-        try {
-          const url = new URL(db.syncUrl);
-          const port = parseInt(url.port, 10);
-          if (!isNaN(port)) {
-            const pid = await findPidOnPort(port);
-            if (pid !== void 0) {
-              process.kill(pid, "SIGKILL");
-            }
-          }
-        } catch {
-        }
+      killTrackedProcess(db.pid, db.detached, this.isProcessRunning.bind(this));
+      if (db.port) {
+        await reclaimSpecificOrphanOnPort(db.port);
+      }
+    }
+    for (const aux of Object.values(state.electric ?? {})) {
+      killTrackedProcess(aux.pid, aux.detached, this.isProcessRunning.bind(this));
+      if (aux.port) {
+        await reclaimSpecificOrphanOnPort(aux.port);
+      }
+    }
+    if (state.drizzleGateway) {
+      const dg = state.drizzleGateway;
+      killTrackedProcess(dg.pid, dg.detached, this.isProcessRunning.bind(this));
+      if (dg.port) {
+        await reclaimSpecificOrphanOnPort(dg.port);
       }
     }
   }
@@ -370200,6 +370438,45 @@ var InstanceStateManager = class {
       releaseLock();
     }
   }
+  async registerElectric(databaseName, info) {
+    if (!this.ownsInstances) {
+      throw new Error("Cannot register Electric: not the owner");
+    }
+    const releaseLock = await this.acquireLock();
+    try {
+      const state = this.readState();
+      state.electric = { ...state.electric ?? {}, [databaseName]: info };
+      this.writeStateAtomic(state);
+    } finally {
+      releaseLock();
+    }
+  }
+  async registerDrizzleGateway(info) {
+    if (!this.ownsInstances) {
+      throw new Error("Cannot register Drizzle Gateway: not the owner");
+    }
+    const releaseLock = await this.acquireLock();
+    try {
+      const state = this.readState();
+      state.drizzleGateway = info;
+      this.writeStateAtomic(state);
+    } finally {
+      releaseLock();
+    }
+  }
+  async setPublicUrls(publicUrls) {
+    if (!this.ownsInstances) {
+      throw new Error("Cannot set public URLs: not the owner");
+    }
+    const releaseLock = await this.acquireLock();
+    try {
+      const state = this.readState();
+      state.publicUrls = publicUrls;
+      this.writeStateAtomic(state);
+    } finally {
+      releaseLock();
+    }
+  }
   async releaseOwnership() {
     if (!this.ownsInstances) {
       return;
@@ -370225,17 +370502,15 @@ var InstanceStateManager = class {
     fs6.renameSync(tmpPath, this.statePath);
   }
 };
-async function findPidOnPort(port) {
+function killTrackedProcess(pid, detached, isProcessRunning) {
+  if (!pid || !isProcessRunning(pid)) return;
   try {
-    const { stdout } = await execFileAsync(
-      "lsof",
-      ["-i", `:${port}`, "-t", "-sTCP:LISTEN"],
-      { timeout: 5e3 }
-    );
-    const pid = parseInt(stdout.trim().split("\n")[0], 10);
-    return isNaN(pid) ? void 0 : pid;
+    if (detached) {
+      process.kill(-pid, "SIGKILL");
+    } else {
+      process.kill(pid, "SIGKILL");
+    }
   } catch {
-    return void 0;
   }
 }
 var __dirname = path7.dirname(fileURLToPath(import.meta.url));
@@ -370533,21 +370808,15 @@ async function startElectric(postgres, port, dataDir, options2) {
   );
   const secret = generateRandomString(32);
   const host = "127.0.0.1";
-  if (await checkTcpPort2(host, port)) {
-    let freed = false;
-    for (let i = 0; i < 30; i++) {
-      await sleep2(100);
-      if (!await checkTcpPort2(host, port)) {
-        freed = true;
-        break;
-      }
-    }
+  if (await isPortInUse(host, port)) {
+    await reclaimSpecificOrphanOnPort(port);
+    const freed = await waitForPortFree(host, port, 3e3);
     if (!freed) {
       throw new Error(
-        `Electric port ${port} is already in use. This may be an orphaned process from a previous session \u2014 find it with \`lsof -i :${port}\` and kill it, then retry.`
+        `Electric port ${port} is already in use by a non-Specific process. Find it with \`lsof -i :${port}\` and kill it, then retry.`
       );
     }
-    writeLog("electric", `Port ${port} was occupied but is now free`);
+    writeLog("electric", `Port ${port} was occupied but has been reclaimed`);
   }
   const storageDir = path9.join(process.cwd(), dataDir, `electric-${postgres.name}`);
   fs8.rmSync(storageDir, { recursive: true, force: true });
@@ -370559,6 +370828,7 @@ async function startElectric(postgres, port, dataDir, options2) {
   writeLog("electric", `Binary: ${binary.executables["electric"]}`);
   const electric = spawn3(binary.executables["electric"], [], {
     stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
     env: {
       ...process.env,
       DATABASE_URL: postgres.url,
@@ -370569,16 +370839,18 @@ async function startElectric(postgres, port, dataDir, options2) {
       ELECTRIC_STORAGE: "MEMORY"
     }
   });
+  electric.unref();
   pipeProcess("electric", electric);
   await waitForTcpPort2(host, port);
   return {
     databaseName: postgres.name,
     pid: electric.pid,
+    detached: true,
     port,
     url: `http://${host}:${port}`,
     secret,
     async stop() {
-      return killProcess(electric);
+      return killProcess(electric, { detached: true });
     }
   };
 }
@@ -370595,7 +370867,7 @@ async function waitForTcpPort2(host, port, timeoutMs = 3e4) {
 }
 function checkTcpPort2(host, port) {
   return new Promise((resolve52) => {
-    const socket = new net2.Socket();
+    const socket = new net3.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
@@ -370781,22 +371053,29 @@ async function startDrizzleGateway(postgresInstances, port, configDir, options2)
     "drizzle-gateway",
     `Binary: ${binary.executables["drizzle-gateway"]}`
   );
+  if (await isPortInUse(host, port)) {
+    await reclaimSpecificOrphanOnPort(port);
+    await waitForPortFree(host, port, 1e3);
+  }
   const drizzleGateway = spawn4(binary.executables["drizzle-gateway"], [], {
     stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
     env: {
       ...process.env,
       STORE_PATH: drizzleConfigDir,
       PORT: String(port)
     }
   });
+  drizzleGateway.unref();
   pipeProcess("drizzle-gateway", drizzleGateway);
   await waitForTcpPort3(host, port);
   return {
     port,
     url: `http://${host}:${port}`,
     pid: drizzleGateway.pid,
+    detached: true,
     async stop() {
-      return killProcess(drizzleGateway);
+      return killProcess(drizzleGateway, { detached: true });
     }
   };
 }
@@ -370815,7 +371094,7 @@ async function waitForTcpPort3(host, port, timeoutMs = 3e4) {
 }
 function checkTcpPort3(host, port) {
   return new Promise((resolve52) => {
-    const socket = new net3.Socket();
+    const socket = new net4.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
@@ -371149,6 +371428,12 @@ async function startTemporalDevServer(temporals, grpcPort, uiPort, dataDir, onPr
   }
   const host = "127.0.0.1";
   const namespaceArgs = temporals.flatMap((t) => ["--namespace", t.name]);
+  for (const p of [grpcPort, uiPort]) {
+    if (await isPortInUse(host, p)) {
+      await reclaimSpecificOrphanOnPort(p);
+      await waitForPortFree(host, p, 1e3);
+    }
+  }
   const proc = spawn5(
     binary.executables["temporal"],
     [
@@ -371167,12 +371452,14 @@ async function startTemporalDevServer(temporals, grpcPort, uiPort, dataDir, onPr
       "pretty"
     ],
     {
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
     }
   );
+  proc.unref();
   pipeProcess("temporal", proc);
   await waitForTcpPort4(host, grpcPort);
-  const stopServer = () => killProcess(proc);
+  const stopServer = () => killProcess(proc, { detached: true });
   const instances = temporals.map((temporal, i) => ({
     name: temporal.name,
     type: "temporal",
@@ -371184,6 +371471,7 @@ async function startTemporalDevServer(temporals, grpcPort, uiPort, dataDir, onPr
     url: `${host}:${grpcPort}`,
     uiPort,
     pid: i === 0 ? proc.pid : void 0,
+    detached: i === 0 ? true : void 0,
     // Only the first instance owns the server lifecycle
     stop: i === 0 ? stopServer : async () => {
     }
@@ -371203,7 +371491,7 @@ async function waitForTcpPort4(host, port, timeoutMs = 3e4) {
 }
 function checkTcpPort4(host, port) {
   return new Promise((resolve52) => {
-    const socket = new net4.Socket();
+    const socket = new net5.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
@@ -371305,6 +371593,8 @@ async function startResources(options2) {
       dbName: instance.dbName,
       url: instance.url
     };
+    if (instance.pid !== void 0) dbState.pid = instance.pid;
+    if (instance.detached) dbState.detached = true;
     if (instance.reshapeEnabled) {
       dbState.reshapeEnabled = true;
       if (instance.reshapeSearchPath) {
@@ -371327,7 +371617,7 @@ async function startResources(options2) {
     startedResources.push(instance);
     callbacks.onResourceReady?.(redis.name, instance);
     log(`Redis "${redis.name}" ready`);
-    await stateManager.registerDatabase(redis.name, {
+    const redisState = {
       engine: "redis",
       port: instance.port,
       host: instance.host,
@@ -371335,7 +371625,10 @@ async function startResources(options2) {
       password: instance.password,
       dbName: instance.dbName,
       url: instance.url
-    });
+    };
+    if (instance.pid !== void 0) redisState.pid = instance.pid;
+    if (instance.detached) redisState.detached = true;
+    await stateManager.registerDatabase(redis.name, redisState);
   }
   for (const storage of storageConfigs) {
     if (signal?.cancelled) {
@@ -371389,6 +371682,8 @@ async function startResources(options2) {
         dbName: "",
         url: instance.url
       };
+      if (instance.pid !== void 0) dbState.pid = instance.pid;
+      if (instance.detached) dbState.detached = true;
       await stateManager.registerDatabase(instance.name, dbState);
     }
   }
@@ -371437,6 +371732,13 @@ async function startResources(options2) {
         syncUrl: electricInstance.url,
         syncSecret: electricInstance.secret
       });
+      if (electricInstance.pid !== void 0) {
+        await stateManager.registerElectric(pgName, {
+          port: electricInstance.port,
+          pid: electricInstance.pid,
+          detached: electricInstance.detached
+        });
+      }
       callbacks.onElectricReady?.(pgName, electricInstance);
       log(`Electric sync for "${pgName}" ready at ${electricInstance.url}`);
     }
@@ -371522,7 +371824,7 @@ var BlockPortAllocator = class _BlockPortAllocator {
 };
 function isPortAvailable(port) {
   return new Promise((resolve52) => {
-    const server = net5.createServer();
+    const server = net6.createServer();
     server.once("error", () => resolve52(false));
     server.once("listening", () => {
       server.close(() => resolve52(true));
@@ -371636,7 +371938,7 @@ var TunnelClientImpl = class extends EventEmitter2 {
     }
   }
   addPoolConnection() {
-    const remote = net6.connect({ host: this.tunnelHost, port: this.info.port });
+    const remote = net7.connect({ host: this.tunnelHost, port: this.info.port });
     remote.setKeepAlive(true, 3e4);
     this.pool.add(remote);
     remote.once("data", (firstChunk) => {
@@ -371651,7 +371953,7 @@ var TunnelClientImpl = class extends EventEmitter2 {
     remote.on("close", () => this.onIdleClose(remote, errored));
   }
   pipeToLocal(remote, firstChunk) {
-    const local = net6.connect({ host: "127.0.0.1", port: this.localPort }, () => {
+    const local = net7.connect({ host: "127.0.0.1", port: this.localPort }, () => {
       local.write(firstChunk);
       remote.pipe(local);
       local.pipe(remote);
@@ -371905,21 +372207,33 @@ var DevEnvironment = class extends TypedEventEmitter {
     for (const electric of this.electricInstances) {
       if (electric.pid) {
         try {
-          process.kill(electric.pid, "SIGKILL");
+          if (electric.detached) {
+            process.kill(-electric.pid, "SIGKILL");
+          } else {
+            process.kill(electric.pid, "SIGKILL");
+          }
         } catch {
         }
       }
     }
     if (this.drizzleGateway?.pid) {
       try {
-        process.kill(this.drizzleGateway.pid, "SIGKILL");
+        if (this.drizzleGateway.detached) {
+          process.kill(-this.drizzleGateway.pid, "SIGKILL");
+        } else {
+          process.kill(this.drizzleGateway.pid, "SIGKILL");
+        }
       } catch {
       }
     }
     for (const resource of this.resources.values()) {
       if (resource.pid) {
         try {
-          process.kill(resource.pid, "SIGKILL");
+          if (resource.detached) {
+            process.kill(-resource.pid, "SIGKILL");
+          } else {
+            process.kill(resource.pid, "SIGKILL");
+          }
         } catch {
         }
       }
@@ -372073,21 +372387,33 @@ var DevEnvironment = class extends TypedEventEmitter {
       for (const electric of this.electricInstances) {
         if (electric.pid) {
           try {
-            process.kill(electric.pid, "SIGKILL");
+            if (electric.detached) {
+              process.kill(-electric.pid, "SIGKILL");
+            } else {
+              process.kill(electric.pid, "SIGKILL");
+            }
           } catch {
           }
         }
       }
       if (this.drizzleGateway?.pid) {
         try {
-          process.kill(this.drizzleGateway.pid, "SIGKILL");
+          if (this.drizzleGateway.detached) {
+            process.kill(-this.drizzleGateway.pid, "SIGKILL");
+          } else {
+            process.kill(this.drizzleGateway.pid, "SIGKILL");
+          }
         } catch {
         }
       }
       for (const resource of this.resources.values()) {
         if (resource.pid) {
           try {
-            process.kill(resource.pid, "SIGKILL");
+            if (resource.detached) {
+              process.kill(-resource.pid, "SIGKILL");
+            } else {
+              process.kill(resource.pid, "SIGKILL");
+            }
           } catch {
           }
         }
@@ -372301,6 +372627,13 @@ var DevEnvironment = class extends TypedEventEmitter {
         );
         this.drizzleGateway = drizzleGateway;
         this.systemLog(`Database viewer ready at ${drizzleGateway.url}`);
+        if (drizzleGateway.pid !== void 0) {
+          await stateManager.registerDrizzleGateway({
+            port: drizzleGateway.port,
+            pid: drizzleGateway.pid,
+            detached: drizzleGateway.detached
+          });
+        }
       } catch (err) {
         this.systemLog(
           `Failed to start database viewer: ${err instanceof Error ? err.message : String(err)}`
@@ -372524,6 +372857,7 @@ Add them to the config block in specific.local`
         publicUrls.set(svc.name, `localhost:${svc.port}`);
       }
     }
+    await stateManager.setPublicUrls(Object.fromEntries(publicUrls));
     const runningServices = [];
     const resolveServiceCwd = (service) => {
       if (service.root)
@@ -373341,7 +373675,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.125",
+      cli_version: "0.1.127",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId()
@@ -373659,7 +373993,7 @@ Valid agents: ${VALID_AGENT_IDS.join(", ")}`
 }
 
 // src/commands/docs.tsx
-import { readFileSync as readFileSync9, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync17 } from "fs";
 import { spawn as spawn6 } from "child_process";
 import { join as join19, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -373673,7 +374007,7 @@ var BETA_REGISTRY = [
 ];
 
 // src/lib/beta/storage.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync16, mkdirSync as mkdirSync13 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync16, mkdirSync as mkdirSync13 } from "fs";
 import { join as join18 } from "path";
 var BETAS_FILE = ".specific/betas.json";
 function loadEnabledBetas(projectDir = process.cwd()) {
@@ -373682,7 +374016,7 @@ function loadEnabledBetas(projectDir = process.cwd()) {
     return [];
   }
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const data = JSON.parse(content);
     return data.enabled ?? [];
   } catch {
@@ -373787,15 +374121,15 @@ function resolveEmbeddedDoc(path27) {
 function resolveFilesystemDoc(path27) {
   if (!path27) {
     const indexPath2 = join19(docsDir, "index.md");
-    return existsSync17(indexPath2) ? readFileSync9(indexPath2, "utf-8") : null;
+    return existsSync17(indexPath2) ? readFileSync10(indexPath2, "utf-8") : null;
   }
   const directPath = join19(docsDir, `${path27}.md`);
   if (existsSync17(directPath)) {
-    return readFileSync9(directPath, "utf-8");
+    return readFileSync10(directPath, "utf-8");
   }
   const indexPath = join19(docsDir, path27, "index.md");
   if (existsSync17(indexPath)) {
-    return readFileSync9(indexPath, "utf-8");
+    return readFileSync10(indexPath, "utf-8");
   }
   return null;
 }
@@ -374879,11 +375213,13 @@ function DevUI({ instanceKey, tunnelEnabled }) {
     };
     process.on("SIGINT", handleSignal);
     process.on("SIGTERM", handleSignal);
+    process.on("SIGHUP", handleSignal);
     process.on("uncaughtException", handleCrash);
     process.on("unhandledRejection", handleCrash);
     return () => {
       process.off("SIGINT", handleSignal);
       process.off("SIGTERM", handleSignal);
+      process.off("SIGHUP", handleSignal);
       process.off("uncaughtException", handleCrash);
       process.off("unhandledRejection", handleCrash);
     };
@@ -376585,7 +376921,7 @@ function startSpinner(text) {
     }
   };
 }
-async function execCommand(serviceName, command, instanceKey = "default") {
+async function execCommand(serviceName, command, instanceKey = "default", options2 = {}) {
   if (command.length === 0) {
     console.error(
       "Error: No command provided. Usage: specific exec <service> -- <command>"
@@ -376723,11 +377059,32 @@ async function execCommand(serviceName, command, instanceKey = "default") {
       }
     }
   }
+  let runningContext;
+  if (existingInstances) {
+    const serviceEndpoints = /* @__PURE__ */ new Map();
+    for (const [name, svcState] of Object.entries(existingInstances.services)) {
+      if (svcState.port !== void 0) {
+        serviceEndpoints.set(name, [
+          { serviceName: name, endpointName: "default", port: svcState.port }
+        ]);
+      }
+    }
+    const selfPort = existingInstances.services[serviceName]?.port;
+    runningContext = { serviceEndpoints };
+    if (selfPort !== void 0) {
+      runningContext.servicePort = selfPort;
+      runningContext.currentServicePorts = /* @__PURE__ */ new Map([["default", selfPort]]);
+    }
+    if (existingInstances.publicUrls) {
+      runningContext.publicUrls = new Map(Object.entries(existingInstances.publicUrls));
+    }
+  }
+  const effectiveEnv = runningContext && service.dev?.env ? { ...service.env, ...service.dev.env } : service.env;
   let resolvedEnv;
   try {
     const secrets = await prepareSecrets(config.secrets);
     const configs = await prepareConfigs(config.configs);
-    const result = resolveEnvForExec(service.env, resources, secrets, configs);
+    const result = resolveEnvForExec(effectiveEnv, resources, secrets, configs, runningContext);
     resolvedEnv = result.env;
     if (result.missingSecrets.length > 0 || result.missingConfigs.length > 0) {
       if (result.missingSecrets.length > 0) {
@@ -376762,7 +377119,9 @@ async function execCommand(serviceName, command, instanceKey = "default") {
   process.on("SIGINT", () => handleSignal("SIGINT"));
   process.on("SIGTERM", () => handleSignal("SIGTERM"));
   let effectiveCwd = process.cwd();
-  if (service.root) {
+  if (options2.cwd) {
+    effectiveCwd = path21.resolve(process.cwd(), options2.cwd);
+  } else if (service.root) {
     effectiveCwd = path21.resolve(process.cwd(), service.root);
   } else if (service.build) {
     const build = config.builds.find((b) => b.name === service.build.name);
@@ -377422,7 +377781,7 @@ function compareVersions(a, b) {
   return 0;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.125";
+  const currentVersion = "0.1.127";
   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}`);
@@ -377692,7 +378051,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.125").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.127").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
@@ -377722,13 +378081,14 @@ Examples:
   $ specific deploy --secret db_url=postgres://... --config domain=app.com`).action((options2) => {
   deployCommand(options2);
 });
-program.command("exec <service> [args...]").description("Run a one-off command with service environment").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").passThroughOptions().addHelpText("after", `
+program.command("exec <service> [args...]").description("Run a one-off command with service environment").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").option("--cwd <path>", "Override working directory (defaults to service.root or build.root)").passThroughOptions().addHelpText("after", `
 Examples:
   $ specific exec api -- npm run migrate
-  $ specific exec worker -- python manage.py shell`).action(async (service, args, options2) => {
+  $ specific exec worker -- python manage.py shell
+  $ specific exec --cwd . api -- npx expo start`).action(async (service, args, options2) => {
   const filteredArgs = args[0] === "--" ? args.slice(1) : args;
   const key = options2.key ?? getDefaultKey();
-  await execCommand(service, filteredArgs, key);
+  await execCommand(service, filteredArgs, key, options2.cwd !== void 0 ? { cwd: options2.cwd } : {});
 });
 program.command("psql [database] [args...]").description("Connect to a Postgres database").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").passThroughOptions().addHelpText("after", `
 Examples: