@specific.dev/cli 0.1.58 → 0.1.60

package/dist/cli.js

@@ -183873,7 +183873,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.58",
+      cli_version: "0.1.60",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),
@@ -189380,29 +189380,133 @@ var StableSubdomainAllocator = class {
   }
 };
 
+// node_modules/.pnpm/@specific+tunnel-client@file+..+tunnel+client/node_modules/@specific/tunnel-client/dist/index.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+import * as net4 from "node:net";
+var DEFAULT_HOST = "https://tunnel.spcf.app";
+async function register(baseUrl, subdomain) {
+  const res = await fetch(`${baseUrl}/${subdomain}`);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Registration failed (${res.status}): ${body}`);
+  }
+  return await res.json();
+}
+var TunnelClientImpl = class extends EventEmitter2 {
+  info;
+  localPort;
+  tunnelHost;
+  url;
+  subdomain;
+  pool = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(info, localPort, tunnelHost) {
+    super();
+    this.info = info;
+    this.localPort = localPort;
+    this.tunnelHost = tunnelHost;
+    this.url = info.url;
+    this.subdomain = info.id;
+    this.fillPool();
+  }
+  close() {
+    this.closed = true;
+    for (const c of this.pool)
+      c.destroy();
+    this.pool.clear();
+  }
+  fillPool() {
+    while (!this.closed && this.pool.size < this.info.max_conn_count) {
+      this.addPoolConnection();
+    }
+  }
+  addPoolConnection() {
+    const remote = net4.connect({ host: this.tunnelHost, port: this.info.port });
+    remote.setKeepAlive(true, 3e4);
+    this.pool.add(remote);
+    remote.once("data", (firstChunk) => {
+      this.pool.delete(remote);
+      this.pipeToLocal(remote, firstChunk);
+    });
+    let errored = false;
+    remote.on("error", (err) => {
+      errored = true;
+      this.emit("error", err);
+    });
+    remote.on("close", () => this.onIdleClose(remote, errored));
+  }
+  pipeToLocal(remote, firstChunk) {
+    const local = net4.connect({ host: "127.0.0.1", port: this.localPort }, () => {
+      local.write(firstChunk);
+      remote.pipe(local);
+      local.pipe(remote);
+    });
+    local.on("error", () => remote.destroy());
+    remote.on("close", () => {
+      if (!this.closed)
+        this.fillPool();
+    });
+  }
+  onIdleClose(remote, errored) {
+    if (!this.pool.delete(remote) || this.closed)
+      return;
+    if (errored) {
+      if (this.pool.size === 0)
+        this.emit("close");
+    } else {
+      this.fillPool();
+    }
+  }
+};
+async function connect2(options2) {
+  const host = options2.host ?? DEFAULT_HOST;
+  const tunnelHost = new URL(host).hostname;
+  const info = await register(host, options2.subdomain);
+  return new TunnelClientImpl(info, options2.port, tunnelHost);
+}
+
 // src/lib/dev/tunnel-manager.ts
-import localtunnel from "localtunnel";
 var TUNNEL_HOST = "https://tunnel.spcf.app";
 async function startTunnel(serviceName, endpointName, port, subdomain, callbacks) {
-  const tunnel = await localtunnel({
-    port,
-    subdomain,
-    host: TUNNEL_HOST
-  });
-  tunnel.on("error", (err) => {
-    callbacks?.onError?.(serviceName, endpointName, err);
-  });
-  tunnel.on("close", () => {
-    callbacks?.onClose?.(serviceName, endpointName);
-  });
+  let currentTunnel = null;
+  let stopped = false;
+  function setupTunnel(tunnel) {
+    tunnel.on("error", (err) => {
+      callbacks?.onError?.(serviceName, endpointName, err);
+    });
+    tunnel.on("close", () => {
+      if (!stopped) {
+        callbacks?.onClose?.(serviceName, endpointName);
+        reconnect();
+      }
+    });
+  }
+  async function reconnect() {
+    const delays = [1e3, 2e3, 4e3, 8e3, 15e3];
+    for (let attempt = 0; !stopped; attempt++) {
+      const delay = delays[Math.min(attempt, delays.length - 1)];
+      await new Promise((r) => setTimeout(r, delay));
+      if (stopped) return;
+      try {
+        currentTunnel = await connect2({ port, subdomain, host: TUNNEL_HOST });
+        setupTunnel(currentTunnel);
+        callbacks?.onReconnect?.(serviceName, endpointName);
+        return;
+      } catch {
+      }
+    }
+  }
+  currentTunnel = await connect2({ port, subdomain, host: TUNNEL_HOST });
+  setupTunnel(currentTunnel);
   return {
     serviceName,
     endpointName,
     localPort: port,
-    url: tunnel.url,
+    url: currentTunnel.url,
     subdomain,
     stop: async () => {
-      tunnel.close();
+      stopped = true;
+      currentTunnel?.close();
     }
   };
 }
@@ -189411,7 +189515,7 @@ async function startTunnel(serviceName, endpointName, port, subdomain, callbacks
 import * as fs20 from "fs";
 import * as path17 from "path";
 import * as os7 from "os";
-import * as net4 from "net";
+import * as net5 from "net";
 var ProxyRegistryManager = class {
   proxyDir;
   ownerPath;
@@ -189445,7 +189549,7 @@ var ProxyRegistryManager = class {
    */
   isProxyListening(port, timeoutMs = 1e3) {
     return new Promise((resolve10) => {
-      const socket = new net4.Socket();
+      const socket = new net5.Socket();
       let resolved = false;
       const cleanup = () => {
         if (!resolved) {
@@ -189997,9 +190101,6 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       // Stop all tunnels
       ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
-    if (tunnelsRef.current.length > 0) {
-      await new Promise((resolve10) => setTimeout(resolve10, 1500));
-    }
     electricInstancesRef.current = [];
     reshapeWatchersRef.current = [];
     restartServicesRef.current = null;
@@ -190039,7 +190140,8 @@ function DevUI({ instanceKey, tunnelEnabled }) {
           ...servicesRef.current,
           ...electricInstancesRef.current,
           drizzleGatewayRef.current,
-          ...[...resourcesRef.current.values()]
+          ...[...resourcesRef.current.values()],
+          ...tunnelsRef.current
         ].filter(Boolean);
         for (const proc of allProcesses) {
           try {
@@ -190052,11 +190154,20 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       }
       shutdown2();
     };
+    const handleCrash = (err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      writeLog("system:error", `Uncaught error: ${msg}`);
+      shutdown2();
+    };
     process.on("SIGINT", handleSignal);
     process.on("SIGTERM", handleSignal);
+    process.on("uncaughtException", handleCrash);
+    process.on("unhandledRejection", handleCrash);
     return () => {
       process.off("SIGINT", handleSignal);
       process.off("SIGTERM", handleSignal);
+      process.off("uncaughtException", handleCrash);
+      process.off("unhandledRejection", handleCrash);
     };
   }, []);
   useEffect3(() => {
@@ -190631,7 +190742,14 @@ Add them to the config block in specific.local`);
                     writeLog("system:error", `Tunnel error for ${serviceName}: ${error.message}`);
                   },
                   onClose: (serviceName) => {
-                    writeLog("system", `Tunnel closed for ${serviceName}`);
+                    writeLog("system", `Tunnel closed for ${serviceName}, reconnecting...`);
+                    tunnelStatusMap.set(serviceName, "connecting");
+                    setState((s) => ({ ...s, tunnelStatus: new Map(tunnelStatusMap) }));
+                  },
+                  onReconnect: (serviceName) => {
+                    writeLog("system", `Tunnel reconnected for ${serviceName}`);
+                    tunnelStatusMap.set(serviceName, "connected");
+                    setState((s) => ({ ...s, tunnelStatus: new Map(tunnelStatusMap) }));
                   }
                 }
               );
@@ -193065,7 +193183,7 @@ function betaCommand() {
 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.58").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.60").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);

package/dist/postinstall.js

@@ -111,7 +111,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.58",
+      cli_version: "0.1.60",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/cli",
-  "version": "0.1.58",
+  "version": "0.1.60",
   "description": "CLI for Specific infrastructure-as-code",
   "type": "module",
   "main": "dist/cli.js",
@@ -41,7 +41,6 @@
     "http-proxy": "^1.18.1",
     "ink": "^6.5.1",
     "ink-spinner": "^5.0.0",
-    "localtunnel": "^2.0.2",
     "node-forge": "^1.3.1",
     "open": "^11.0.0",
     "posthog-node": "^5.24.1",
@@ -52,8 +51,8 @@
   },
   "devDependencies": {
     "@specific/config": "file:../config",
+    "@specific/tunnel-client": "file:../tunnel/client",
     "@types/http-proxy": "^1.17.17",
-    "@types/localtunnel": "^2.0.4",
     "@types/node": "^25.0.1",
     "@types/node-forge": "^1.3.11",
     "@types/react": "^19.2.7",