@specific.dev/cli 0.1.38 → 0.1.40

package/dist/cli.js

@@ -182236,8 +182236,8 @@ import { Command } from "commander";
 import React, { useState, useEffect } from "react";
 import { render, Text, Box, useInput, useApp } from "ink";
 import "ink-spinner";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/lib/dev/local-ca.ts
 import * as fs from "fs";
@@ -182405,6 +182405,106 @@ function generateCertificate(domain, keys = []) {
   };
 }
 
+// src/lib/analytics/index.ts
+import { PostHog } from "posthog-node";
+import * as os2 from "os";
+import * as crypto from "crypto";
+
+// src/lib/project/config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var PROJECT_ID_FILE = ".specific/project_id";
+var ProjectNotLinkedError = class extends Error {
+  constructor() {
+    super(
+      `Project not linked to Specific.
+
+The file ${PROJECT_ID_FILE} does not exist.
+
+Run: specific deploy`
+    );
+    this.name = "ProjectNotLinkedError";
+  }
+};
+function readProjectId(projectDir = process.cwd()) {
+  const projectIdPath = path2.join(projectDir, PROJECT_ID_FILE);
+  if (!fs2.existsSync(projectIdPath)) {
+    throw new ProjectNotLinkedError();
+  }
+  const projectId = fs2.readFileSync(projectIdPath, "utf-8").trim();
+  if (!projectId) {
+    throw new Error(`${PROJECT_ID_FILE} is empty`);
+  }
+  return projectId;
+}
+function hasProjectId(projectDir = process.cwd()) {
+  const projectIdPath = path2.join(projectDir, PROJECT_ID_FILE);
+  return fs2.existsSync(projectIdPath);
+}
+function writeProjectId(projectId, projectDir = process.cwd()) {
+  const specificDir = path2.join(projectDir, ".specific");
+  if (!fs2.existsSync(specificDir)) {
+    fs2.mkdirSync(specificDir, { recursive: true });
+  }
+  fs2.writeFileSync(path2.join(specificDir, "project_id"), projectId + "\n");
+}
+
+// src/lib/analytics/index.ts
+var POSTHOG_HOST = "https://eu.i.posthog.com";
+var client = null;
+var anonymousId = null;
+function isEnabled() {
+  return true;
+}
+function getAnonymousId() {
+  if (anonymousId) return anonymousId;
+  const machineId = `${os2.hostname()}-${os2.userInfo().username}`;
+  anonymousId = crypto.createHash("sha256").update(machineId).digest("hex").slice(0, 16);
+  return anonymousId;
+}
+function getProjectId() {
+  try {
+    if (hasProjectId()) {
+      return readProjectId();
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getClient() {
+  if (!isEnabled()) return null;
+  if (!client) {
+    client = new PostHog("phc_qNQCEUXh6ErdciQRRmeG2xlVvwFjkcW6A5bnOFJ8vXZ", {
+      host: POSTHOG_HOST,
+      flushAt: 1,
+      // Flush immediately for CLI
+      flushInterval: 0
+    });
+  }
+  return client;
+}
+function trackEvent(event, properties) {
+  const ph = getClient();
+  if (!ph) return;
+  ph.capture({
+    distinctId: getAnonymousId(),
+    event,
+    properties: {
+      ...properties,
+      cli_version: "0.1.40",
+      platform: process.platform,
+      node_version: process.version,
+      project_id: getProjectId()
+    }
+  });
+}
+async function shutdown() {
+  if (client) {
+    await client.shutdown();
+    client = null;
+  }
+}
+
 // src/commands/init.tsx
 var SPECIFIC_INSTRUCTIONS = `Use Specific to handle all infrastructure and development environments: like deployments, databases, real-time sync, services, secrets, configuration and environment variables. Run \`specific docs\` to learn how to use Specific. ALWAYS run \`specific check\` after making changes to the Specific configuration.`;
 var CURSOR_MDC_CONTENT = `---
@@ -182422,67 +182522,67 @@ var options = [
   { id: "other", label: "Other / Manual" }
 ];
 function isGitProject() {
-  const gitPath = path2.join(process.cwd(), ".git");
-  return fs2.existsSync(gitPath);
+  const gitPath = path3.join(process.cwd(), ".git");
+  return fs3.existsSync(gitPath);
 }
 function detectExistingAgents() {
   const detected = {};
-  const cursorDir = path2.join(process.cwd(), ".cursor");
-  if (fs2.existsSync(cursorDir)) {
+  const cursorDir = path3.join(process.cwd(), ".cursor");
+  if (fs3.existsSync(cursorDir)) {
     detected["cursor"] = true;
   }
-  const claudeDir = path2.join(process.cwd(), ".claude");
-  const claudeMd = path2.join(process.cwd(), "CLAUDE.md");
-  if (fs2.existsSync(claudeDir) || fs2.existsSync(claudeMd)) {
+  const claudeDir = path3.join(process.cwd(), ".claude");
+  const claudeMd = path3.join(process.cwd(), "CLAUDE.md");
+  if (fs3.existsSync(claudeDir) || fs3.existsSync(claudeMd)) {
     detected["claude"] = true;
   }
-  const agentsMd = path2.join(process.cwd(), "AGENTS.md");
-  if (fs2.existsSync(agentsMd)) {
+  const agentsMd = path3.join(process.cwd(), "AGENTS.md");
+  if (fs3.existsSync(agentsMd)) {
     detected["codex"] = true;
   }
   return detected;
 }
 function appendOrCreateFile(filePath, content) {
-  if (fs2.existsSync(filePath)) {
-    const existing = fs2.readFileSync(filePath, "utf-8");
+  if (fs3.existsSync(filePath)) {
+    const existing = fs3.readFileSync(filePath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    fs2.writeFileSync(filePath, existing + separator + content + "\n");
+    fs3.writeFileSync(filePath, existing + separator + content + "\n");
     return "modified";
   } else {
-    fs2.writeFileSync(filePath, content + "\n");
+    fs3.writeFileSync(filePath, content + "\n");
     return "created";
   }
 }
 function addToGitignore() {
-  const gitignorePath = path2.join(process.cwd(), ".gitignore");
+  const gitignorePath = path3.join(process.cwd(), ".gitignore");
   const entries = [".specific", "specific.secrets"];
-  if (fs2.existsSync(gitignorePath)) {
-    const existing = fs2.readFileSync(gitignorePath, "utf-8");
+  if (fs3.existsSync(gitignorePath)) {
+    const existing = fs3.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";
-    fs2.writeFileSync(
+    fs3.writeFileSync(
       gitignorePath,
       existing + separator + missingEntries.join("\n") + "\n"
     );
     return "modified";
   } else {
-    fs2.writeFileSync(gitignorePath, entries.join("\n") + "\n");
+    fs3.writeFileSync(gitignorePath, entries.join("\n") + "\n");
     return "created";
   }
 }
 function configureClaudeCodePermissions() {
-  const claudeDir = path2.join(process.cwd(), ".claude");
-  const settingsPath = path2.join(claudeDir, "settings.local.json");
+  const claudeDir = path3.join(process.cwd(), ".claude");
+  const settingsPath = path3.join(claudeDir, "settings.local.json");
   const permissions = ["Bash(specific docs:*)", "Bash(specific check:*)"];
-  if (fs2.existsSync(settingsPath)) {
-    const existing = JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
+  if (fs3.existsSync(settingsPath)) {
+    const existing = JSON.parse(fs3.readFileSync(settingsPath, "utf-8"));
     const allowList = existing?.permissions?.allow || [];
     const missingPermissions = permissions.filter(
       (p) => !allowList.includes(p)
@@ -182497,39 +182597,39 @@ function configureClaudeCodePermissions() {
       existing.permissions.allow = [];
     }
     existing.permissions.allow.push(...missingPermissions);
-    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    fs3.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
     return "modified";
   }
-  if (!fs2.existsSync(claudeDir)) {
-    fs2.mkdirSync(claudeDir);
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir);
   }
   const settings = {
     permissions: {
       allow: permissions
     }
   };
-  fs2.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return "created";
 }
 function createCursorRule() {
-  const cursorDir = path2.join(process.cwd(), ".cursor");
-  const rulesDir = path2.join(cursorDir, "rules");
-  const mdcPath = path2.join(rulesDir, "specific.mdc");
-  if (fs2.existsSync(mdcPath)) {
-    const existing = fs2.readFileSync(mdcPath, "utf-8");
+  const cursorDir = path3.join(process.cwd(), ".cursor");
+  const rulesDir = path3.join(cursorDir, "rules");
+  const mdcPath = path3.join(rulesDir, "specific.mdc");
+  if (fs3.existsSync(mdcPath)) {
+    const existing = fs3.readFileSync(mdcPath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
-    fs2.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+    fs3.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
     return "modified";
   }
-  if (!fs2.existsSync(cursorDir)) {
-    fs2.mkdirSync(cursorDir);
+  if (!fs3.existsSync(cursorDir)) {
+    fs3.mkdirSync(cursorDir);
   }
-  if (!fs2.existsSync(rulesDir)) {
-    fs2.mkdirSync(rulesDir);
+  if (!fs3.existsSync(rulesDir)) {
+    fs3.mkdirSync(rulesDir);
   }
-  fs2.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+  fs3.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
   return "created";
 }
 function configureAgents(checked) {
@@ -182545,7 +182645,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".cursor/rules/specific.mdc");
   }
   if (checked["claude"]) {
-    const claudeMdPath = path2.join(process.cwd(), "CLAUDE.md");
+    const claudeMdPath = path3.join(process.cwd(), "CLAUDE.md");
     const status = appendOrCreateFile(claudeMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("CLAUDE.md");
     else if (status === "modified") agents.filesModified.push("CLAUDE.md");
@@ -182556,7 +182656,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".claude/settings.local.json");
   }
   if (checked["codex"]) {
-    const agentsMdPath = path2.join(process.cwd(), "AGENTS.md");
+    const agentsMdPath = path3.join(process.cwd(), "AGENTS.md");
     const status = appendOrCreateFile(agentsMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("AGENTS.md");
     else if (status === "modified") agents.filesModified.push("AGENTS.md");
@@ -182632,6 +182732,9 @@ function InitUI() {
     } else if ((key.return || input === " ") && isSubmitFocused) {
       const configResult = configureAgents(checked);
       setResult(configResult);
+      trackEvent("project_initialized", {
+        agents: Object.keys(checked).filter((k) => checked[k])
+      });
       setPhase("done");
     }
   });
@@ -182675,11 +182778,11 @@ function initCommand() {
 }
 
 // src/commands/docs.tsx
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { join as join3, dirname } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { join as join4, dirname } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var docsDir = join3(__dirname, "docs");
+var docsDir = join4(__dirname, "docs");
 function docsCommand(path22) {
   const docPath = resolveDocPath(path22);
   if (!docPath) {
@@ -182690,20 +182793,20 @@ Run 'specific docs' to see available topics.`
     );
     process.exit(1);
   }
-  const content = readFileSync3(docPath, "utf-8");
+  const content = readFileSync4(docPath, "utf-8");
   console.log(content);
 }
 function resolveDocPath(path22) {
   if (!path22) {
-    const indexPath2 = join3(docsDir, "index.md");
-    return existsSync3(indexPath2) ? indexPath2 : null;
+    const indexPath2 = join4(docsDir, "index.md");
+    return existsSync4(indexPath2) ? indexPath2 : null;
   }
-  const directPath = join3(docsDir, `${path22}.md`);
-  if (existsSync3(directPath)) {
+  const directPath = join4(docsDir, `${path22}.md`);
+  if (existsSync4(directPath)) {
     return directPath;
   }
-  const indexPath = join3(docsDir, path22, "index.md");
-  if (existsSync3(indexPath)) {
+  const indexPath = join4(docsDir, path22, "index.md");
+  if (existsSync4(indexPath)) {
     return indexPath;
   }
   return null;
@@ -182713,8 +182816,8 @@ function resolveDocPath(path22) {
 import React2, { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render2, Text as Text2, Box as Box2 } from "ink";
 import Spinner2 from "ink-spinner";
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // ../config/dist/parser.js
 var import_hcl2_json_parser = __toESM(require_dist(), 1);
@@ -183196,8 +183299,8 @@ function CheckUI() {
   const [state, setState] = useState2({ status: "loading" });
   useEffect2(() => {
     async function load() {
-      const configPath = path3.join(process.cwd(), "specific.hcl");
-      if (!fs3.existsSync(configPath)) {
+      const configPath = path4.join(process.cwd(), "specific.hcl");
+      if (!fs4.existsSync(configPath)) {
         setState({
           status: "error",
           error: "No specific.hcl found in current directory"
@@ -183205,7 +183308,7 @@ function CheckUI() {
         return;
       }
       try {
-        const hcl = fs3.readFileSync(configPath, "utf-8");
+        const hcl = fs4.readFileSync(configPath, "utf-8");
         const config2 = await parseConfig(hcl);
         setState({ status: "success", config: config2 });
       } catch (err) {
@@ -183237,8 +183340,8 @@ function checkCommand() {
 import React3, { useState as useState3, useEffect as useEffect3, useRef } from "react";
 import { render as render3, Text as Text3, Box as Box3, useApp as useApp2, Static } from "ink";
 import Spinner3 from "ink-spinner";
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 
 // node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
@@ -184992,8 +185095,8 @@ var PortAllocator = class {
 };
 
 // src/lib/dev/stable-port-allocator.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 var PORT_RANGE_START2 = 4e4;
 var PORT_RANGE_END2 = 49999;
 var StablePortAllocator = class {
@@ -185002,16 +185105,16 @@ var StablePortAllocator = class {
   savedPorts = {};
   usedPorts = /* @__PURE__ */ new Set();
   constructor(projectRoot, key = "default") {
-    this.portsDir = path4.join(projectRoot, ".specific", "keys", key);
-    this.portsFilePath = path4.join(this.portsDir, "ports.json");
+    this.portsDir = path5.join(projectRoot, ".specific", "keys", key);
+    this.portsFilePath = path5.join(this.portsDir, "ports.json");
     this.loadPorts();
   }
   loadPorts() {
-    if (!fs4.existsSync(this.portsFilePath)) {
+    if (!fs5.existsSync(this.portsFilePath)) {
       return;
     }
     try {
-      const content = fs4.readFileSync(this.portsFilePath, "utf-8");
+      const content = fs5.readFileSync(this.portsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.ports) {
         this.savedPorts = data.ports;
@@ -185024,14 +185127,14 @@ var StablePortAllocator = class {
     }
   }
   savePorts() {
-    if (!fs4.existsSync(this.portsDir)) {
-      fs4.mkdirSync(this.portsDir, { recursive: true });
+    if (!fs5.existsSync(this.portsDir)) {
+      fs5.mkdirSync(this.portsDir, { recursive: true });
     }
     const data = {
       version: 1,
       ports: this.savedPorts
     };
-    fs4.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
+    fs5.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
   }
   allocateRandom() {
     const rangeSize = PORT_RANGE_END2 - PORT_RANGE_START2 + 1;
@@ -185057,10 +185160,10 @@ var StablePortAllocator = class {
 };
 
 // src/lib/dev/database-manager.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import * as net from "net";
-import * as os3 from "os";
+import * as os4 from "os";
 import { spawn } from "child_process";
 
 // src/lib/bin/types.ts
@@ -185098,17 +185201,17 @@ var ExtractionError = class extends Error {
 };
 
 // src/lib/bin/manager.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import * as os2 from "os";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
 import { createReadStream } from "fs";
 import { createTarExtractor, extractTo } from "tar-vern";
 function getBinBaseDir() {
-  return path5.join(os2.homedir(), ".specific", "bin");
+  return path6.join(os3.homedir(), ".specific", "bin");
 }
 function getPlatformInfo() {
-  const platform5 = os2.platform();
-  const arch3 = os2.arch();
+  const platform5 = os3.platform();
+  const arch3 = os3.arch();
   if (platform5 !== "darwin" && platform5 !== "linux") {
     throw new Error(
       `Unsupported platform: ${platform5}. Only macOS and Linux are supported.`
@@ -185127,7 +185230,7 @@ function getPlatformInfo() {
   return { platform: platform5, arch: mappedArch };
 }
 function getBinaryDir(definition, version, platformInfo) {
-  return path5.join(
+  return path6.join(
     getBinBaseDir(),
     definition.name,
     version,
@@ -185137,8 +185240,8 @@ function getBinaryDir(definition, version, platformInfo) {
 function isBinaryInstalled(definition, version, platformInfo) {
   const binDir = getBinaryDir(definition, version, platformInfo);
   for (const execPath of definition.executables) {
-    const fullPath = path5.join(binDir, execPath);
-    if (!fs5.existsSync(fullPath)) {
+    const fullPath = path6.join(binDir, execPath);
+    if (!fs6.existsSync(fullPath)) {
       return false;
     }
   }
@@ -185166,12 +185269,12 @@ async function downloadFile(url, destPath, onProgress) {
     10
   );
   let bytesDownloaded = 0;
-  const parentDir = path5.dirname(destPath);
-  if (!fs5.existsSync(parentDir)) {
-    fs5.mkdirSync(parentDir, { recursive: true });
+  const parentDir = path6.dirname(destPath);
+  if (!fs6.existsSync(parentDir)) {
+    fs6.mkdirSync(parentDir, { recursive: true });
   }
   const partPath = destPath + ".part";
-  const fileStream = fs5.createWriteStream(partPath);
+  const fileStream = fs6.createWriteStream(partPath);
   try {
     const reader = response.body.getReader();
     while (true) {
@@ -185194,12 +185297,12 @@ async function downloadFile(url, destPath, onProgress) {
         else resolve5();
       });
     });
-    fs5.renameSync(partPath, destPath);
+    fs6.renameSync(partPath, destPath);
   } catch (error) {
     try {
       fileStream.close();
-      if (fs5.existsSync(partPath)) {
-        fs5.unlinkSync(partPath);
+      if (fs6.existsSync(partPath)) {
+        fs6.unlinkSync(partPath);
       }
     } catch {
     }
@@ -185208,8 +185311,8 @@ async function downloadFile(url, destPath, onProgress) {
 }
 async function extractTarball(archivePath, destDir, definition, onProgress) {
   onProgress?.({ phase: "extracting" });
-  if (!fs5.existsSync(destDir)) {
-    fs5.mkdirSync(destDir, { recursive: true });
+  if (!fs6.existsSync(destDir)) {
+    fs6.mkdirSync(destDir, { recursive: true });
   }
   try {
     const fileStream = createReadStream(archivePath);
@@ -185217,9 +185320,9 @@ async function extractTarball(archivePath, destDir, definition, onProgress) {
     await extractTo(entries, destDir);
     onProgress?.({ phase: "finalizing" });
     for (const execPath of definition.executables) {
-      const fullPath = path5.join(destDir, execPath);
-      if (fs5.existsSync(fullPath)) {
-        fs5.chmodSync(fullPath, 493);
+      const fullPath = path6.join(destDir, execPath);
+      if (fs6.existsSync(fullPath)) {
+        fs6.chmodSync(fullPath, 493);
       }
     }
   } catch (error) {
@@ -185243,24 +185346,24 @@ async function ensureBinary(definition, version, onProgress) {
           `Binary type definitions must have exactly one executable, got ${definition.executables.length}`
         );
       }
-      if (!fs5.existsSync(binDir)) {
-        fs5.mkdirSync(binDir, { recursive: true });
+      if (!fs6.existsSync(binDir)) {
+        fs6.mkdirSync(binDir, { recursive: true });
       }
-      const execPath = path5.join(binDir, definition.executables[0]);
+      const execPath = path6.join(binDir, definition.executables[0]);
       await downloadFile(url, execPath, onProgress);
-      fs5.chmodSync(execPath, 493);
+      fs6.chmodSync(execPath, 493);
       onProgress?.({ phase: "finalizing" });
     } else {
-      const downloadDir = path5.join(getBinBaseDir(), "downloads");
+      const downloadDir = path6.join(getBinBaseDir(), "downloads");
       const archiveName = `${definition.name}-${resolvedVersion}-${platformInfo.platform}-${platformInfo.arch}.tar.gz`;
-      const archivePath = path5.join(downloadDir, archiveName);
+      const archivePath = path6.join(downloadDir, archiveName);
       try {
         await downloadFile(url, archivePath, onProgress);
         await extractTarball(archivePath, binDir, definition, onProgress);
       } finally {
         try {
-          if (fs5.existsSync(archivePath)) {
-            fs5.unlinkSync(archivePath);
+          if (fs6.existsSync(archivePath)) {
+            fs6.unlinkSync(archivePath);
           }
         } catch {
         }
@@ -185269,10 +185372,10 @@ async function ensureBinary(definition, version, onProgress) {
   }
   const executables = {};
   for (const execPath of definition.executables) {
-    const name = path5.basename(execPath);
-    executables[name] = path5.join(binDir, execPath);
+    const name = path6.basename(execPath);
+    executables[name] = path6.join(binDir, execPath);
   }
-  const libraryPath = definition.libraryDir ? path5.join(binDir, definition.libraryDir) : void 0;
+  const libraryPath = definition.libraryDir ? path6.join(binDir, definition.libraryDir) : void 0;
   return {
     rootDir: binDir,
     version: resolvedVersion,
@@ -185372,17 +185475,17 @@ var drizzleGatewayBinary = {
 };
 
 // src/lib/dev/debug-logger.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 var DEBUG_LOG_PATH = ".specific/debug.log";
 var logStream = null;
 function getLogStream() {
   if (logStream) {
     return logStream;
   }
-  const logPath = path6.join(process.cwd(), DEBUG_LOG_PATH);
-  fs6.mkdirSync(path6.dirname(logPath), { recursive: true });
-  logStream = fs6.createWriteStream(logPath, { flags: "a" });
+  const logPath = path7.join(process.cwd(), DEBUG_LOG_PATH);
+  fs7.mkdirSync(path7.dirname(logPath), { recursive: true });
+  logStream = fs7.createWriteStream(logPath, { flags: "a" });
   return logStream;
 }
 function writeLog(source, message) {
@@ -185425,7 +185528,7 @@ function getLibraryEnv(binary) {
   if (!binary.libraryPath) {
     return {};
   }
-  const platform5 = os3.platform();
+  const platform5 = os4.platform();
   if (platform5 === "darwin") {
     return { DYLD_LIBRARY_PATH: binary.libraryPath };
   } else if (platform5 === "linux") {
@@ -185435,15 +185538,15 @@ function getLibraryEnv(binary) {
 }
 async function startPostgres(pg, port, dataDir, onProgress) {
   const binary = await ensureBinary(postgresBinary, void 0, onProgress);
-  const dbDataPath = path7.join(process.cwd(), dataDir, pg.name);
+  const dbDataPath = path8.join(process.cwd(), dataDir, pg.name);
   const host = "127.0.0.1";
   const user = "postgres";
   const password = "postgres";
   const libraryEnv = getLibraryEnv(binary);
   const env2 = { ...process.env, ...libraryEnv };
-  const dataExists = fs7.existsSync(dbDataPath);
+  const dataExists = fs8.existsSync(dbDataPath);
   if (!dataExists) {
-    fs7.mkdirSync(dbDataPath, { recursive: true });
+    fs8.mkdirSync(dbDataPath, { recursive: true });
     await runCommand(
       binary.executables["initdb"],
       ["-D", dbDataPath, "-U", user, "--auth=trust", "--no-locale", "-E", "UTF8"],
@@ -185519,9 +185622,9 @@ async function startRedis(redis, port, onProgress) {
 }
 async function startStorage(storage, port, dataDir) {
   const S3rver = (await import("s3rver")).default;
-  const storageDataPath = path7.join(process.cwd(), dataDir, storage.name);
-  if (!fs7.existsSync(storageDataPath)) {
-    fs7.mkdirSync(storageDataPath, { recursive: true });
+  const storageDataPath = path8.join(process.cwd(), dataDir, storage.name);
+  if (!fs8.existsSync(storageDataPath)) {
+    fs8.mkdirSync(storageDataPath, { recursive: true });
   }
   const host = "127.0.0.1";
   const accessKey = "S3RVER";
@@ -185655,9 +185758,9 @@ import { spawn as spawn2 } from "child_process";
 // src/lib/secrets/parser.ts
 var import_hcl2_json_parser2 = __toESM(require_dist(), 1);
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import * as path8 from "path";
-import * as crypto from "crypto";
+import { existsSync as existsSync9 } from "fs";
+import * as path9 from "path";
+import * as crypto2 from "crypto";
 var { parseToObject: parseToObject2 } = import_hcl2_json_parser2.default;
 var SECRETS_FILE = "specific.secrets";
 var GENERATED_SECRETS_FILE = ".specific/generated-secrets.json";
@@ -185675,7 +185778,7 @@ async function parseSecretsFile(content) {
   return secrets;
 }
 async function loadSecrets() {
-  if (!existsSync8(SECRETS_FILE)) {
+  if (!existsSync9(SECRETS_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile(SECRETS_FILE, "utf-8");
@@ -185683,7 +185786,7 @@ async function loadSecrets() {
 }
 function generateRandomString(length = 64) {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  const bytes = crypto.randomBytes(length);
+  const bytes = crypto2.randomBytes(length);
   let result = "";
   for (let i = 0; i < length; i++) {
     result += chars[bytes[i] % chars.length];
@@ -185691,7 +185794,7 @@ function generateRandomString(length = 64) {
   return result;
 }
 async function loadGeneratedSecrets() {
-  if (!existsSync8(GENERATED_SECRETS_FILE)) {
+  if (!existsSync9(GENERATED_SECRETS_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile(GENERATED_SECRETS_FILE, "utf-8");
@@ -185700,13 +185803,13 @@ async function loadGeneratedSecrets() {
 }
 async function saveGeneratedSecret(name, value) {
   let secrets = {};
-  if (existsSync8(GENERATED_SECRETS_FILE)) {
+  if (existsSync9(GENERATED_SECRETS_FILE)) {
     const content = await readFile(GENERATED_SECRETS_FILE, "utf-8");
     secrets = JSON.parse(content);
   }
   secrets[name] = value;
-  const dir = path8.dirname(GENERATED_SECRETS_FILE);
-  if (!existsSync8(dir)) {
+  const dir = path9.dirname(GENERATED_SECRETS_FILE);
+  if (!existsSync9(dir)) {
     await mkdir(dir, { recursive: true });
   }
   await writeFile(GENERATED_SECRETS_FILE, JSON.stringify(secrets, null, 2) + "\n");
@@ -185736,7 +185839,7 @@ async function prepareSecrets(secretsConfig) {
 // src/lib/config/parser.ts
 var import_hcl2_json_parser3 = __toESM(require_dist(), 1);
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 var { parseToObject: parseToObject3 } = import_hcl2_json_parser3.default;
 var CONFIG_FILE = "specific.config";
 async function parseConfigFile(content) {
@@ -185753,7 +185856,7 @@ async function parseConfigFile(content) {
   return configs;
 }
 async function loadConfigs() {
-  if (!existsSync9(CONFIG_FILE)) {
+  if (!existsSync10(CONFIG_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile2(CONFIG_FILE, "utf-8");
@@ -186065,8 +186168,8 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
 }
 
 // src/lib/dev/instance-state.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 var InstanceStateManager = class {
   stateDir;
   statePath;
@@ -186075,16 +186178,16 @@ var InstanceStateManager = class {
   key;
   constructor(projectRoot, key = "default") {
     this.key = key;
-    this.stateDir = path9.join(projectRoot, ".specific", "keys", key);
-    this.statePath = path9.join(this.stateDir, "state.json");
-    this.lockPath = path9.join(this.stateDir, "state.lock");
+    this.stateDir = path10.join(projectRoot, ".specific", "keys", key);
+    this.statePath = path10.join(this.stateDir, "state.json");
+    this.lockPath = path10.join(this.stateDir, "state.lock");
   }
   getKey() {
     return this.key;
   }
   ensureStateDir() {
-    if (!fs8.existsSync(this.stateDir)) {
-      fs8.mkdirSync(this.stateDir, { recursive: true });
+    if (!fs9.existsSync(this.stateDir)) {
+      fs9.mkdirSync(this.stateDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -186101,15 +186204,15 @@ var InstanceStateManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs8.openSync(
+        const fd = fs9.openSync(
           this.lockPath,
-          fs8.constants.O_CREAT | fs8.constants.O_EXCL | fs8.constants.O_WRONLY
+          fs9.constants.O_CREAT | fs9.constants.O_EXCL | fs9.constants.O_WRONLY
         );
-        fs8.writeSync(fd, String(process.pid));
-        fs8.closeSync(fd);
+        fs9.writeSync(fd, String(process.pid));
+        fs9.closeSync(fd);
         return () => {
           try {
-            fs8.unlinkSync(this.lockPath);
+            fs9.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -186118,16 +186221,16 @@ var InstanceStateManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs8.readFileSync(this.lockPath, "utf-8").trim(),
+              fs9.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs8.unlinkSync(this.lockPath);
+              fs9.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs8.unlinkSync(this.lockPath);
+              fs9.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
@@ -186141,12 +186244,12 @@ var InstanceStateManager = class {
     throw new Error("Failed to acquire state lock (timeout)");
   }
   async getExistingInstances() {
-    if (!fs8.existsSync(this.statePath)) {
+    if (!fs9.existsSync(this.statePath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs8.readFileSync(this.statePath, "utf-8");
+      const content = fs9.readFileSync(this.statePath, "utf-8");
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
         return null;
@@ -186159,21 +186262,21 @@ var InstanceStateManager = class {
     }
   }
   async cleanStaleState() {
-    if (!fs8.existsSync(this.statePath)) {
+    if (!fs9.existsSync(this.statePath)) {
       return false;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs8.readFileSync(this.statePath, "utf-8");
+      const content = fs9.readFileSync(this.statePath, "utf-8");
       const state = JSON.parse(content);
       if (!this.isProcessRunning(state.owner.pid)) {
-        fs8.unlinkSync(this.statePath);
+        fs9.unlinkSync(this.statePath);
         return true;
       }
       return false;
     } catch {
       try {
-        fs8.unlinkSync(this.statePath);
+        fs9.unlinkSync(this.statePath);
         return true;
       } catch {
       }
@@ -186185,8 +186288,8 @@ var InstanceStateManager = class {
   async claimOwnership(command) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs8.existsSync(this.statePath)) {
-        const content = fs8.readFileSync(this.statePath, "utf-8");
+      if (fs9.existsSync(this.statePath)) {
+        const content = fs9.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}`);
@@ -186255,8 +186358,8 @@ var InstanceStateManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs8.existsSync(this.statePath)) {
-        fs8.unlinkSync(this.statePath);
+      if (fs9.existsSync(this.statePath)) {
+        fs9.unlinkSync(this.statePath);
       }
       this.ownsInstances = false;
     } finally {
@@ -186264,26 +186367,26 @@ var InstanceStateManager = class {
     }
   }
   readState() {
-    const content = fs8.readFileSync(this.statePath, "utf-8");
+    const content = fs9.readFileSync(this.statePath, "utf-8");
     return JSON.parse(content);
   }
   writeStateAtomic(state) {
     this.ensureStateDir();
     const tmpPath = this.statePath + ".tmp";
-    fs8.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs8.renameSync(tmpPath, this.statePath);
+    fs9.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs9.renameSync(tmpPath, this.statePath);
   }
 };
 
 // src/lib/dev/http-proxy.ts
 import * as http from "http";
 import * as https from "https";
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import httpProxy from "http-proxy";
-var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
-var adminDir = path10.join(__dirname2, "admin");
+var __dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
+var adminDir = path11.join(__dirname2, "admin");
 var HTTP_PORT = 80;
 var HTTPS_PORT = 443;
 var DOMAIN_SUFFIX = ".local.spcf.app";
@@ -186340,7 +186443,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
   });
   const handleRequest = (req, res) => {
     const host = req.headers.host || "";
-    const hostname = host.split(":")[0];
+    const hostname2 = host.split(":")[0];
     const drizzleKey = extractDrizzleGatewayKey(host);
     if (drizzleKey !== null) {
       const drizzlePort = drizzleGatewayPortMap.get(drizzleKey);
@@ -186366,7 +186469,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
         serveStaticFile(res, url.pathname);
         return;
       }
-      if (adminKey === "default" && hostname === ADMIN_DOMAIN) {
+      if (adminKey === "default" && hostname2 === ADMIN_DOMAIN) {
         res.writeHead(503, { "Content-Type": "text/html" });
         res.end("<h1>Admin UI</h1><p>No dev instance running. Start <code>specific dev</code> first.</p>");
         return;
@@ -186487,11 +186590,11 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
   });
 }
 function extractServiceAndKey(host) {
-  const hostname = host.split(":")[0];
-  if (!hostname || !hostname.endsWith(DOMAIN_SUFFIX)) {
+  const hostname2 = host.split(":")[0];
+  if (!hostname2 || !hostname2.endsWith(DOMAIN_SUFFIX)) {
     return null;
   }
-  const prefix = hostname.slice(0, -DOMAIN_SUFFIX.length);
+  const prefix = hostname2.slice(0, -DOMAIN_SUFFIX.length);
   if (!prefix) {
     return null;
   }
@@ -186504,11 +186607,11 @@ function extractServiceAndKey(host) {
   return null;
 }
 function extractDrizzleGatewayKey(host) {
-  const hostname = host.split(":")[0];
-  if (!hostname || !hostname.endsWith(DOMAIN_SUFFIX)) {
+  const hostname2 = host.split(":")[0];
+  if (!hostname2 || !hostname2.endsWith(DOMAIN_SUFFIX)) {
     return null;
   }
-  const prefix = hostname.slice(0, -DOMAIN_SUFFIX.length);
+  const prefix = hostname2.slice(0, -DOMAIN_SUFFIX.length);
   if (!prefix) {
     return null;
   }
@@ -186521,17 +186624,17 @@ function extractDrizzleGatewayKey(host) {
   return null;
 }
 function extractAdminKey(host) {
-  const hostname = host.split(":")[0];
-  if (!hostname) {
+  const hostname2 = host.split(":")[0];
+  if (!hostname2) {
     return null;
   }
-  if (hostname === ADMIN_DOMAIN) {
+  if (hostname2 === ADMIN_DOMAIN) {
     return "default";
   }
-  if (!hostname.endsWith(DOMAIN_SUFFIX)) {
+  if (!hostname2.endsWith(DOMAIN_SUFFIX)) {
     return null;
   }
-  const prefix = hostname.slice(0, -DOMAIN_SUFFIX.length);
+  const prefix = hostname2.slice(0, -DOMAIN_SUFFIX.length);
   if (!prefix) {
     return null;
   }
@@ -186569,25 +186672,25 @@ function serveStaticFile(res, pathname) {
     filePath = filePath + "index.html";
   }
   const relativePath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path10.join(adminDir, relativePath);
-  const resolvedPath = path10.resolve(fullPath);
-  const resolvedAdminDir = path10.resolve(adminDir);
+  const fullPath = path11.join(adminDir, relativePath);
+  const resolvedPath = path11.resolve(fullPath);
+  const resolvedAdminDir = path11.resolve(adminDir);
   if (!resolvedPath.startsWith(resolvedAdminDir)) {
     res.writeHead(403, { "Content-Type": "text/html" });
     res.end("<h1>Forbidden</h1>");
     return;
   }
-  if (!fs9.existsSync(resolvedPath)) {
+  if (!fs10.existsSync(resolvedPath)) {
     const htmlPath = resolvedPath + ".html";
-    if (fs9.existsSync(htmlPath)) {
+    if (fs10.existsSync(htmlPath)) {
       return serveFile(res, htmlPath);
     }
-    const indexPath = path10.join(resolvedPath, "index.html");
-    if (fs9.existsSync(indexPath)) {
+    const indexPath = path11.join(resolvedPath, "index.html");
+    if (fs10.existsSync(indexPath)) {
       return serveFile(res, indexPath);
     }
-    const notFoundPath = path10.join(adminDir, "404.html");
-    if (fs9.existsSync(notFoundPath)) {
+    const notFoundPath = path11.join(adminDir, "404.html");
+    if (fs10.existsSync(notFoundPath)) {
       return serveFileContent(res, notFoundPath, "text/html", 404);
     }
     res.writeHead(404, { "Content-Type": "text/html" });
@@ -186597,13 +186700,13 @@ function serveStaticFile(res, pathname) {
   serveFile(res, resolvedPath);
 }
 function serveFile(res, filePath) {
-  const ext = path10.extname(filePath).toLowerCase();
+  const ext = path11.extname(filePath).toLowerCase();
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
   serveFileContent(res, filePath, contentType, 200);
 }
 function serveFileContent(res, filePath, contentType, statusCode = 200) {
   try {
-    const content = fs9.readFileSync(filePath);
+    const content = fs10.readFileSync(filePath);
     res.writeHead(statusCode, { "Content-Type": contentType });
     res.end(content);
   } catch (err) {
@@ -186755,8 +186858,8 @@ function sleep2(ms) {
 
 // src/lib/dev/drizzle-gateway-manager.ts
 import * as net3 from "net";
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import { spawn as spawn4 } from "child_process";
 import { randomUUID } from "crypto";
 function generateStoreJson(postgresInstances) {
@@ -186788,13 +186891,13 @@ async function startDrizzleGateway(postgresInstances, port, configDir, options2)
     options2?.onProgress
   );
   const host = "127.0.0.1";
-  const drizzleConfigDir = path11.join(configDir, "drizzle-gateway");
-  if (!fs10.existsSync(drizzleConfigDir)) {
-    fs10.mkdirSync(drizzleConfigDir, { recursive: true });
+  const drizzleConfigDir = path12.join(configDir, "drizzle-gateway");
+  if (!fs11.existsSync(drizzleConfigDir)) {
+    fs11.mkdirSync(drizzleConfigDir, { recursive: true });
   }
   const storeJson = generateStoreJson(postgresInstances);
-  const storeJsonPath = path11.join(drizzleConfigDir, "store.json");
-  fs10.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
+  const storeJsonPath = path12.join(drizzleConfigDir, "store.json");
+  fs11.writeFileSync(storeJsonPath, JSON.stringify(storeJson, null, 2));
   writeLog("drizzle-gateway", `Starting Drizzle Gateway`);
   writeLog("drizzle-gateway", `STORE_PATH: ${drizzleConfigDir}`);
   writeLog("drizzle-gateway", `PORT: ${port}`);
@@ -187063,9 +187166,9 @@ function watchConfigFile(configPath, debounceMs, onChange) {
 }
 
 // src/lib/dev/proxy-registry.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
-import * as os4 from "os";
+import * as fs12 from "fs";
+import * as path13 from "path";
+import * as os5 from "os";
 var ProxyRegistryManager = class {
   proxyDir;
   ownerPath;
@@ -187074,14 +187177,14 @@ var ProxyRegistryManager = class {
   isOwner = false;
   registryWatcher = null;
   constructor() {
-    this.proxyDir = path12.join(os4.homedir(), ".specific", "proxy");
-    this.ownerPath = path12.join(this.proxyDir, "owner.json");
-    this.registryPath = path12.join(this.proxyDir, "registry.json");
-    this.lockPath = path12.join(this.proxyDir, "registry.lock");
+    this.proxyDir = path13.join(os5.homedir(), ".specific", "proxy");
+    this.ownerPath = path13.join(this.proxyDir, "owner.json");
+    this.registryPath = path13.join(this.proxyDir, "registry.json");
+    this.lockPath = path13.join(this.proxyDir, "registry.lock");
   }
   ensureProxyDir() {
-    if (!fs11.existsSync(this.proxyDir)) {
-      fs11.mkdirSync(this.proxyDir, { recursive: true });
+    if (!fs12.existsSync(this.proxyDir)) {
+      fs12.mkdirSync(this.proxyDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -187098,15 +187201,15 @@ var ProxyRegistryManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs11.openSync(
+        const fd = fs12.openSync(
           this.lockPath,
-          fs11.constants.O_CREAT | fs11.constants.O_EXCL | fs11.constants.O_WRONLY
+          fs12.constants.O_CREAT | fs12.constants.O_EXCL | fs12.constants.O_WRONLY
         );
-        fs11.writeSync(fd, String(process.pid));
-        fs11.closeSync(fd);
+        fs12.writeSync(fd, String(process.pid));
+        fs12.closeSync(fd);
         return () => {
           try {
-            fs11.unlinkSync(this.lockPath);
+            fs12.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -187115,16 +187218,16 @@ var ProxyRegistryManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs11.readFileSync(this.lockPath, "utf-8").trim(),
+              fs12.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs11.unlinkSync(this.lockPath);
+              fs12.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs11.unlinkSync(this.lockPath);
+              fs12.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
@@ -187144,8 +187247,8 @@ var ProxyRegistryManager = class {
   async claimProxyOwnership(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs11.existsSync(this.ownerPath)) {
-        const content = fs11.readFileSync(this.ownerPath, "utf-8");
+      if (fs12.existsSync(this.ownerPath)) {
+        const content = fs12.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (this.isProcessRunning(ownerFile2.owner.pid)) {
           return false;
@@ -187175,11 +187278,11 @@ var ProxyRegistryManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs11.existsSync(this.ownerPath)) {
-        const content = fs11.readFileSync(this.ownerPath, "utf-8");
+      if (fs12.existsSync(this.ownerPath)) {
+        const content = fs12.readFileSync(this.ownerPath, "utf-8");
         const ownerFile = JSON.parse(content);
         if (ownerFile.owner.pid === process.pid) {
-          fs11.unlinkSync(this.ownerPath);
+          fs12.unlinkSync(this.ownerPath);
         }
       }
       this.isOwner = false;
@@ -187191,12 +187294,12 @@ var ProxyRegistryManager = class {
    * Get the current proxy owner.
    */
   async getProxyOwner() {
-    if (!fs11.existsSync(this.ownerPath)) {
+    if (!fs12.existsSync(this.ownerPath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs11.readFileSync(this.ownerPath, "utf-8");
+      const content = fs12.readFileSync(this.ownerPath, "utf-8");
       const ownerFile = JSON.parse(content);
       if (!this.isProcessRunning(ownerFile.owner.pid)) {
         return null;
@@ -187290,7 +187393,7 @@ var ProxyRegistryManager = class {
    */
   watchRegistry(onChange) {
     this.ensureProxyDir();
-    if (!fs11.existsSync(this.registryPath)) {
+    if (!fs12.existsSync(this.registryPath)) {
       const emptyRegistry = {
         version: 1,
         keys: {},
@@ -187334,13 +187437,13 @@ var ProxyRegistryManager = class {
   async attemptElection(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs11.existsSync(this.ownerPath)) {
-        const content = fs11.readFileSync(this.ownerPath, "utf-8");
+      if (fs12.existsSync(this.ownerPath)) {
+        const content = fs12.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (this.isProcessRunning(ownerFile2.owner.pid)) {
           return false;
         }
-        fs11.unlinkSync(this.ownerPath);
+        fs12.unlinkSync(this.ownerPath);
       }
       const ownerFile = {
         version: 1,
@@ -187358,7 +187461,7 @@ var ProxyRegistryManager = class {
     }
   }
   readRegistry() {
-    if (!fs11.existsSync(this.registryPath)) {
+    if (!fs12.existsSync(this.registryPath)) {
       return {
         version: 1,
         keys: {},
@@ -187366,7 +187469,7 @@ var ProxyRegistryManager = class {
       };
     }
     try {
-      const content = fs11.readFileSync(this.registryPath, "utf-8");
+      const content = fs12.readFileSync(this.registryPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return {
@@ -187379,8 +187482,8 @@ var ProxyRegistryManager = class {
   writeFileAtomic(filePath, data) {
     this.ensureProxyDir();
     const tmpPath = filePath + ".tmp";
-    fs11.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    fs11.renameSync(tmpPath, filePath);
+    fs12.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs12.renameSync(tmpPath, filePath);
   }
 };
 
@@ -187423,6 +187526,7 @@ function DevUI({ instanceKey }) {
     }
   }
   const shuttingDown = useRef(false);
+  const startTimeRef = useRef(null);
   const stateManagerRef = useRef(null);
   const proxyRegistryRef = useRef(null);
   const electricInstancesRef = useRef([]);
@@ -187435,9 +187539,11 @@ function DevUI({ instanceKey }) {
   const resourcesRef = useRef(/* @__PURE__ */ new Map());
   const [reloadTrigger, setReloadTrigger] = useState3(0);
   const [readyToStart, setReadyToStart] = useState3(() => caFilesExist());
-  const shutdown = async () => {
+  const shutdown2 = async () => {
     if (shuttingDown.current) return;
     shuttingDown.current = true;
+    const duration = startTimeRef.current ? Math.round((Date.now() - startTimeRef.current) / 1e3) : void 0;
+    trackEvent("dev_stopped", { duration_seconds: duration });
     writeLog("system", "Shutting down");
     setState((s) => ({ ...s, status: "stopping" }));
     if (electionIntervalRef.current) {
@@ -187544,7 +187650,7 @@ function DevUI({ instanceKey }) {
         }
         process.exit(1);
       }
-      shutdown();
+      shutdown2();
     };
     process.on("SIGINT", handleSignal);
     process.on("SIGTERM", handleSignal);
@@ -187553,12 +187659,18 @@ function DevUI({ instanceKey }) {
       process.off("SIGTERM", handleSignal);
     };
   }, []);
+  useEffect3(() => {
+    if (state.status === "running" && !startTimeRef.current) {
+      startTimeRef.current = Date.now();
+      trackEvent("dev_started");
+    }
+  }, [state.status]);
   useEffect3(() => {
     if (state.status !== "running") return;
-    const configPath = path13.join(process.cwd(), "specific.hcl");
+    const configPath = path14.join(process.cwd(), "specific.hcl");
     const watcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs12.readFileSync(configPath, "utf-8");
+        const hcl = fs13.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           triggerReload();
         }).catch((err) => {
@@ -187624,8 +187736,8 @@ function DevUI({ instanceKey }) {
         }));
         return;
       }
-      const configPath = path13.join(process.cwd(), "specific.hcl");
-      if (!fs12.existsSync(configPath)) {
+      const configPath = path14.join(process.cwd(), "specific.hcl");
+      if (!fs13.existsSync(configPath)) {
         writeLog("system", "Waiting for specific.hcl to appear");
         setState((s) => ({
           ...s,
@@ -187644,7 +187756,7 @@ function DevUI({ instanceKey }) {
       }
       let config2;
       try {
-        const hcl = fs12.readFileSync(configPath, "utf-8");
+        const hcl = fs13.readFileSync(configPath, "utf-8");
         config2 = await parseConfig(hcl);
       } catch (err) {
         setState((s) => ({
@@ -187750,7 +187862,7 @@ function DevUI({ instanceKey }) {
           const drizzleGateway = await startDrizzleGateway(
             postgresResources,
             drizzlePort,
-            path13.join(process.cwd(), ".specific", "keys", instanceKey)
+            path14.join(process.cwd(), ".specific", "keys", instanceKey)
           );
           startedDrizzleGateway = drizzleGateway;
           drizzleGatewayRef.current = drizzleGateway;
@@ -188211,7 +188323,7 @@ function devCommand(instanceKey) {
 
 // src/lib/dev/git-worktree.ts
 import { execSync as execSync2 } from "child_process";
-import * as path14 from "path";
+import * as path15 from "path";
 function isInWorktree() {
   try {
     const commonDir = execSync2("git rev-parse --git-common-dir", {
@@ -188222,8 +188334,8 @@ function isInWorktree() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const resolvedCommonDir = path14.resolve(commonDir);
-    const resolvedGitDir = path14.resolve(gitDir);
+    const resolvedCommonDir = path15.resolve(commonDir);
+    const resolvedGitDir = path15.resolve(gitDir);
     return resolvedCommonDir !== resolvedGitDir;
   } catch {
     return false;
@@ -188238,7 +188350,7 @@ function getWorktreeName() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return path14.basename(gitDir);
+    return path15.basename(gitDir);
   } catch {
     return null;
   }
@@ -188255,30 +188367,30 @@ import Spinner5 from "ink-spinner";
 
 // ../../node_modules/open/index.js
 import process8 from "node:process";
-import path15 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import childProcess3 from "node:child_process";
-import fs17, { constants as fsConstants2 } from "node:fs/promises";
+import fs18, { constants as fsConstants2 } from "node:fs/promises";
 
 // ../../node_modules/wsl-utils/index.js
 import { promisify as promisify2 } from "node:util";
 import childProcess2 from "node:child_process";
-import fs16, { constants as fsConstants } from "node:fs/promises";
+import fs17, { constants as fsConstants } from "node:fs/promises";
 
 // ../../node_modules/is-wsl/index.js
 import process2 from "node:process";
-import os5 from "node:os";
-import fs15 from "node:fs";
+import os6 from "node:os";
+import fs16 from "node:fs";
 
 // ../../node_modules/is-inside-container/index.js
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 
 // ../../node_modules/is-docker/index.js
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs13.statSync("/.dockerenv");
+    fs14.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -188286,7 +188398,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs13.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs14.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -188302,7 +188414,7 @@ function isDocker() {
 var cachedResult;
 var hasContainerEnv = () => {
   try {
-    fs14.statSync("/run/.containerenv");
+    fs15.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -188320,14 +188432,14 @@ var isWsl = () => {
   if (process2.platform !== "linux") {
     return false;
   }
-  if (os5.release().toLowerCase().includes("microsoft")) {
+  if (os6.release().toLowerCase().includes("microsoft")) {
     if (isInsideContainer()) {
       return false;
     }
     return true;
   }
   try {
-    return fs15.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+    return fs16.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
   } catch {
     return false;
   }
@@ -188395,14 +188507,14 @@ var wslDrivesMountPoint = /* @__PURE__ */ (() => {
     const configFilePath = "/etc/wsl.conf";
     let isConfigFileExists = false;
     try {
-      await fs16.access(configFilePath, fsConstants.F_OK);
+      await fs17.access(configFilePath, fsConstants.F_OK);
       isConfigFileExists = true;
     } catch {
     }
     if (!isConfigFileExists) {
       return defaultMountPoint;
     }
-    const configContent = await fs16.readFile(configFilePath, { encoding: "utf8" });
+    const configContent = await fs17.readFile(configFilePath, { encoding: "utf8" });
     const parsedMountPoint = parseMountPointFromConfig(configContent);
     if (parsedMountPoint === void 0) {
       return defaultMountPoint;
@@ -188422,7 +188534,7 @@ var canAccessPowerShell = async () => {
   canAccessPowerShellPromise ??= (async () => {
     try {
       const psPath = await powerShellPath2();
-      await fs16.access(psPath, fsConstants.X_OK);
+      await fs17.access(psPath, fsConstants.X_OK);
       return true;
     } catch {
       return false;
@@ -188586,8 +188698,8 @@ var is_in_ssh_default = isInSsh;
 
 // ../../node_modules/open/index.js
 var fallbackAttemptSymbol = Symbol("fallbackAttempt");
-var __dirname3 = import.meta.url ? path15.dirname(fileURLToPath3(import.meta.url)) : "";
-var localXdgOpenPath = path15.join(__dirname3, "xdg-open");
+var __dirname3 = import.meta.url ? path16.dirname(fileURLToPath3(import.meta.url)) : "";
+var localXdgOpenPath = path16.join(__dirname3, "xdg-open");
 var { platform: platform4, arch: arch2 } = process8;
 var tryEachApp = async (apps2, opener) => {
   if (apps2.length === 0) {
@@ -188735,7 +188847,7 @@ var baseOpen = async (options2) => {
       const isBundled = !__dirname3 || __dirname3 === "/";
       let exeLocalXdgOpen = false;
       try {
-        await fs17.access(localXdgOpenPath, fsConstants2.X_OK);
+        await fs18.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {
       }
@@ -188872,30 +188984,30 @@ import * as path19 from "path";
 
 // src/lib/deploy/build-tester.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync15 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join17 } from "path";
 function getDependencyInstallCommand(build, projectDir) {
   switch (build.base) {
     case "node":
-      if (existsSync15(join16(projectDir, "pnpm-lock.yaml"))) {
+      if (existsSync16(join17(projectDir, "pnpm-lock.yaml"))) {
         return "pnpm install --frozen-lockfile";
-      } else if (existsSync15(join16(projectDir, "yarn.lock"))) {
+      } else if (existsSync16(join17(projectDir, "yarn.lock"))) {
         return "yarn install --frozen-lockfile";
-      } else if (existsSync15(join16(projectDir, "package-lock.json"))) {
+      } else if (existsSync16(join17(projectDir, "package-lock.json"))) {
         return "npm ci";
       } else {
         return "npm install";
       }
     case "python":
-      if (existsSync15(join16(projectDir, "poetry.lock"))) {
+      if (existsSync16(join17(projectDir, "poetry.lock"))) {
         return "poetry install --no-interaction";
-      } else if (existsSync15(join16(projectDir, "Pipfile.lock"))) {
+      } else if (existsSync16(join17(projectDir, "Pipfile.lock"))) {
         return "pipenv install --deploy";
-      } else if (existsSync15(join16(projectDir, "Pipfile"))) {
+      } else if (existsSync16(join17(projectDir, "Pipfile"))) {
         return "pipenv install";
-      } else if (existsSync15(join16(projectDir, "pyproject.toml"))) {
+      } else if (existsSync16(join17(projectDir, "pyproject.toml"))) {
         return "pip install .";
-      } else if (existsSync15(join16(projectDir, "requirements.txt"))) {
+      } else if (existsSync16(join17(projectDir, "requirements.txt"))) {
         return "pip install -r requirements.txt";
       }
       return null;
@@ -189287,12 +189399,40 @@ var ApiClient = class {
     }
     return response.json();
   }
+  async getMe(signal) {
+    const url = `${this.baseUrl}/users/me`;
+    writeLog("api", `GET ${url}`);
+    const response = await fetch(url, {
+      headers: this.authHeaders(),
+      signal
+    });
+    writeLog("api", `Response: ${response.status} ${response.statusText}`);
+    if (!response.ok) {
+      let errorBody;
+      try {
+        const error = await response.json();
+        errorBody = JSON.stringify(error);
+        writeLog("api:error", `API error: ${error.error} (${error.code})`);
+        writeLog("api:error", `Request was: GET ${url}`);
+        writeLog("api:error", `Response body: ${errorBody}`);
+        throw new Error(`Failed to get user: ${error.error} (${error.code})`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("Failed to get user")) {
+          throw e;
+        }
+        errorBody = await response.text();
+        writeLog("api:error", `Failed to parse error response: ${errorBody}`);
+        throw new Error(`Failed to get user: ${response.statusText}`);
+      }
+    }
+    return response.json();
+  }
 };
 
 // src/lib/tarball/create.ts
 import { execSync as execSync3 } from "child_process";
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
 function isInsideGitRepository(dir) {
   try {
@@ -189338,10 +189478,10 @@ async function createGitArchive(projectDir) {
 var EXCLUDED_DIRS = [".specific"];
 async function collectPaths(baseDir, currentDir, exclude) {
   const results = [];
-  const entries = await fs18.promises.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs19.promises.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path16.join(currentDir, entry.name);
-    const relativePath = path16.relative(baseDir, fullPath);
+    const fullPath = path17.join(currentDir, entry.name);
+    const relativePath = path17.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (!exclude.includes(entry.name)) {
         results.push(relativePath);
@@ -189356,8 +189496,8 @@ async function collectPaths(baseDir, currentDir, exclude) {
 }
 async function createTarArchive(projectDir) {
   writeLog("tarball", "Creating tarball using tar-vern (non-git project)");
-  const configPath = path16.join(projectDir, "specific.hcl");
-  if (!fs18.existsSync(configPath)) {
+  const configPath = path17.join(projectDir, "specific.hcl");
+  if (!fs19.existsSync(configPath)) {
     throw new Error("specific.hcl not found in project directory");
   }
   const relativePaths = await collectPaths(projectDir, projectDir, EXCLUDED_DIRS);
@@ -189379,49 +189519,10 @@ async function createProjectTarball(projectDir) {
   return createTarArchive(projectDir);
 }
 
-// src/lib/project/config.ts
-import * as fs19 from "fs";
-import * as path17 from "path";
-var PROJECT_ID_FILE = ".specific/project_id";
-var ProjectNotLinkedError = class extends Error {
-  constructor() {
-    super(
-      `Project not linked to Specific.
-
-The file ${PROJECT_ID_FILE} does not exist.
-
-Run: specific deploy`
-    );
-    this.name = "ProjectNotLinkedError";
-  }
-};
-function readProjectId(projectDir = process.cwd()) {
-  const projectIdPath = path17.join(projectDir, PROJECT_ID_FILE);
-  if (!fs19.existsSync(projectIdPath)) {
-    throw new ProjectNotLinkedError();
-  }
-  const projectId = fs19.readFileSync(projectIdPath, "utf-8").trim();
-  if (!projectId) {
-    throw new Error(`${PROJECT_ID_FILE} is empty`);
-  }
-  return projectId;
-}
-function hasProjectId(projectDir = process.cwd()) {
-  const projectIdPath = path17.join(projectDir, PROJECT_ID_FILE);
-  return fs19.existsSync(projectIdPath);
-}
-function writeProjectId(projectId, projectDir = process.cwd()) {
-  const specificDir = path17.join(projectDir, ".specific");
-  if (!fs19.existsSync(specificDir)) {
-    fs19.mkdirSync(specificDir, { recursive: true });
-  }
-  fs19.writeFileSync(path17.join(specificDir, "project_id"), projectId + "\n");
-}
-
 // src/lib/auth/credentials.ts
 import * as fs20 from "fs";
 import * as path18 from "path";
-import * as os6 from "os";
+import * as os7 from "os";
 
 // src/lib/auth/errors.ts
 var RefreshTokenExpiredError = class extends Error {
@@ -189560,10 +189661,14 @@ function LoginFlow({ isReauthentication, onComplete }) {
               }
             } else {
               const successResponse = response;
+              const expiresAt2 = Date.now() + successResponse.expires_in * 1e3;
+              const client2 = new ApiClient(successResponse.access_token);
+              const user = await client2.getMe();
               writeUserCredentials({
                 accessToken: successResponse.access_token,
                 refreshToken: successResponse.refresh_token,
-                expiresAt: Date.now() + successResponse.expires_in * 1e3
+                expiresAt: expiresAt2,
+                userId: user.id
               });
               setUserEmail(successResponse.user.email);
               setPhase("success");
@@ -189612,7 +189717,7 @@ function LoginFlow({ isReauthentication, onComplete }) {
 
 // src/lib/auth/credentials.ts
 function getUserCredentialsDir() {
-  return path18.join(os6.homedir(), ".specific");
+  return path18.join(os7.homedir(), ".specific");
 }
 function getCredentialsPath() {
   return path18.join(getUserCredentialsDir(), "credentials.json");
@@ -189899,8 +190004,8 @@ function DeployUI({ environment, config, skipBuildTest }) {
     async function loadProjects() {
       try {
         const token = await getValidAccessToken();
-        const client = new ApiClient(token);
-        const { projects: projects2 } = await client.listProjects();
+        const client2 = new ApiClient(token);
+        const { projects: projects2 } = await client2.listProjects();
         if (cancelled) return;
         setState({
           phase: "selecting-project",
@@ -189946,8 +190051,8 @@ function DeployUI({ environment, config, skipBuildTest }) {
     async function createProject() {
       try {
         const token = await getValidAccessToken();
-        const client = new ApiClient(token);
-        const project = await client.createProject(state.newProjectName);
+        const client2 = new ApiClient(token);
+        const project = await client2.createProject(state.newProjectName);
         if (cancelled) return;
         writeProjectId(project.id);
         setState({
@@ -190040,15 +190145,15 @@ function DeployUI({ environment, config, skipBuildTest }) {
       (secret) => secretValues[secret]
     );
     if (!allSecretsCollected) return;
-    const client = clientRef.current;
-    if (!client) return;
+    const client2 = clientRef.current;
+    if (!client2) return;
     (async () => {
       try {
         writeLog(
           "deploy",
           `Submitting secrets: ${Object.keys(secretValues).join(", ")}`
         );
-        await client.submitSecrets(deployment2.id, secretValues);
+        await client2.submitSecrets(deployment2.id, secretValues);
         writeLog("deploy", "Secrets submitted successfully");
         setState((s) => ({
           ...s,
@@ -190082,15 +190187,15 @@ function DeployUI({ environment, config, skipBuildTest }) {
       (config2) => configValues[config2]
     );
     if (!allConfigsCollected) return;
-    const client = clientRef.current;
-    if (!client) return;
+    const client2 = clientRef.current;
+    if (!client2) return;
     (async () => {
       try {
         writeLog(
           "deploy",
           `Submitting configs: ${Object.keys(configValues).join(", ")}`
         );
-        await client.submitConfigs(deployment2.id, configValues);
+        await client2.submitConfigs(deployment2.id, configValues);
         writeLog("deploy", "Configs submitted successfully");
         setState((s) => ({
           ...s,
@@ -190112,58 +190217,47 @@ function DeployUI({ environment, config, skipBuildTest }) {
   useEffect5(() => {
     if (state.phase !== "testing-builds" || !state.projectId) return;
     let cancelled = false;
-    async function runBuildTests() {
+    let pollInterval;
+    async function runBuildTestsAndDeploy() {
       const projectDir = process.cwd();
       const builds = config.builds || [];
-      if (skipBuildTest || builds.length === 0) {
-        writeLog("deploy", skipBuildTest ? "Skipping build tests (--skip-build-test)" : "No builds to test");
-        setState((s) => ({ ...s, phase: "creating-tarball" }));
-        return;
-      }
-      writeLog("deploy", `Testing ${builds.length} build(s) locally`);
-      try {
-        const results = await testAllBuilds(builds, projectDir);
-        if (cancelled) return;
-        if (!results.allPassed) {
-          const failures = results.results.filter((r) => !r.success);
-          const errorMsg = failures.map((f) => `Build "${f.buildName}" failed:
+      if (!skipBuildTest && builds.length > 0) {
+        writeLog("deploy", `Testing ${builds.length} build(s) locally`);
+        try {
+          const results = await testAllBuilds(builds, projectDir);
+          if (cancelled) return;
+          if (!results.allPassed) {
+            const failures = results.results.filter((r) => !r.success);
+            const errorMsg = failures.map((f) => `Build "${f.buildName}" failed:
 ${f.output}`).join("\n\n");
+            writeLog("deploy:error", errorMsg);
+            setState({
+              phase: "error",
+              error: `Build test failed:
+${errorMsg}`
+            });
+            return;
+          }
+          writeLog("deploy", "All builds passed local testing");
+        } catch (err) {
+          if (cancelled) return;
+          const errorMsg = `Build test failed: ${err instanceof Error ? err.message : String(err)}`;
           writeLog("deploy:error", errorMsg);
           setState({
             phase: "error",
-            error: `Build test failed:
-${errorMsg}`
+            error: errorMsg
           });
           return;
         }
-        writeLog("deploy", "All builds passed local testing");
-        setState((s) => ({ ...s, phase: "creating-tarball" }));
-      } catch (err) {
-        if (cancelled) return;
-        const errorMsg = `Build test failed: ${err instanceof Error ? err.message : String(err)}`;
-        writeLog("deploy:error", errorMsg);
-        setState({
-          phase: "error",
-          error: errorMsg
-        });
+      } else {
+        writeLog("deploy", skipBuildTest ? "Skipping build tests (--skip-build-test)" : "No builds to test");
       }
-    }
-    runBuildTests();
-    return () => {
-      cancelled = true;
-    };
-  }, [state.phase, state.projectId, config.builds, skipBuildTest]);
-  useEffect5(() => {
-    if (state.phase !== "creating-tarball" || !state.projectId) return;
-    let cancelled = false;
-    let pollInterval;
-    async function deploy() {
-      const projectDir = process.cwd();
+      setState((s) => ({ ...s, phase: "creating-tarball" }));
       writeLog("deploy", `Starting deployment to "${environment}"`);
       writeLog("deploy", `Project directory: ${projectDir}`);
       const authToken = await getValidAccessToken();
-      const client = new ApiClient(authToken);
-      clientRef.current = client;
+      const client2 = new ApiClient(authToken);
+      clientRef.current = client2;
       if (cancelled) return;
       let tarball;
       try {
@@ -190188,7 +190282,7 @@ ${errorMsg}`
       let deployment2;
       try {
         writeLog("deploy", `Creating deployment for project ${state.projectId}`);
-        deployment2 = await client.createDeployment(state.projectId, environment);
+        deployment2 = await client2.createDeployment(state.projectId, environment);
         writeLog("deploy", `Deployment created: ${deployment2.id}`);
       } catch (err) {
         const errorMsg = `Failed to create deployment: ${err instanceof Error ? err.message : String(err)}`;
@@ -190203,7 +190297,7 @@ ${errorMsg}`
       setState((s) => ({ ...s, phase: "uploading", deployment: deployment2 }));
       try {
         writeLog("deploy", `Uploading tarball (${tarball.length} bytes)`);
-        deployment2 = await client.uploadTarball(deployment2.id, tarball);
+        deployment2 = await client2.uploadTarball(deployment2.id, tarball);
         writeLog("deploy", "Tarball uploaded successfully");
       } catch (err) {
         const errorMsg = `Failed to upload tarball: ${err instanceof Error ? err.message : String(err)}`;
@@ -190222,7 +190316,7 @@ ${errorMsg}`
       let lastState;
       const pollForCompletion = async () => {
         try {
-          const status = await client.getDeployment(deployment2.id);
+          const status = await client2.getDeployment(deployment2.id);
           if (cancelled) return;
           if (status.state !== lastState) {
             writeLog(
@@ -190299,20 +190393,20 @@ ${errorMsg}`
       pollInterval = setInterval(pollForCompletion, 2e3);
       pollForCompletion();
     }
-    deploy();
+    runBuildTestsAndDeploy();
     return () => {
       cancelled = true;
       if (pollInterval) clearInterval(pollInterval);
     };
-  }, [state.projectId, environment]);
+  }, [state.projectId, environment, config.builds, skipBuildTest]);
   useEffect5(() => {
     let pollInterval;
     if ((state.phase === "building" || state.phase === "deploying") && state.deployment && state.missingSecrets === void 0 && state.secretValues === void 0 && state.missingConfigs === void 0 && state.configValues === void 0) {
-      const client = clientRef.current;
-      if (!client) return;
+      const client2 = clientRef.current;
+      if (!client2) return;
       const pollForCompletion = async () => {
         try {
-          const status = await client.getDeployment(state.deployment.id);
+          const status = await client2.getDeployment(state.deployment.id);
           if (status.state === "failed") {
             setState((s) => ({
               ...s,
@@ -190344,12 +190438,24 @@ ${errorMsg}`
     }
   }, [state.phase, state.missingSecrets, state.secretValues, state.missingConfigs, state.configValues]);
   useEffect5(() => {
-    if (state.phase === "success" || state.phase === "error") {
+    if (state.phase === "testing-builds") {
+      trackEvent("deploy_started", { environment });
+    }
+  }, [state.phase, environment]);
+  useEffect5(() => {
+    if (state.phase === "success") {
+      trackEvent("deploy_succeeded", { environment });
       closeDebugLog();
       const timer = setTimeout(() => exit(), 100);
       return () => clearTimeout(timer);
     }
-  }, [state.phase, exit]);
+    if (state.phase === "error") {
+      trackEvent("deploy_failed", { environment });
+      closeDebugLog();
+      const timer = setTimeout(() => exit(), 100);
+      return () => clearTimeout(timer);
+    }
+  }, [state.phase, exit, environment]);
   const {
     phase,
     deployment,
@@ -191174,7 +191280,7 @@ function logoutCommand() {
 var program = new Command();
 var env = "production";
 var envLabel = env !== "production" ? `[${env.toUpperCase()}] ` : "";
-program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.38").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.40").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").action(initCommand);
 program.command("docs [topic]").description("Fetch LLM-optimized documentation").action(docsCommand);
 program.command("check").description("Validate specific.hcl configuration").action(checkCommand);
@@ -191201,6 +191307,11 @@ program.command("secrets [action] [name]").description("Manage secrets").action(
 program.command("config [action] [name] [value]").description("Manage configuration values").action(configCommand);
 program.command("login").description("Log in to Specific").action(loginCommand);
 program.command("logout").description("Log out of Specific").action(logoutCommand);
+var commandName = process.argv[2] || "help";
+trackEvent("cli_command_invoked", { command: commandName });
+process.on("beforeExit", async () => {
+  await shutdown();
+});
 program.parse();
 /*! Bundled license information: