@specific.dev/cli 0.1.126 → 0.1.128

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();
@@ -370015,7 +370209,6 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     }
   };
 }
-var execFileAsync = promisify(execFile);
 var InstanceStateManager = class {
   stateDir;
   statePath;
@@ -370107,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();
@@ -370117,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;
       }
@@ -370146,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);
       }
     }
   }
@@ -370228,6 +370438,32 @@ 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");
@@ -370266,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));
@@ -370574,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 });
@@ -370600,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,
@@ -370610,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 });
     }
   };
 }
@@ -370636,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();
@@ -370822,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 });
     }
   };
 }
@@ -370856,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();
@@ -371190,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"],
     [
@@ -371208,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",
@@ -371225,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 () => {
     }
@@ -371244,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();
@@ -371346,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) {
@@ -371368,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,
@@ -371376,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) {
@@ -371430,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);
     }
   }
@@ -371478,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}`);
     }
@@ -371563,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));
@@ -371677,41 +371938,80 @@ 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);
+    let active = false;
+    let errored = false;
     remote.once("data", (firstChunk) => {
       this.pool.delete(remote);
+      active = true;
       this.pipeToLocal(remote, firstChunk);
     });
-    let errored = false;
     remote.on("error", (err) => {
       errored = true;
       this.emit("error", err);
     });
-    remote.on("close", () => this.onIdleClose(remote, errored));
+    remote.on("close", () => {
+      if (this.closed)
+        return;
+      if (active) {
+        this.fillPool();
+        return;
+      }
+      this.pool.delete(remote);
+      if (errored && this.pool.size === 0) {
+        this.reconnect();
+      } else {
+        this.fillPool();
+      }
+    });
   }
   pipeToLocal(remote, firstChunk) {
-    const local = net6.connect({ host: "127.0.0.1", port: this.localPort }, () => {
-      local.write(firstChunk);
+    let buffered = firstChunk;
+    const HEADER_END = Buffer.from("\r\n\r\n");
+    const MAX_HEADER_BYTES = 64 * 1024;
+    const flush = (end) => {
+      const headers = buffered.subarray(0, end + HEADER_END.length);
+      const body = buffered.subarray(end + HEADER_END.length);
+      const rewritten = this.rewriteDevOriginHeaders(headers);
+      const request2 = body.length > 0 ? Buffer.concat([rewritten, body]) : rewritten;
+      this.openLocal(remote, request2);
+    };
+    const initial = buffered.indexOf(HEADER_END);
+    if (initial !== -1) {
+      flush(initial);
+      return;
+    }
+    const onData = (chunk) => {
+      buffered = Buffer.concat([buffered, chunk]);
+      const end = buffered.indexOf(HEADER_END);
+      if (end !== -1) {
+        remote.off("data", onData);
+        flush(end);
+      } else if (buffered.length > MAX_HEADER_BYTES) {
+        remote.off("data", onData);
+        remote.destroy();
+      }
+    };
+    remote.on("data", onData);
+  }
+  openLocal(remote, request2) {
+    const local = net7.connect({ host: "127.0.0.1", port: this.localPort }, () => {
+      local.write(request2);
       remote.pipe(local);
       local.pipe(remote);
     });
     local.on("error", () => remote.destroy());
-    remote.on("close", () => {
-      if (!this.closed)
-        this.fillPool();
-    });
   }
-  onIdleClose(remote, errored) {
-    if (!this.pool.delete(remote) || this.closed)
-      return;
-    if (errored) {
-      if (this.pool.size === 0)
-        this.reconnect();
-    } else {
-      this.fillPool();
-    }
+  rewriteDevOriginHeaders(headers) {
+    const target = `localhost:${this.localPort}`;
+    const text = headers.toString("latin1");
+    let out = text.replace(/^Host:[^\r\n]*\r\n/im, `Host: ${target}\r
+`);
+    out = out.replace(/^Origin:[^\r\n]*\r\n/im, `Origin: http://${target}\r
+`);
+    return Buffer.from(out, "latin1");
   }
   async reconnect() {
     this.emit("close");
@@ -371946,21 +372246,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 {
         }
       }
@@ -372114,21 +372426,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 {
           }
         }
@@ -372342,6 +372666,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)}`
@@ -373383,7 +373714,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.126",
+      cli_version: "0.1.128",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId()
@@ -373701,7 +374032,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";
@@ -373715,7 +374046,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()) {
@@ -373724,7 +374055,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 {
@@ -373829,15 +374160,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;
 }
@@ -374921,11 +375252,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);
     };
@@ -377487,7 +377820,7 @@ function compareVersions(a, b) {
   return 0;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.126";
+  const currentVersion = "0.1.128";
   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}`);
@@ -377757,7 +378090,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.126").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.128").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