@specific.dev/cli 0.1.75 → 0.1.77

package/dist/cli.js

@@ -39,10 +39,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
-import fs6 from "node:fs";
+import fs5 from "node:fs";
 function hasDockerEnv() {
   try {
-    fs6.statSync("/.dockerenv");
+    fs5.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -50,7 +50,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs6.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs5.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -68,7 +68,7 @@ var init_is_docker = __esm({
 });
 
 // node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 function isInsideContainer() {
   if (cachedResult === void 0) {
     cachedResult = hasContainerEnv() || isDocker();
@@ -81,7 +81,7 @@ var init_is_inside_container = __esm({
     init_is_docker();
     hasContainerEnv = () => {
       try {
-        fs7.statSync("/run/.containerenv");
+        fs6.statSync("/run/.containerenv");
         return true;
       } catch {
         return false;
@@ -92,8 +92,8 @@ 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 os5 from "node:os";
-import fs8 from "node:fs";
+import os4 from "node:os";
+import fs7 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"() {
@@ -102,14 +102,14 @@ var init_is_wsl = __esm({
       if (process2.platform !== "linux") {
         return false;
       }
-      if (os5.release().toLowerCase().includes("microsoft")) {
+      if (os4.release().toLowerCase().includes("microsoft")) {
         if (isInsideContainer()) {
           return false;
         }
         return true;
       }
       try {
-        return fs8.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+        return fs7.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
       } catch {
         return false;
       }
@@ -179,7 +179,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 fs9, { constants as fsConstants } from "node:fs/promises";
+import fs8, { 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"() {
@@ -198,14 +198,14 @@ var init_wsl_utils = __esm({
         const configFilePath = "/etc/wsl.conf";
         let isConfigFileExists = false;
         try {
-          await fs9.access(configFilePath, fsConstants.F_OK);
+          await fs8.access(configFilePath, fsConstants.F_OK);
           isConfigFileExists = true;
         } catch {
         }
         if (!isConfigFileExists) {
           return defaultMountPoint;
         }
-        const configContent = await fs9.readFile(configFilePath, { encoding: "utf8" });
+        const configContent = await fs8.readFile(configFilePath, { encoding: "utf8" });
         const parsedMountPoint = parseMountPointFromConfig(configContent);
         if (parsedMountPoint === void 0) {
           return defaultMountPoint;
@@ -224,7 +224,7 @@ var init_wsl_utils = __esm({
       canAccessPowerShellPromise ??= (async () => {
         try {
           const psPath = await powerShellPath2();
-          await fs9.access(psPath, fsConstants.X_OK);
+          await fs8.access(psPath, fsConstants.X_OK);
           return true;
         } catch {
           return false;
@@ -435,7 +435,7 @@ import process8 from "node:process";
 import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import childProcess3 from "node:child_process";
-import fs10, { constants as fsConstants2 } from "node:fs/promises";
+import fs9, { constants as fsConstants2 } from "node:fs/promises";
 function detectArchBinary(binary) {
   if (typeof binary === "string" || Array.isArray(binary)) {
     return binary;
@@ -446,16 +446,16 @@ function detectArchBinary(binary) {
   }
   return archBinary;
 }
-function detectPlatformBinary({ [platform4]: platformBinary }, { wsl } = {}) {
+function detectPlatformBinary({ [platform3]: platformBinary }, { wsl } = {}) {
   if (wsl && is_wsl_default) {
     return detectArchBinary(wsl);
   }
   if (!platformBinary) {
-    throw new Error(`${platform4} is not supported`);
+    throw new Error(`${platform3} is not supported`);
   }
   return detectArchBinary(platformBinary);
 }
-var fallbackAttemptSymbol, __dirname, localXdgOpenPath, platform4, arch, tryEachApp, baseOpen, open, openApp, apps, open_default;
+var fallbackAttemptSymbol, __dirname, localXdgOpenPath, platform3, arch, tryEachApp, baseOpen, open, openApp, apps, open_default;
 var init_open = __esm({
   "node_modules/.pnpm/open@11.0.0/node_modules/open/index.js"() {
     init_wsl_utils();
@@ -467,7 +467,7 @@ var init_open = __esm({
     fallbackAttemptSymbol = Symbol("fallbackAttempt");
     __dirname = import.meta.url ? path5.dirname(fileURLToPath(import.meta.url)) : "";
     localXdgOpenPath = path5.join(__dirname, "xdg-open");
-    ({ platform: platform4, arch } = process8);
+    ({ platform: platform3, arch } = process8);
     tryEachApp = async (apps2, opener) => {
       if (apps2.length === 0) {
         return;
@@ -564,7 +564,7 @@ var init_open = __esm({
       if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
         shouldUseWindowsInWsl = await canAccessPowerShell();
       }
-      if (platform4 === "darwin") {
+      if (platform3 === "darwin") {
         command = "open";
         if (options2.wait) {
           cliArguments.push("--wait-apps");
@@ -578,7 +578,7 @@ var init_open = __esm({
         if (app) {
           cliArguments.push("-a", app);
         }
-      } else if (platform4 === "win32" || shouldUseWindowsInWsl) {
+      } else if (platform3 === "win32" || shouldUseWindowsInWsl) {
         command = await powerShellPath2();
         cliArguments.push(...executePowerShell.argumentsPrefix);
         if (!is_wsl_default) {
@@ -614,11 +614,11 @@ var init_open = __esm({
           const isBundled = !__dirname || __dirname === "/";
           let exeLocalXdgOpen = false;
           try {
-            await fs10.access(localXdgOpenPath, fsConstants2.X_OK);
+            await fs9.access(localXdgOpenPath, fsConstants2.X_OK);
             exeLocalXdgOpen = true;
           } catch {
           }
-          const useSystemXdgOpen = process8.versions.electron ?? (platform4 === "android" || isBundled || !exeLocalXdgOpen);
+          const useSystemXdgOpen = process8.versions.electron ?? (platform3 === "android" || isBundled || !exeLocalXdgOpen);
           command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
         }
         if (appArguments.length > 0) {
@@ -629,7 +629,7 @@ var init_open = __esm({
           childProcessOptions.detached = true;
         }
       }
-      if (platform4 === "darwin" && appArguments.length > 0) {
+      if (platform3 === "darwin" && appArguments.length > 0) {
         cliArguments.push("--args", ...appArguments);
       }
       if (options2.target) {
@@ -754,8 +754,8 @@ var require_dist = __commonJS({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require : $global = this, void 0 === $global || void 0 === $global.Array) throw new Error("no global object found");
       if ("undefined" != typeof module && ($module = module), !$global.fs && $global.require) try {
-        var fs33 = $global.require("fs");
-        "object" == typeof fs33 && null !== fs33 && 0 !== Object.keys(fs33).length && ($global.fs = fs33);
+        var fs32 = $global.require("fs");
+        "object" == typeof fs32 && null !== fs32 && 0 !== Object.keys(fs32).length && ($global.fs = fs32);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183430,13 +183430,11 @@ import { Command } from "commander";
 import React2, { useState, useEffect } from "react";
 import { render as render2, Text as Text2, Box as Box2, useInput, useApp } from "ink";
 import "ink-spinner";
-import * as fs12 from "fs";
+import * as fs11 from "fs";
 import * as path7 from "path";
 
 // src/lib/dev/system-setup.ts
 import { execSync as execSync2 } from "child_process";
-import * as fs4 from "fs";
-import * as os4 from "os";
 import * as path3 from "path";
 
 // src/lib/dev/local-ca.ts
@@ -183472,17 +183470,17 @@ function caInstalledInTrustStore() {
   if (!caFilesExist()) {
     return false;
   }
-  const platform6 = os.platform();
+  const platform5 = os.platform();
   const certPath = path.join(getCADir(), "ca.crt");
   const diskCert = fs.readFileSync(certPath, "utf-8").replace(/\r\n/g, "\n").trim();
   try {
-    if (platform6 === "darwin") {
+    if (platform5 === "darwin") {
       const keychainCert = execSync(
         'security find-certificate -c "Specific Local Development CA" -p /Library/Keychains/System.keychain',
         { encoding: "utf-8" }
       ).replace(/\r\n/g, "\n").trim();
       return keychainCert === diskCert;
-    } else if (platform6 === "linux") {
+    } else if (platform5 === "linux") {
       const trustPaths = [
         "/usr/local/share/ca-certificates/specific-local-ca.crt",
         // Debian/Ubuntu
@@ -183594,15 +183592,15 @@ function removeCA() {
   }
 }
 function getCAInstallCommands(certPath) {
-  const platform6 = os.platform();
-  if (platform6 === "darwin") {
+  const platform5 = os.platform();
+  if (platform5 === "darwin") {
     return [
       // Remove any existing cert with the same CN first — add-trusted-cert
       // silently does nothing if a cert with the same subject already exists.
       'security delete-certificate -c "Specific Local Development CA" /Library/Keychains/System.keychain 2>/dev/null || true',
       `security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${certPath}"`
     ];
-  } else if (platform6 === "linux") {
+  } else if (platform5 === "linux") {
     if (fs.existsSync("/usr/local/share/ca-certificates")) {
       return [
         `cp "${certPath}" /usr/local/share/ca-certificates/specific-local-ca.crt`,
@@ -183621,7 +183619,7 @@ function getCAInstallCommands(certPath) {
     }
     throw new Error("Could not detect Linux certificate trust mechanism");
   }
-  throw new Error(`Unsupported platform: ${platform6}`);
+  throw new Error(`Unsupported platform: ${platform5}`);
 }
 function generateCertificate(domain, keys = []) {
   const caDir = getCADir();
@@ -183667,23 +183665,23 @@ var RESOLVER_FILE_MACOS = "/etc/resolver/spcf.localhost";
 var OLD_RESOLVER_FILE_MACOS = "/etc/resolver/local.spcf.app";
 var RESOLVER_FILE_LINUX = "/etc/systemd/resolved.conf.d/specific-local.conf";
 function resolverConfigExists() {
-  const platform6 = os2.platform();
-  if (platform6 === "darwin") {
+  const platform5 = os2.platform();
+  if (platform5 === "darwin") {
     return fs2.existsSync(RESOLVER_FILE_MACOS);
-  } else if (platform6 === "linux") {
+  } else if (platform5 === "linux") {
     return fs2.existsSync(RESOLVER_FILE_LINUX);
   }
   return false;
 }
 function getResolverInstallCommands(port) {
-  const platform6 = os2.platform();
-  if (platform6 === "darwin") {
+  const platform5 = os2.platform();
+  if (platform5 === "darwin") {
     return [
       "mkdir -p /etc/resolver",
       `rm -f ${OLD_RESOLVER_FILE_MACOS}`,
       `printf "nameserver 127.0.0.1\\nport ${port}\\n" > ${RESOLVER_FILE_MACOS}`
     ];
-  } else if (platform6 === "linux") {
+  } else if (platform5 === "linux") {
     if (fs2.existsSync("/etc/systemd/resolved.conf.d") || fs2.existsSync("/etc/systemd")) {
       return [
         "mkdir -p /etc/systemd/resolved.conf.d",
@@ -183802,7 +183800,7 @@ function performSystemSetup() {
     return;
   }
   try {
-    execPrivileged(commands);
+    execSync2(`sudo sh -c '${commands.join(" && ")}'`, { stdio: "inherit" });
   } catch (err) {
     if (needsGenerate) {
       removeCA();
@@ -183810,43 +183808,14 @@ function performSystemSetup() {
     throw err;
   }
 }
-function execPrivileged(commands) {
-  if (commands.length === 0) return;
-  if (os4.platform() === "darwin") {
-    const scriptPath = path3.join(os4.tmpdir(), "specific-setup.sh");
-    const appPath = path3.join(os4.tmpdir(), "Specific.app");
-    try {
-      fs4.writeFileSync(
-        scriptPath,
-        "#!/bin/sh\nset -e\n" + commands.join("\n") + "\n",
-        { mode: 448 }
-      );
-      execSync2(
-        `osacompile -o '${appPath}' -e 'do shell script "sh ${scriptPath}" with administrator privileges'`
-      );
-      execSync2(`'${appPath}/Contents/MacOS/applet'`, { stdio: "pipe" });
-    } finally {
-      try {
-        fs4.unlinkSync(scriptPath);
-      } catch {
-      }
-      try {
-        fs4.rmSync(appPath, { recursive: true });
-      } catch {
-      }
-    }
-  } else {
-    execSync2(`sudo sh -c '${commands.join(" && ")}'`, { stdio: "inherit" });
-  }
-}
 
 // src/lib/analytics/index.ts
 import { PostHog } from "posthog-node";
-import * as os7 from "os";
+import * as os6 from "os";
 import * as crypto from "crypto";
 
 // src/lib/project/config.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as path4 from "path";
 var PROJECT_ID_FILE = ".specific/project_id";
 var ProjectNotLinkedError = class extends Error {
@@ -183863,10 +183832,10 @@ Run: specific deploy`
 };
 function readProjectId(projectDir = process.cwd()) {
   const projectIdPath = path4.join(projectDir, PROJECT_ID_FILE);
-  if (!fs5.existsSync(projectIdPath)) {
+  if (!fs4.existsSync(projectIdPath)) {
     throw new ProjectNotLinkedError();
   }
-  const projectId = fs5.readFileSync(projectIdPath, "utf-8").trim();
+  const projectId = fs4.readFileSync(projectIdPath, "utf-8").trim();
   if (!projectId) {
     throw new Error(`${PROJECT_ID_FILE} is empty`);
   }
@@ -183874,20 +183843,20 @@ function readProjectId(projectDir = process.cwd()) {
 }
 function hasProjectId(projectDir = process.cwd()) {
   const projectIdPath = path4.join(projectDir, PROJECT_ID_FILE);
-  return fs5.existsSync(projectIdPath);
+  return fs4.existsSync(projectIdPath);
 }
 function writeProjectId(projectId, projectDir = process.cwd()) {
   const specificDir = path4.join(projectDir, ".specific");
-  if (!fs5.existsSync(specificDir)) {
-    fs5.mkdirSync(specificDir, { recursive: true });
+  if (!fs4.existsSync(specificDir)) {
+    fs4.mkdirSync(specificDir, { recursive: true });
   }
-  fs5.writeFileSync(path4.join(specificDir, "project_id"), projectId + "\n");
+  fs4.writeFileSync(path4.join(specificDir, "project_id"), projectId + "\n");
 }
 
 // src/lib/auth/credentials.ts
-import * as fs11 from "fs";
+import * as fs10 from "fs";
 import * as path6 from "path";
-import * as os6 from "os";
+import * as os5 from "os";
 
 // src/lib/auth/errors.ts
 var RefreshTokenExpiredError = class extends Error {
@@ -184468,18 +184437,18 @@ var ApiClient = class {
 
 // src/lib/auth/credentials.ts
 function getUserCredentialsDir() {
-  return path6.join(os6.homedir(), ".specific");
+  return path6.join(os5.homedir(), ".specific");
 }
 function getCredentialsPath() {
   return path6.join(getUserCredentialsDir(), "credentials.json");
 }
 function readUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (!fs11.existsSync(credentialsPath)) {
+  if (!fs10.existsSync(credentialsPath)) {
     return null;
   }
   try {
-    const content = fs11.readFileSync(credentialsPath, "utf-8");
+    const content = fs10.readFileSync(credentialsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -184487,18 +184456,18 @@ function readUserCredentials() {
 }
 function writeUserCredentials(credentials) {
   const dir = getUserCredentialsDir();
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
-  fs11.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs10.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
 function clearUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (fs11.existsSync(credentialsPath)) {
-    fs11.unlinkSync(credentialsPath);
+  if (fs10.existsSync(credentialsPath)) {
+    fs10.unlinkSync(credentialsPath);
   }
 }
 function isLoggedIn() {
@@ -184577,7 +184546,7 @@ function isEnabled() {
 }
 function getAnonymousId() {
   if (anonymousId) return anonymousId;
-  const machineId = `${os7.hostname()}-${os7.userInfo().username}`;
+  const machineId = `${os6.hostname()}-${os6.userInfo().username}`;
   anonymousId = crypto.createHash("sha256").update(machineId).digest("hex").slice(0, 16);
   return anonymousId;
 }
@@ -184624,7 +184593,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.75",
+      cli_version: "0.1.77",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId()
@@ -184661,57 +184630,57 @@ var options = [
 ];
 function isGitProject() {
   const gitPath = path7.join(process.cwd(), ".git");
-  return fs12.existsSync(gitPath);
+  return fs11.existsSync(gitPath);
 }
 function detectExistingAgents() {
   const detected = {};
   const cursorDir = path7.join(process.cwd(), ".cursor");
-  if (fs12.existsSync(cursorDir)) {
+  if (fs11.existsSync(cursorDir)) {
     detected["cursor"] = true;
   }
   const claudeDir = path7.join(process.cwd(), ".claude");
   const claudeMd = path7.join(process.cwd(), "CLAUDE.md");
-  if (fs12.existsSync(claudeDir) || fs12.existsSync(claudeMd)) {
+  if (fs11.existsSync(claudeDir) || fs11.existsSync(claudeMd)) {
     detected["claude"] = true;
   }
   const agentsMd = path7.join(process.cwd(), "AGENTS.md");
-  if (fs12.existsSync(agentsMd)) {
+  if (fs11.existsSync(agentsMd)) {
     detected["codex"] = true;
   }
   return detected;
 }
 function appendOrCreateFile(filePath, content) {
-  if (fs12.existsSync(filePath)) {
-    const existing = fs12.readFileSync(filePath, "utf-8");
+  if (fs11.existsSync(filePath)) {
+    const existing = fs11.readFileSync(filePath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    fs12.writeFileSync(filePath, existing + separator + content + "\n");
+    fs11.writeFileSync(filePath, existing + separator + content + "\n");
     return "modified";
   } else {
-    fs12.writeFileSync(filePath, content + "\n");
+    fs11.writeFileSync(filePath, content + "\n");
     return "created";
   }
 }
 function addToGitignore() {
   const gitignorePath = path7.join(process.cwd(), ".gitignore");
   const entries = [".specific", "specific.local"];
-  if (fs12.existsSync(gitignorePath)) {
-    const existing = fs12.readFileSync(gitignorePath, "utf-8");
+  if (fs11.existsSync(gitignorePath)) {
+    const existing = fs11.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";
-    fs12.writeFileSync(
+    fs11.writeFileSync(
       gitignorePath,
       existing + separator + missingEntries.join("\n") + "\n"
     );
     return "modified";
   } else {
-    fs12.writeFileSync(gitignorePath, entries.join("\n") + "\n");
+    fs11.writeFileSync(gitignorePath, entries.join("\n") + "\n");
     return "created";
   }
 }
@@ -184719,8 +184688,8 @@ function configureClaudeCodePermissions() {
   const claudeDir = path7.join(process.cwd(), ".claude");
   const settingsPath = path7.join(claudeDir, "settings.local.json");
   const permissions = ["Bash(specific docs:*)", "Bash(specific check:*)"];
-  if (fs12.existsSync(settingsPath)) {
-    const existing = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
+  if (fs11.existsSync(settingsPath)) {
+    const existing = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
     const allowList = existing?.permissions?.allow || [];
     const missingPermissions = permissions.filter(
       (p) => !allowList.includes(p)
@@ -184735,39 +184704,39 @@ function configureClaudeCodePermissions() {
       existing.permissions.allow = [];
     }
     existing.permissions.allow.push(...missingPermissions);
-    fs12.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    fs11.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
     return "modified";
   }
-  if (!fs12.existsSync(claudeDir)) {
-    fs12.mkdirSync(claudeDir);
+  if (!fs11.existsSync(claudeDir)) {
+    fs11.mkdirSync(claudeDir);
   }
   const settings = {
     permissions: {
       allow: permissions
     }
   };
-  fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs11.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return "created";
 }
 function createCursorRule() {
   const cursorDir = path7.join(process.cwd(), ".cursor");
   const rulesDir = path7.join(cursorDir, "rules");
   const mdcPath = path7.join(rulesDir, "specific.mdc");
-  if (fs12.existsSync(mdcPath)) {
-    const existing = fs12.readFileSync(mdcPath, "utf-8");
+  if (fs11.existsSync(mdcPath)) {
+    const existing = fs11.readFileSync(mdcPath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
-    fs12.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+    fs11.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
     return "modified";
   }
-  if (!fs12.existsSync(cursorDir)) {
-    fs12.mkdirSync(cursorDir);
+  if (!fs11.existsSync(cursorDir)) {
+    fs11.mkdirSync(cursorDir);
   }
-  if (!fs12.existsSync(rulesDir)) {
-    fs12.mkdirSync(rulesDir);
+  if (!fs11.existsSync(rulesDir)) {
+    fs11.mkdirSync(rulesDir);
   }
-  fs12.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+  fs11.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
   return "created";
 }
 function configureAgents(checked) {
@@ -185010,7 +184979,7 @@ var BETA_REGISTRY = [
 ];
 
 // src/lib/beta/storage.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync6 } from "fs";
 import { join as join7 } from "path";
 var BETAS_FILE = ".specific/betas.json";
 function loadEnabledBetas(projectDir = process.cwd()) {
@@ -185043,7 +185012,7 @@ function saveBetas(enabled, projectDir) {
     mkdirSync6(specificDir, { recursive: true });
   }
   const data = { enabled };
-  writeFileSync6(
+  writeFileSync5(
     join7(projectDir, BETAS_FILE),
     JSON.stringify(data, null, 2) + "\n"
   );
@@ -185110,7 +185079,7 @@ function resolveFilesystemDoc(path30) {
 import React3, { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render3, Text as Text3, Box as Box3 } from "ink";
 import Spinner3 from "ink-spinner";
-import * as fs14 from "fs";
+import * as fs13 from "fs";
 import * as path9 from "path";
 import { execFile as execFile7 } from "child_process";
 
@@ -185982,32 +185951,32 @@ var ExtractionError = class extends Error {
 };
 
 // src/lib/bin/manager.ts
-import * as fs13 from "fs";
+import * as fs12 from "fs";
 import * as path8 from "path";
-import * as os8 from "os";
+import * as os7 from "os";
 import { createReadStream } from "fs";
 import { createTarExtractor, extractTo } from "tar-vern";
 function getLibraryEnv(binary) {
   if (!binary.libraryPath) {
     return {};
   }
-  const platform6 = os8.platform();
-  if (platform6 === "darwin") {
+  const platform5 = os7.platform();
+  if (platform5 === "darwin") {
     return { DYLD_LIBRARY_PATH: binary.libraryPath };
-  } else if (platform6 === "linux") {
+  } else if (platform5 === "linux") {
     return { LD_LIBRARY_PATH: binary.libraryPath };
   }
   return {};
 }
 function getBinBaseDir() {
-  return path8.join(os8.homedir(), ".specific", "bin");
+  return path8.join(os7.homedir(), ".specific", "bin");
 }
 function getPlatformInfo() {
-  const platform6 = os8.platform();
-  const arch3 = os8.arch();
-  if (platform6 !== "darwin" && platform6 !== "linux") {
+  const platform5 = os7.platform();
+  const arch3 = os7.arch();
+  if (platform5 !== "darwin" && platform5 !== "linux") {
     throw new Error(
-      `Unsupported platform: ${platform6}. Only macOS and Linux are supported.`
+      `Unsupported platform: ${platform5}. Only macOS and Linux are supported.`
     );
   }
   const archStr = arch3;
@@ -186021,7 +185990,7 @@ function getPlatformInfo() {
       `Unsupported architecture: ${arch3}. Only x64 and arm64 are supported.`
     );
   }
-  return { platform: platform6, arch: mappedArch };
+  return { platform: platform5, arch: mappedArch };
 }
 function getBinaryDir(definition, version, platformInfo) {
   return path8.join(
@@ -186035,7 +186004,7 @@ function isBinaryInstalled(definition, version, platformInfo) {
   const binDir = getBinaryDir(definition, version, platformInfo);
   for (const execPath of definition.executables) {
     const fullPath = path8.join(binDir, execPath);
-    if (!fs13.existsSync(fullPath)) {
+    if (!fs12.existsSync(fullPath)) {
       return false;
     }
   }
@@ -186064,11 +186033,11 @@ async function downloadFile(url, destPath, onProgress) {
   );
   let bytesDownloaded = 0;
   const parentDir = path8.dirname(destPath);
-  if (!fs13.existsSync(parentDir)) {
-    fs13.mkdirSync(parentDir, { recursive: true });
+  if (!fs12.existsSync(parentDir)) {
+    fs12.mkdirSync(parentDir, { recursive: true });
   }
   const partPath = destPath + ".part";
-  const fileStream = fs13.createWriteStream(partPath);
+  const fileStream = fs12.createWriteStream(partPath);
   try {
     const reader = response.body.getReader();
     while (true) {
@@ -186091,12 +186060,12 @@ async function downloadFile(url, destPath, onProgress) {
         else resolve9();
       });
     });
-    fs13.renameSync(partPath, destPath);
+    fs12.renameSync(partPath, destPath);
   } catch (error) {
     try {
       fileStream.close();
-      if (fs13.existsSync(partPath)) {
-        fs13.unlinkSync(partPath);
+      if (fs12.existsSync(partPath)) {
+        fs12.unlinkSync(partPath);
       }
     } catch {
     }
@@ -186105,8 +186074,8 @@ async function downloadFile(url, destPath, onProgress) {
 }
 async function extractTarball(archivePath, destDir, definition, onProgress) {
   onProgress?.({ phase: "extracting" });
-  if (!fs13.existsSync(destDir)) {
-    fs13.mkdirSync(destDir, { recursive: true });
+  if (!fs12.existsSync(destDir)) {
+    fs12.mkdirSync(destDir, { recursive: true });
   }
   try {
     const fileStream = createReadStream(archivePath);
@@ -186115,8 +186084,8 @@ async function extractTarball(archivePath, destDir, definition, onProgress) {
     onProgress?.({ phase: "finalizing" });
     for (const execPath of definition.executables) {
       const fullPath = path8.join(destDir, execPath);
-      if (fs13.existsSync(fullPath)) {
-        fs13.chmodSync(fullPath, 493);
+      if (fs12.existsSync(fullPath)) {
+        fs12.chmodSync(fullPath, 493);
       }
     }
   } catch (error) {
@@ -186140,12 +186109,12 @@ async function ensureBinary(definition, version, onProgress) {
           `Binary type definitions must have exactly one executable, got ${definition.executables.length}`
         );
       }
-      if (!fs13.existsSync(binDir)) {
-        fs13.mkdirSync(binDir, { recursive: true });
+      if (!fs12.existsSync(binDir)) {
+        fs12.mkdirSync(binDir, { recursive: true });
       }
       const execPath = path8.join(binDir, definition.executables[0]);
       await downloadFile(url, execPath, onProgress);
-      fs13.chmodSync(execPath, 493);
+      fs12.chmodSync(execPath, 493);
       onProgress?.({ phase: "finalizing" });
     } else {
       const downloadDir = path8.join(getBinBaseDir(), "downloads");
@@ -186156,8 +186125,8 @@ async function ensureBinary(definition, version, onProgress) {
         await extractTarball(archivePath, binDir, definition, onProgress);
       } finally {
         try {
-          if (fs13.existsSync(archivePath)) {
-            fs13.unlinkSync(archivePath);
+          if (fs12.existsSync(archivePath)) {
+            fs12.unlinkSync(archivePath);
           }
         } catch {
         }
@@ -186333,20 +186302,20 @@ function CheckUI() {
   useEffect2(() => {
     async function load() {
       const configPath = path9.join(process.cwd(), "specific.hcl");
-      if (!fs14.existsSync(configPath)) {
+      if (!fs13.existsSync(configPath)) {
         setState({
           status: "error",
           error: "No specific.hcl found in current directory"
         });
         return;
       }
-      const hcl = fs14.readFileSync(configPath, "utf-8");
+      const hcl = fs13.readFileSync(configPath, "utf-8");
       try {
         const config2 = await parseConfig(hcl);
         for (const build of config2.builds) {
           if (build.dockerfile) {
             const dockerfilePath = path9.resolve(process.cwd(), build.dockerfile);
-            if (!fs14.existsSync(dockerfilePath)) {
+            if (!fs13.existsSync(dockerfilePath)) {
               setState({
                 status: "error",
                 error: `Build "${build.name}": Dockerfile not found at "${build.dockerfile}" (resolved to ${dockerfilePath})`
@@ -186362,7 +186331,7 @@ function CheckUI() {
               process.cwd(),
               pg.reshape.migrations_dir ?? "migrations"
             );
-            if (!fs14.existsSync(migrationsDir)) {
+            if (!fs13.existsSync(migrationsDir)) {
               reshapeChecks2.push({
                 databaseName: pg.name,
                 migrationsDir: pg.reshape.migrations_dir ?? "migrations",
@@ -186415,7 +186384,7 @@ function checkCommand() {
 import React6, { useState as useState5, useEffect as useEffect3, useRef } from "react";
 import { render as render4, Text as Text6, Box as Box6, useApp as useApp2, Static, useInput as useInput4 } from "ink";
 import Spinner4 from "ink-spinner";
-import * as fs24 from "fs";
+import * as fs23 from "fs";
 import * as path20 from "path";
 
 // node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
@@ -188170,7 +188139,7 @@ var PortAllocator = class {
 };
 
 // src/lib/dev/stable-port-allocator.ts
-import * as fs15 from "fs";
+import * as fs14 from "fs";
 import * as path10 from "path";
 var PORT_RANGE_START2 = 4e4;
 var PORT_RANGE_END2 = 49999;
@@ -188185,11 +188154,11 @@ var StablePortAllocator = class {
     this.loadPorts();
   }
   loadPorts() {
-    if (!fs15.existsSync(this.portsFilePath)) {
+    if (!fs14.existsSync(this.portsFilePath)) {
       return;
     }
     try {
-      const content = fs15.readFileSync(this.portsFilePath, "utf-8");
+      const content = fs14.readFileSync(this.portsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.ports) {
         this.savedPorts = data.ports;
@@ -188202,14 +188171,14 @@ var StablePortAllocator = class {
     }
   }
   savePorts() {
-    if (!fs15.existsSync(this.portsDir)) {
-      fs15.mkdirSync(this.portsDir, { recursive: true });
+    if (!fs14.existsSync(this.portsDir)) {
+      fs14.mkdirSync(this.portsDir, { recursive: true });
     }
     const data = {
       version: 1,
       ports: this.savedPorts
     };
-    fs15.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
+    fs14.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
   }
   allocateRandom() {
     const rangeSize = PORT_RANGE_END2 - PORT_RANGE_START2 + 1;
@@ -188236,7 +188205,7 @@ var StablePortAllocator = class {
 };
 
 // src/lib/dev/database-manager.ts
-import * as fs16 from "fs";
+import * as fs15 from "fs";
 import * as path11 from "path";
 import * as net from "net";
 import { spawn } from "child_process";
@@ -188248,9 +188217,9 @@ async function startPostgres(pg, port, dataDir, onProgress) {
   const password = "postgres";
   const libraryEnv = getLibraryEnv(binary);
   const env2 = { ...process.env, ...libraryEnv };
-  const dataExists = fs16.existsSync(dbDataPath);
+  const dataExists = fs15.existsSync(dbDataPath);
   if (!dataExists) {
-    fs16.mkdirSync(dbDataPath, { recursive: true });
+    fs15.mkdirSync(dbDataPath, { recursive: true });
     await runCommand(
       binary.executables["initdb"],
       ["-D", dbDataPath, "-U", user, "--auth=trust", "--no-locale", "-E", "UTF8"],
@@ -188327,8 +188296,8 @@ async function startRedis(redis, port, onProgress) {
 async function startStorage(storage, port, dataDir) {
   const S3rver = (await import("s3rver")).default;
   const storageDataPath = path11.join(process.cwd(), dataDir, storage.name);
-  if (!fs16.existsSync(storageDataPath)) {
-    fs16.mkdirSync(storageDataPath, { recursive: true });
+  if (!fs15.existsSync(storageDataPath)) {
+    fs15.mkdirSync(storageDataPath, { recursive: true });
   }
   const host = "127.0.0.1";
   const accessKey = "S3RVER";
@@ -188971,7 +188940,7 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
 }
 
 // src/lib/dev/instance-state.ts
-import * as fs17 from "fs";
+import * as fs16 from "fs";
 import * as path12 from "path";
 var InstanceStateManager = class {
   stateDir;
@@ -188989,8 +188958,8 @@ var InstanceStateManager = class {
     return this.key;
   }
   ensureStateDir() {
-    if (!fs17.existsSync(this.stateDir)) {
-      fs17.mkdirSync(this.stateDir, { recursive: true });
+    if (!fs16.existsSync(this.stateDir)) {
+      fs16.mkdirSync(this.stateDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -189007,15 +188976,15 @@ var InstanceStateManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs17.openSync(
+        const fd = fs16.openSync(
           this.lockPath,
-          fs17.constants.O_CREAT | fs17.constants.O_EXCL | fs17.constants.O_WRONLY
+          fs16.constants.O_CREAT | fs16.constants.O_EXCL | fs16.constants.O_WRONLY
         );
-        fs17.writeSync(fd, String(process.pid));
-        fs17.closeSync(fd);
+        fs16.writeSync(fd, String(process.pid));
+        fs16.closeSync(fd);
         return () => {
           try {
-            fs17.unlinkSync(this.lockPath);
+            fs16.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -189024,16 +188993,16 @@ var InstanceStateManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs17.readFileSync(this.lockPath, "utf-8").trim(),
+              fs16.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs17.unlinkSync(this.lockPath);
+              fs16.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs17.unlinkSync(this.lockPath);
+              fs16.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
@@ -189047,12 +189016,12 @@ var InstanceStateManager = class {
     throw new Error("Failed to acquire state lock (timeout)");
   }
   async getExistingInstances() {
-    if (!fs17.existsSync(this.statePath)) {
+    if (!fs16.existsSync(this.statePath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs17.readFileSync(this.statePath, "utf-8");
+      const content = fs16.readFileSync(this.statePath, "utf-8");
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
         return null;
@@ -189065,21 +189034,21 @@ var InstanceStateManager = class {
     }
   }
   async cleanStaleState() {
-    if (!fs17.existsSync(this.statePath)) {
+    if (!fs16.existsSync(this.statePath)) {
       return false;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs17.readFileSync(this.statePath, "utf-8");
+      const content = fs16.readFileSync(this.statePath, "utf-8");
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
-        fs17.unlinkSync(this.statePath);
+        fs16.unlinkSync(this.statePath);
         return true;
       }
       return false;
     } catch {
       try {
-        fs17.unlinkSync(this.statePath);
+        fs16.unlinkSync(this.statePath);
         return true;
       } catch {
       }
@@ -189091,8 +189060,8 @@ var InstanceStateManager = class {
   async claimOwnership(command) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs17.existsSync(this.statePath)) {
-        const content = fs17.readFileSync(this.statePath, "utf-8");
+      if (fs16.existsSync(this.statePath)) {
+        const content = fs16.readFileSync(this.statePath, "utf-8");
         const state2 = JSON.parse(content);
         if (this.isProcessRunning(state2.owner.pid)) {
           throw new Error(`Instances already owned by PID ${state2.owner.pid}`);
@@ -189161,8 +189130,8 @@ var InstanceStateManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs17.existsSync(this.statePath)) {
-        fs17.unlinkSync(this.statePath);
+      if (fs16.existsSync(this.statePath)) {
+        fs16.unlinkSync(this.statePath);
       }
       this.ownsInstances = false;
     } finally {
@@ -189170,21 +189139,21 @@ var InstanceStateManager = class {
     }
   }
   readState() {
-    const content = fs17.readFileSync(this.statePath, "utf-8");
+    const content = fs16.readFileSync(this.statePath, "utf-8");
     return JSON.parse(content);
   }
   writeStateAtomic(state) {
     this.ensureStateDir();
     const tmpPath = this.statePath + ".tmp";
-    fs17.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs17.renameSync(tmpPath, this.statePath);
+    fs16.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs16.renameSync(tmpPath, this.statePath);
   }
 };
 
 // src/lib/dev/http-proxy.ts
 import * as http from "http";
 import * as https from "https";
-import * as fs18 from "fs";
+import * as fs17 from "fs";
 import * as path13 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import httpProxy from "http-proxy";
@@ -189592,10 +189561,10 @@ function serveFilesystemFile(res, pathname) {
     res.end("<h1>Forbidden</h1>");
     return;
   }
-  if (fs18.existsSync(resolvedPath)) {
-    if (fs18.statSync(resolvedPath).isDirectory()) {
+  if (fs17.existsSync(resolvedPath)) {
+    if (fs17.statSync(resolvedPath).isDirectory()) {
       const indexPath2 = path13.join(resolvedPath, "index.html");
-      if (fs18.existsSync(indexPath2)) {
+      if (fs17.existsSync(indexPath2)) {
         return serveFile(res, indexPath2);
       }
     } else {
@@ -189603,15 +189572,15 @@ function serveFilesystemFile(res, pathname) {
     }
   }
   const htmlPath = resolvedPath + ".html";
-  if (fs18.existsSync(htmlPath)) {
+  if (fs17.existsSync(htmlPath)) {
     return serveFile(res, htmlPath);
   }
   const indexPath = path13.join(resolvedPath, "index.html");
-  if (fs18.existsSync(indexPath)) {
+  if (fs17.existsSync(indexPath)) {
     return serveFile(res, indexPath);
   }
   const notFoundPath = path13.join(adminDir, "404.html");
-  if (fs18.existsSync(notFoundPath)) {
+  if (fs17.existsSync(notFoundPath)) {
     return serveFileContent(res, notFoundPath, "text/html", 404);
   }
   res.writeHead(404, { "Content-Type": "text/html" });
@@ -189624,7 +189593,7 @@ function serveFile(res, filePath) {
 }
 function serveFileContent(res, filePath, contentType, statusCode = 200) {
   try {
-    const content = fs18.readFileSync(filePath);
+    const content = fs17.readFileSync(filePath);
     res.writeHead(statusCode, { "Content-Type": contentType });
     res.end(content);
   } catch (err) {
@@ -189999,7 +189968,7 @@ async function startMailServer(mail, smtpPort, apiPort) {
 
 // src/lib/dev/drizzle-gateway-manager.ts
 import * as net3 from "net";
-import * as fs19 from "fs";
+import * as fs18 from "fs";
 import * as path15 from "path";
 import { spawn as spawn4 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -190033,12 +190002,12 @@ async function startDrizzleGateway(postgresInstances, port, configDir, options2)
   );
   const host = "127.0.0.1";
   const drizzleConfigDir = path15.join(configDir, "drizzle-gateway");
-  if (!fs19.existsSync(drizzleConfigDir)) {
-    fs19.mkdirSync(drizzleConfigDir, { recursive: true });
+  if (!fs18.existsSync(drizzleConfigDir)) {
+    fs18.mkdirSync(drizzleConfigDir, { recursive: true });
   }
   const storeJson = generateStoreJson(postgresInstances);
   const storeJsonPath = path15.join(drizzleConfigDir, "store.json");
-  fs19.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
+  fs18.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
   writeLog("drizzle-gateway", `Starting Drizzle Gateway`);
   writeLog("drizzle-gateway", `STORE_PATH: ${drizzleConfigDir}`);
   writeLog("drizzle-gateway", `PORT: ${port}`);
@@ -190140,16 +190109,16 @@ function detectSyncDatabases(config) {
 }
 
 // src/lib/dev/reshape-watcher.ts
-import * as fs20 from "fs";
+import * as fs19 from "fs";
 import * as path16 from "path";
 import { spawnSync } from "child_process";
 function getMigrationFiles(dir, log) {
   log(`Scanning migrations directory: ${dir}`);
-  if (!fs20.existsSync(dir)) {
+  if (!fs19.existsSync(dir)) {
     log(`Migrations directory does not exist: ${dir}`);
     return [];
   }
-  const files = fs20.readdirSync(dir);
+  const files = fs19.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)"}`);
@@ -190199,7 +190168,7 @@ function runReshape(args, databaseUrl, migrationsDir, reshapeBinaryPath, log) {
 }
 function makeReadOnly(filePath, log) {
   try {
-    fs20.chmodSync(filePath, 292);
+    fs19.chmodSync(filePath, 292);
     log(`Set file permissions to read-only (444): ${filePath}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -190285,9 +190254,9 @@ function createReshapeWatcher(options2) {
   };
   const startWatching = () => {
     log(`Starting file watcher for migrations directory...`);
-    if (!fs20.existsSync(migrationsDir)) {
+    if (!fs19.existsSync(migrationsDir)) {
       log(`Migrations directory does not exist, creating: ${migrationsDir}`);
-      fs20.mkdirSync(migrationsDir, { recursive: true });
+      fs19.mkdirSync(migrationsDir, { recursive: true });
     }
     log(`Watching directory: ${migrationsDir}`);
     watcher = chokidar_default.watch(migrationsDir, {
@@ -190422,7 +190391,7 @@ function createReshapeWatcher(options2) {
 }
 
 // src/lib/dev/temporal-manager.ts
-import * as fs21 from "fs";
+import * as fs20 from "fs";
 import * as path17 from "path";
 import * as net4 from "net";
 import { spawn as spawn5 } from "child_process";
@@ -190430,8 +190399,8 @@ async function startTemporalDevServer(temporals, grpcPort, uiPort, dataDir, onPr
   const binary = await ensureBinary(temporalBinary, void 0, onProgress);
   const dbPath = path17.join(process.cwd(), dataDir, "temporal.db");
   const dbDir = path17.dirname(dbPath);
-  if (!fs21.existsSync(dbDir)) {
-    fs21.mkdirSync(dbDir, { recursive: true });
+  if (!fs20.existsSync(dbDir)) {
+    fs20.mkdirSync(dbDir, { recursive: true });
   }
   const host = "127.0.0.1";
   const namespaceArgs = temporals.flatMap((t) => ["--namespace", t.name]);
@@ -190760,7 +190729,7 @@ function watchConfigFile(configPath, debounceMs, onChange) {
 }
 
 // src/lib/dev/subdomain-generator.ts
-import * as fs22 from "fs";
+import * as fs21 from "fs";
 import * as path18 from "path";
 import { generateSlug } from "random-word-slugs";
 var StableSubdomainAllocator = class {
@@ -190773,11 +190742,11 @@ var StableSubdomainAllocator = class {
     this.loadTunnels();
   }
   loadTunnels() {
-    if (!fs22.existsSync(this.tunnelsFilePath)) {
+    if (!fs21.existsSync(this.tunnelsFilePath)) {
       return;
     }
     try {
-      const content = fs22.readFileSync(this.tunnelsFilePath, "utf-8");
+      const content = fs21.readFileSync(this.tunnelsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.baseSlug) {
         this.baseSlug = data.baseSlug;
@@ -190787,14 +190756,14 @@ var StableSubdomainAllocator = class {
     }
   }
   saveTunnels() {
-    if (!fs22.existsSync(this.tunnelsDir)) {
-      fs22.mkdirSync(this.tunnelsDir, { recursive: true });
+    if (!fs21.existsSync(this.tunnelsDir)) {
+      fs21.mkdirSync(this.tunnelsDir, { recursive: true });
     }
     const data = {
       version: 1,
       baseSlug: this.baseSlug
     };
-    fs22.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
+    fs21.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
   }
   generateBaseSlug() {
     return generateSlug(2, {
@@ -190950,9 +190919,9 @@ async function startTunnel(serviceName, endpointName, port, subdomain, callbacks
 }
 
 // src/lib/dev/proxy-registry.ts
-import * as fs23 from "fs";
+import * as fs22 from "fs";
 import * as path19 from "path";
-import * as os9 from "os";
+import * as os8 from "os";
 import * as net6 from "net";
 var ProxyRegistryManager = class {
   proxyDir;
@@ -190962,14 +190931,14 @@ var ProxyRegistryManager = class {
   isOwner = false;
   registryWatcher = null;
   constructor() {
-    this.proxyDir = path19.join(os9.homedir(), ".specific", "proxy");
+    this.proxyDir = path19.join(os8.homedir(), ".specific", "proxy");
     this.ownerPath = path19.join(this.proxyDir, "owner.json");
     this.registryPath = path19.join(this.proxyDir, "registry.json");
     this.lockPath = path19.join(this.proxyDir, "registry.lock");
   }
   ensureProxyDir() {
-    if (!fs23.existsSync(this.proxyDir)) {
-      fs23.mkdirSync(this.proxyDir, { recursive: true });
+    if (!fs22.existsSync(this.proxyDir)) {
+      fs22.mkdirSync(this.proxyDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -191026,15 +190995,15 @@ var ProxyRegistryManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs23.openSync(
+        const fd = fs22.openSync(
           this.lockPath,
-          fs23.constants.O_CREAT | fs23.constants.O_EXCL | fs23.constants.O_WRONLY
+          fs22.constants.O_CREAT | fs22.constants.O_EXCL | fs22.constants.O_WRONLY
         );
-        fs23.writeSync(fd, String(process.pid));
-        fs23.closeSync(fd);
+        fs22.writeSync(fd, String(process.pid));
+        fs22.closeSync(fd);
         return () => {
           try {
-            fs23.unlinkSync(this.lockPath);
+            fs22.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -191043,16 +191012,16 @@ var ProxyRegistryManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs23.readFileSync(this.lockPath, "utf-8").trim(),
+              fs22.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs23.unlinkSync(this.lockPath);
+              fs22.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs23.unlinkSync(this.lockPath);
+              fs22.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
@@ -191072,8 +191041,8 @@ var ProxyRegistryManager = class {
   async claimProxyOwnership(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs23.existsSync(this.ownerPath)) {
-        const content = fs23.readFileSync(this.ownerPath, "utf-8");
+      if (fs22.existsSync(this.ownerPath)) {
+        const content = fs22.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (await this.isProxyOwnerHealthy(ownerFile2.owner.pid)) {
           return false;
@@ -191103,11 +191072,11 @@ var ProxyRegistryManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs23.existsSync(this.ownerPath)) {
-        const content = fs23.readFileSync(this.ownerPath, "utf-8");
+      if (fs22.existsSync(this.ownerPath)) {
+        const content = fs22.readFileSync(this.ownerPath, "utf-8");
         const ownerFile = JSON.parse(content);
         if (ownerFile.owner.pid === process.pid) {
-          fs23.unlinkSync(this.ownerPath);
+          fs22.unlinkSync(this.ownerPath);
         }
       }
       this.isOwner = false;
@@ -191119,12 +191088,12 @@ var ProxyRegistryManager = class {
    * Get the current proxy owner.
    */
   async getProxyOwner() {
-    if (!fs23.existsSync(this.ownerPath)) {
+    if (!fs22.existsSync(this.ownerPath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs23.readFileSync(this.ownerPath, "utf-8");
+      const content = fs22.readFileSync(this.ownerPath, "utf-8");
       const ownerFile = JSON.parse(content);
       if (!await this.isProxyOwnerHealthy(ownerFile.owner.pid)) {
         return null;
@@ -191221,7 +191190,7 @@ var ProxyRegistryManager = class {
    */
   watchRegistry(onChange) {
     this.ensureProxyDir();
-    if (!fs23.existsSync(this.registryPath)) {
+    if (!fs22.existsSync(this.registryPath)) {
       const emptyRegistry = {
         version: 1,
         keys: {},
@@ -191264,13 +191233,13 @@ var ProxyRegistryManager = class {
   async attemptElection(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs23.existsSync(this.ownerPath)) {
-        const content = fs23.readFileSync(this.ownerPath, "utf-8");
+      if (fs22.existsSync(this.ownerPath)) {
+        const content = fs22.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (await this.isProxyOwnerHealthy(ownerFile2.owner.pid)) {
           return false;
         }
-        fs23.unlinkSync(this.ownerPath);
+        fs22.unlinkSync(this.ownerPath);
       }
       const ownerFile = {
         version: 1,
@@ -191288,7 +191257,7 @@ var ProxyRegistryManager = class {
     }
   }
   readRegistry() {
-    if (!fs23.existsSync(this.registryPath)) {
+    if (!fs22.existsSync(this.registryPath)) {
       return {
         version: 1,
         keys: {},
@@ -191296,7 +191265,7 @@ var ProxyRegistryManager = class {
       };
     }
     try {
-      const content = fs23.readFileSync(this.registryPath, "utf-8");
+      const content = fs22.readFileSync(this.registryPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return {
@@ -191309,8 +191278,8 @@ var ProxyRegistryManager = class {
   writeFileAtomic(filePath, data) {
     this.ensureProxyDir();
     const tmpPath = filePath + ".tmp";
-    fs23.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    fs23.renameSync(tmpPath, filePath);
+    fs22.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs22.renameSync(tmpPath, filePath);
   }
 };
 
@@ -191436,10 +191405,10 @@ function DevUI({ instanceKey, tunnelEnabled }) {
     }
   }, [state.status, state.caInstallPhase]);
   useInput4((_input, key) => {
-    if (state.status === "installing-ca" && state.caInstallPhase === "prompt" && key.return) {
+    if (key.return) {
       setState((s) => ({ ...s, caInstallPhase: "installing" }));
     }
-  });
+  }, { isActive: state.status === "installing-ca" && state.caInstallPhase === "prompt" });
   async function installSystemConfig() {
     try {
       performSystemSetup();
@@ -191633,7 +191602,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
     const configPath = path20.join(process.cwd(), "specific.hcl");
     const watcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs24.readFileSync(configPath, "utf-8");
+        const hcl = fs23.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           triggerReload();
         }).catch((err) => {
@@ -191759,7 +191728,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
         return;
       }
       const configPath = path20.join(process.cwd(), "specific.hcl");
-      if (!fs24.existsSync(configPath)) {
+      if (!fs23.existsSync(configPath)) {
         writeLog("system", "Waiting for specific.hcl to appear");
         setState((s) => ({
           ...s,
@@ -191777,7 +191746,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
         return;
       }
       let config2;
-      const hcl = fs24.readFileSync(configPath, "utf-8");
+      const hcl = fs23.readFileSync(configPath, "utf-8");
       try {
         config2 = await parseConfig(hcl);
       } catch (err) {
@@ -192104,7 +192073,7 @@ Add them to the config block in specific.local`);
           if (service.volumes) {
             for (const vol of service.volumes) {
               const volumeDir = path20.resolve(`.specific/keys/${instanceKey}/data/volumes/${service.name}/${vol.name}`);
-              fs24.mkdirSync(volumeDir, { recursive: true });
+              fs23.mkdirSync(volumeDir, { recursive: true });
               volumePaths.set(vol.name, volumeDir);
             }
           }
@@ -192160,7 +192129,7 @@ Add them to the config block in specific.local`);
             if (service.volumes) {
               for (const vol of service.volumes) {
                 const volumeDir = path20.resolve(`.specific/keys/${instanceKey}/data/volumes/${service.name}/${vol.name}`);
-                fs24.mkdirSync(volumeDir, { recursive: true });
+                fs23.mkdirSync(volumeDir, { recursive: true });
                 volumePaths.set(vol.name, volumeDir);
               }
             }
@@ -192731,12 +192700,12 @@ init_open();
 import React7, { useState as useState6, useEffect as useEffect4, useCallback } from "react";
 import { render as render5, Text as Text7, Box as Box7, useApp as useApp3, useInput as useInput5 } from "ink";
 import Spinner5 from "ink-spinner";
-import * as fs26 from "fs";
+import * as fs25 from "fs";
 import * as path23 from "path";
 
 // src/lib/tarball/create.ts
 import { execSync as execSync4 } from "child_process";
-import * as fs25 from "fs";
+import * as fs24 from "fs";
 import * as path22 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
 function isInsideGitRepository(dir) {
@@ -192794,7 +192763,7 @@ var EXCLUDED_DIRS = [
 ];
 async function collectPaths(baseDir, currentDir, exclude) {
   const results = [];
-  const entries = await fs25.promises.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs24.promises.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path22.join(currentDir, entry.name);
     const relativePath = path22.relative(baseDir, fullPath);
@@ -192813,7 +192782,7 @@ async function collectPaths(baseDir, currentDir, exclude) {
 async function createTarArchive(projectDir) {
   writeLog("tarball", "Creating tarball using tar-vern (non-git project)");
   const configPath = path22.join(projectDir, "specific.hcl");
-  if (!fs25.existsSync(configPath)) {
+  if (!fs24.existsSync(configPath)) {
     throw new Error("specific.hcl not found in project directory");
   }
   const relativePaths = await collectPaths(projectDir, projectDir, EXCLUDED_DIRS);
@@ -193735,12 +193704,12 @@ function DeployUI({ environment, config }) {
 }
 async function deployCommand(environment) {
   const configPath = path23.join(process.cwd(), "specific.hcl");
-  if (!fs26.existsSync(configPath)) {
+  if (!fs25.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
-  const hcl = fs26.readFileSync(configPath, "utf-8");
+  const hcl = fs25.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig(hcl);
   } catch (err) {
@@ -193761,7 +193730,7 @@ async function deployCommand(environment) {
 
 // src/commands/exec.tsx
 import { spawn as spawn6 } from "child_process";
-import * as fs27 from "fs";
+import * as fs26 from "fs";
 import * as path24 from "path";
 async function execCommand(serviceName, command, instanceKey = "default") {
   if (command.length === 0) {
@@ -193791,12 +193760,12 @@ async function execCommand(serviceName, command, instanceKey = "default") {
     }
   };
   const configPath = path24.join(process.cwd(), "specific.hcl");
-  if (!fs27.existsSync(configPath)) {
+  if (!fs26.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
-  const hcl = fs27.readFileSync(configPath, "utf-8");
+  const hcl = fs26.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig(hcl);
   } catch (err) {
@@ -193946,7 +193915,7 @@ async function execCommand(serviceName, command, instanceKey = "default") {
 
 // src/commands/psql.tsx
 import { spawn as spawn7 } from "child_process";
-import * as fs28 from "fs";
+import * as fs27 from "fs";
 import * as path25 from "path";
 async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []) {
   let startedResources = [];
@@ -193965,12 +193934,12 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
     }
   };
   const configPath = path25.join(process.cwd(), "specific.hcl");
-  if (!fs28.existsSync(configPath)) {
+  if (!fs27.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
-  const hcl = fs28.readFileSync(configPath, "utf-8");
+  const hcl = fs27.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig(hcl);
   } catch (err) {
@@ -194094,7 +194063,7 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
 
 // src/commands/reshape.tsx
 import { spawn as spawn8 } from "child_process";
-import * as fs29 from "fs";
+import * as fs28 from "fs";
 import * as path26 from "path";
 var VALID_ACTIONS = ["start", "complete", "status", "abort", "check"];
 var MIGRATION_SUBCOMMANDS = ["start", "complete", "abort"];
@@ -194112,8 +194081,8 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
   let migrationsDir = "migrations";
   let targetDb;
   try {
-    if (fs29.existsSync(configPath)) {
-      const configContent = fs29.readFileSync(configPath, "utf-8");
+    if (fs28.existsSync(configPath)) {
+      const configContent = fs28.readFileSync(configPath, "utf-8");
       config = await parseConfig(configContent);
       if (databaseName) {
         const postgresConfig = config.postgres.find((p) => p.name === databaseName);
@@ -194249,7 +194218,7 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
   const reshapeArgs = isMigrationSubcommand ? ["migration", action] : [action];
   const fullMigrationsPath = path26.join(process.cwd(), migrationsDir);
   if (action === "check" || action === "start") {
-    if (fs29.existsSync(fullMigrationsPath)) {
+    if (fs28.existsSync(fullMigrationsPath)) {
       reshapeArgs.push("--dirs", fullMigrationsPath);
     } else if (action === "check") {
       console.error(`Error: Migrations directory not found: ${fullMigrationsPath}`);
@@ -194299,7 +194268,7 @@ 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 Spinner6 from "ink-spinner";
-import * as fs30 from "fs";
+import * as fs29 from "fs";
 import * as path27 from "path";
 function CleanUI({ instanceKey }) {
   const [state, setState] = useState7({ status: "checking" });
@@ -194307,13 +194276,13 @@ function CleanUI({ instanceKey }) {
     async function clean() {
       const projectRoot = process.cwd();
       const specificDir = path27.join(projectRoot, ".specific");
-      if (!fs30.existsSync(specificDir)) {
+      if (!fs29.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
         const keyDir = path27.join(specificDir, "keys", instanceKey);
-        if (!fs30.existsSync(keyDir)) {
+        if (!fs29.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -194329,7 +194298,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs30.rmSync(keyDir, { recursive: true, force: true });
+          fs29.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -194339,12 +194308,12 @@ function CleanUI({ instanceKey }) {
         }
       } else {
         const keysDir = path27.join(specificDir, "keys");
-        if (!fs30.existsSync(keysDir)) {
+        if (!fs29.existsSync(keysDir)) {
           setState({ status: "nothing" });
           return;
         }
-        const keys = fs30.readdirSync(keysDir).filter(
-          (f) => fs30.statSync(path27.join(keysDir, f)).isDirectory()
+        const keys = fs29.readdirSync(keysDir).filter(
+          (f) => fs29.statSync(path27.join(keysDir, f)).isDirectory()
         );
         for (const key of keys) {
           const stateManager2 = new InstanceStateManager(projectRoot, key);
@@ -194368,7 +194337,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs30.rmSync(keysDir, { recursive: true, force: true });
+          fs29.rmSync(keysDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -194533,7 +194502,7 @@ import { render as render9, Text as Text11, Box as Box10, useApp as useApp6 } fr
 import Spinner7 from "ink-spinner";
 
 // src/lib/update.ts
-import * as fs31 from "fs";
+import * as fs30 from "fs";
 import * as path28 from "path";
 var BINARIES_BASE_URL = "https://binaries.specific.dev/cli";
 function compareVersions(a, b) {
@@ -194548,7 +194517,7 @@ function compareVersions(a, b) {
   return 0;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.75";
+  const currentVersion = "0.1.77";
   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}`);
@@ -194564,7 +194533,7 @@ function isBinaryWritable() {
   const binaryPath = getCurrentBinaryPath();
   const dir = path28.dirname(binaryPath);
   try {
-    fs31.accessSync(dir, fs31.constants.W_OK);
+    fs30.accessSync(dir, fs30.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -194575,21 +194544,21 @@ async function performUpdate(version, onProgress) {
   const binaryDir = path28.dirname(binaryPath);
   const tempPath = path28.join(binaryDir, `.specific-update-${process.pid}`);
   try {
-    const { platform: platform6, arch: arch3 } = getPlatformInfo();
-    const url = `${BINARIES_BASE_URL}/${version}/specific-${platform6}-${arch3}`;
+    const { platform: platform5, arch: arch3 } = getPlatformInfo();
+    const url = `${BINARIES_BASE_URL}/${version}/specific-${platform5}-${arch3}`;
     await downloadFile(url, tempPath, onProgress);
-    const stat4 = fs31.statSync(tempPath);
+    const stat4 = fs30.statSync(tempPath);
     if (stat4.size === 0) {
       throw new Error("Downloaded binary is empty");
     }
-    fs31.chmodSync(tempPath, 493);
+    fs30.chmodSync(tempPath, 493);
     onProgress?.({ phase: "finalizing" });
-    fs31.unlinkSync(binaryPath);
-    fs31.renameSync(tempPath, binaryPath);
+    fs30.unlinkSync(binaryPath);
+    fs30.renameSync(tempPath, binaryPath);
   } catch (error) {
     try {
-      if (fs31.existsSync(tempPath)) {
-        fs31.unlinkSync(tempPath);
+      if (fs30.existsSync(tempPath)) {
+        fs30.unlinkSync(tempPath);
       }
     } catch {
     }
@@ -194599,21 +194568,21 @@ async function performUpdate(version, onProgress) {
 
 // src/lib/background-update.ts
 import { spawn as spawn9 } from "child_process";
-import * as fs32 from "fs";
+import * as fs31 from "fs";
 import * as path29 from "path";
-import * as os10 from "os";
-var SPECIFIC_DIR = path29.join(os10.homedir(), ".specific");
+import * as os9 from "os";
+var SPECIFIC_DIR = path29.join(os9.homedir(), ".specific");
 var RATE_LIMIT_FILE = path29.join(SPECIFIC_DIR, "last-update-check");
 var LOCK_FILE = path29.join(SPECIFIC_DIR, "update.lock");
 var RATE_LIMIT_MS = 60 * 60 * 1e3;
 var STALE_LOCK_MS = 10 * 60 * 1e3;
 function writeCheckTimestamp() {
-  fs32.mkdirSync(SPECIFIC_DIR, { recursive: true });
-  fs32.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
+  fs31.mkdirSync(SPECIFIC_DIR, { recursive: true });
+  fs31.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
 }
 function isRateLimited() {
   try {
-    const content = fs32.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
+    const content = fs31.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
     const lastCheck = parseInt(content, 10);
     if (isNaN(lastCheck)) return false;
     return Date.now() - lastCheck < RATE_LIMIT_MS;
@@ -194747,7 +194716,7 @@ function updateCommand() {
 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.75").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.77").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").action((options2) => initCommand(options2));
 program.command("docs [topic]").description("Fetch LLM-optimized documentation").action(docsCommand);
 program.command("check").description("Validate specific.hcl configuration").action(checkCommand);