@cimplify/cli 0.12.0 → 0.12.2

package/dist/{chunk-EL34CORK.mjs → chunk-7P2OGMZ4.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { gitDetectRoot, gitCurrentBranch, gitCurrentSha, gitStatusPorcelain } from './chunk-K5464A3L.mjs';
 import { parseEnvFile } from './chunk-DBZ3UOQ2.mjs';
-import { package_default } from './chunk-W64GWXPF.mjs';
+import { package_default } from './chunk-PVHB2MHV.mjs';
 import { parseArgs } from './chunk-C4M3DXKC.mjs';
 import { readAuthOrNull, readProjectLinkOrNull, readProjectState } from './chunk-UBAI443T.mjs';
 import { bold, dim, yellow, green, info, result, red } from './chunk-E2T2SBP5.mjs';

package/dist/{chunk-W64GWXPF.mjs → chunk-PVHB2MHV.mjs}

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@cimplify/cli",
-  version: "0.12.0",
+  version: "0.12.2",
   description: "Cimplify CLI \u2014 deploy, manage env vars, link projects, and scaffold storefronts",
   keywords: [
     "cimplify",

package/dist/{dev-3TPDHU67.mjs → dev-5MB2BJ6L.mjs}

@@ -6,8 +6,8 @@ import { ApiClient } from './chunk-F4S5KETY.mjs';
 import { readAuth, readProjectLink } from './chunk-UBAI443T.mjs';
 import { info, CliError, CLI_ERROR_CODE, dim } from './chunk-E2T2SBP5.mjs';
 import { spawn } from 'child_process';
-import { promises } from 'fs';
-import path2 from 'path';
+import { promises, watch } from 'fs';
+import path from 'path';
 import http from 'http';
 
 // src/tunnel/v2/codec.ts
@@ -367,6 +367,410 @@ function sendableCloseCode(code) {
   return legal ? code : void 0;
 }
 
+// src/tunnel/v2/control-protocol.ts
+var CONTROL_KIND = "control";
+var LENGTH_PREFIX_BYTES = 4;
+var MAX_MESSAGE_BYTES = 32 * 1024 * 1024;
+var CONTROL_OP = {
+  READ: "read",
+  WRITE: "write",
+  DELETE: "delete",
+  LIST: "list",
+  LIST_TREE: "list_tree",
+  STAT: "stat",
+  MKDIR: "mkdir",
+  RENAME: "rename",
+  WATCH_START: "watch_start",
+  WATCH_STOP: "watch_stop",
+  EXEC: "exec"
+};
+var CONTROL_ERROR = {
+  NOT_FOUND: "not_found",
+  INVALID_PATH: "invalid_path",
+  PERMISSION_DENIED: "permission_denied",
+  IO: "io",
+  UNSUPPORTED: "unsupported"};
+var WATCH_EVENT = {
+  ADD: "add",
+  CHANGE: "change",
+  REMOVE: "remove",
+  RESYNC: "resync"
+};
+var ENCODING = {
+  UTF8: "utf8",
+  BASE64: "base64"
+};
+var ControlProtocolError = class extends Error {
+};
+var textEncoder3 = new TextEncoder();
+var textDecoder2 = new TextDecoder();
+function encodeMessage(message) {
+  const json = textEncoder3.encode(JSON.stringify(message));
+  if (json.length > MAX_MESSAGE_BYTES) {
+    throw new ControlProtocolError(`control message ${json.length} exceeds ${MAX_MESSAGE_BYTES}`);
+  }
+  const framed = new Uint8Array(LENGTH_PREFIX_BYTES + json.length);
+  new DataView(framed.buffer).setUint32(0, json.length);
+  framed.set(json, LENGTH_PREFIX_BYTES);
+  return framed;
+}
+function isRequest(message) {
+  return typeof message.op === "string";
+}
+var MessageFramer = class {
+  // Annotated Uint8Array (ArrayBufferLike) so concat/subarray/slice results
+  // assign back cleanly under TS 5.7's Uint8Array<ArrayBuffer> generic.
+  buffer = new Uint8Array(0);
+  push(bytes) {
+    this.buffer = concat(this.buffer, bytes);
+    const messages = [];
+    for (; ; ) {
+      if (this.buffer.length < LENGTH_PREFIX_BYTES) break;
+      const length = new DataView(
+        this.buffer.buffer,
+        this.buffer.byteOffset,
+        LENGTH_PREFIX_BYTES
+      ).getUint32(0);
+      if (length > MAX_MESSAGE_BYTES) {
+        throw new ControlProtocolError(`framed length ${length} exceeds ${MAX_MESSAGE_BYTES}`);
+      }
+      if (this.buffer.length < LENGTH_PREFIX_BYTES + length) break;
+      const jsonBytes = this.buffer.subarray(LENGTH_PREFIX_BYTES, LENGTH_PREFIX_BYTES + length);
+      messages.push(JSON.parse(textDecoder2.decode(jsonBytes)));
+      this.buffer = this.buffer.subarray(LENGTH_PREFIX_BYTES + length);
+    }
+    if (this.buffer.byteOffset > 0) this.buffer = this.buffer.slice();
+    return messages;
+  }
+};
+function concat(a, b) {
+  if (a.length === 0) return b;
+  if (b.length === 0) return a;
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+
+// src/tunnel/v2/control-agent.ts
+var DEFAULT_IGNORED = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".turbo",
+  ".cache",
+  ".cimplify"
+]);
+var ControlFsError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var ControlKind = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  kind = CONTROL_KIND;
+  handle(incoming) {
+    void new ControlSession(incoming.stream, this.deps).run();
+  }
+};
+var ControlSession = class {
+  constructor(stream, deps) {
+    this.stream = stream;
+    this.deps = deps;
+  }
+  stream;
+  deps;
+  framer = new MessageFramer();
+  watch = null;
+  epoch = 0;
+  seq = 0;
+  // Serialize all writes so message bytes never interleave and event order
+  // (which carries seq) is preserved.
+  sending = Promise.resolve();
+  async run() {
+    try {
+      for (; ; ) {
+        const event = await this.stream.recv();
+        if (event === null) return;
+        if (event.type === "data") {
+          for (const message of this.framer.push(event.payload)) {
+            if (isRequest(message)) void this.dispatch(message);
+          }
+        } else if (event.type === "end") {
+          continue;
+        } else {
+          return;
+        }
+      }
+    } finally {
+      this.watch?.stop();
+    }
+  }
+  send(message) {
+    const bytes = encodeMessage(message);
+    this.sending = this.sending.then(() => this.stream.data(bytes).catch(() => {
+    }));
+  }
+  async dispatch(request) {
+    try {
+      const data = await this.execute(request);
+      this.send({ id: request.id, ok: true, data });
+    } catch (error) {
+      const code = error instanceof ControlFsError ? error.code : CONTROL_ERROR.IO;
+      const message = error instanceof Error ? error.message : String(error);
+      this.send({ id: request.id, ok: false, error: { code, message } });
+    }
+  }
+  async execute(request) {
+    const { fs: backend } = this.deps;
+    switch (request.op) {
+      case CONTROL_OP.READ:
+        return backend.read(str(request, FIELD.PATH));
+      case CONTROL_OP.WRITE:
+        await backend.write(str(request, FIELD.PATH), str(request, FIELD.CONTENT), enc(request));
+        return {};
+      case CONTROL_OP.DELETE:
+        await backend.delete(str(request, FIELD.PATH), request.recursive === true);
+        return {};
+      case CONTROL_OP.LIST:
+        return { entries: await backend.list(str(request, FIELD.PATH)) };
+      case CONTROL_OP.LIST_TREE:
+        return { paths: await backend.listTree() };
+      case CONTROL_OP.STAT:
+        return await backend.stat(str(request, FIELD.PATH));
+      case CONTROL_OP.MKDIR:
+        await backend.mkdir(str(request, FIELD.PATH));
+        return {};
+      case CONTROL_OP.RENAME:
+        await backend.rename(str(request, FIELD.FROM), str(request, FIELD.TO));
+        return {};
+      case CONTROL_OP.WATCH_START:
+        return this.startWatch(request);
+      case CONTROL_OP.WATCH_STOP:
+        this.watch?.stop();
+        this.watch = null;
+        return {};
+      case CONTROL_OP.EXEC:
+        return this.deps.exec.run(execCommand(request));
+      default:
+        throw new ControlFsError(CONTROL_ERROR.UNSUPPORTED, `unknown op ${request.op}`);
+    }
+  }
+  startWatch(request) {
+    this.watch?.stop();
+    this.epoch += 1;
+    this.seq = 0;
+    const epoch = this.epoch;
+    const paths = Array.isArray(request.paths) ? request.paths : [WORKSPACE_ROOT];
+    this.watch = this.deps.watcher.start(
+      paths,
+      (type, changed) => {
+        if (this.epoch !== epoch) return;
+        this.seq += 1;
+        this.send({ event: type, paths: changed, seq: this.seq, epoch });
+      },
+      () => {
+        if (this.epoch !== epoch) return;
+        this.send({ event: WATCH_EVENT.RESYNC, epoch });
+      }
+    );
+    return { epoch };
+  }
+};
+var WORKSPACE_ROOT = ".";
+var FIELD = {
+  PATH: "path",
+  CONTENT: "content",
+  FROM: "from",
+  TO: "to"
+};
+function str(request, field) {
+  const value = request[field];
+  if (typeof value !== "string") {
+    throw new ControlFsError(CONTROL_ERROR.INVALID_PATH, `missing string field '${field}'`);
+  }
+  return value;
+}
+function enc(request) {
+  return request.encoding === ENCODING.BASE64 ? ENCODING.BASE64 : ENCODING.UTF8;
+}
+function execCommand(request) {
+  const command = request.command;
+  if (typeof command === "string") return command;
+  if (Array.isArray(command) && command.every((part) => typeof part === "string")) {
+    return command;
+  }
+  throw new ControlFsError(CONTROL_ERROR.INVALID_PATH, "exec requires a command");
+}
+function resolveInRoot(root, rel) {
+  const resolved = path.resolve(root, rel);
+  const rootWithSep = root.endsWith(path.sep) ? root : root + path.sep;
+  if (resolved !== root && !resolved.startsWith(rootWithSep)) {
+    throw new ControlFsError(CONTROL_ERROR.INVALID_PATH, `path escapes workspace: ${rel}`);
+  }
+  return resolved;
+}
+function isIgnored(rel) {
+  return rel.split(/[\\/]/).some((segment) => DEFAULT_IGNORED.has(segment));
+}
+var NodeControlFs = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  async read(rel) {
+    const abs = resolveInRoot(this.root, rel);
+    const bytes = await promises.readFile(abs).catch(rethrow(rel));
+    const text = tryDecodeUtf8(bytes);
+    return text !== null ? { content: text, encoding: ENCODING.UTF8 } : { content: Buffer.from(bytes).toString("base64"), encoding: ENCODING.BASE64 };
+  }
+  async write(rel, content, encoding) {
+    const abs = resolveInRoot(this.root, rel);
+    await promises.mkdir(path.dirname(abs), { recursive: true });
+    const bytes = encoding === ENCODING.BASE64 ? Buffer.from(content, "base64") : Buffer.from(content, "utf8");
+    await promises.writeFile(abs, bytes).catch(rethrow(rel));
+  }
+  async delete(rel, recursive) {
+    const abs = resolveInRoot(this.root, rel);
+    await promises.rm(abs, { recursive, force: true });
+  }
+  async list(rel) {
+    const abs = resolveInRoot(this.root, rel);
+    const dirents = await promises.readdir(abs, { withFileTypes: true }).catch(rethrow(rel));
+    return dirents.filter((d) => !DEFAULT_IGNORED.has(d.name)).map((d) => ({ name: d.name, dir: d.isDirectory() }));
+  }
+  async listTree() {
+    const out = [];
+    const walk = async (dir) => {
+      const dirents = await promises.readdir(path.join(this.root, dir), { withFileTypes: true });
+      for (const dirent of dirents) {
+        if (DEFAULT_IGNORED.has(dirent.name)) continue;
+        const rel = dir ? `${dir}/${dirent.name}` : dirent.name;
+        if (dirent.isDirectory()) await walk(rel);
+        else out.push(rel);
+      }
+    };
+    await walk("");
+    return out;
+  }
+  async stat(rel) {
+    const abs = resolveInRoot(this.root, rel);
+    const stat = await promises.stat(abs).catch(rethrow(rel));
+    return {
+      kind: stat.isDirectory() ? "dir" : "file",
+      size: stat.size,
+      mtimeMs: Math.floor(stat.mtimeMs)
+    };
+  }
+  async mkdir(rel) {
+    await promises.mkdir(resolveInRoot(this.root, rel), { recursive: true });
+  }
+  async rename(from, to) {
+    const absFrom = resolveInRoot(this.root, from);
+    const absTo = resolveInRoot(this.root, to);
+    await promises.mkdir(path.dirname(absTo), { recursive: true });
+    await promises.rename(absFrom, absTo).catch(rethrow(from));
+  }
+};
+var WATCH_DEBOUNCE_MS = 60;
+var NodeControlWatcher = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  start(_relPaths, onEvent, onResync) {
+    let watcher;
+    const pending = /* @__PURE__ */ new Map();
+    const flush = (rel) => {
+      pending.delete(rel);
+      promises.stat(path.join(this.root, rel)).then(
+        (stat) => onEvent(stat.isDirectory() ? WATCH_EVENT.ADD : WATCH_EVENT.CHANGE, [rel]),
+        () => onEvent(WATCH_EVENT.REMOVE, [rel])
+      );
+    };
+    try {
+      watcher = watch(this.root, { recursive: true }, (_type, filename) => {
+        if (filename === null) {
+          onResync();
+          return;
+        }
+        const rel = filename.toString().split(path.sep).join("/");
+        if (isIgnored(rel)) return;
+        const existing = pending.get(rel);
+        if (existing) clearTimeout(existing);
+        pending.set(
+          rel,
+          setTimeout(() => flush(rel), WATCH_DEBOUNCE_MS)
+        );
+      });
+    } catch (error) {
+      onResync();
+      return { stop: () => {
+      } };
+    }
+    watcher.on("error", () => onResync());
+    return {
+      stop: () => {
+        for (const timer of pending.values()) clearTimeout(timer);
+        pending.clear();
+        watcher.close();
+      }
+    };
+  }
+};
+var EXEC_MAX_BUFFER = 8 * 1024 * 1024;
+var NodeControlExec = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  run(command) {
+    const [file, args, shell] = Array.isArray(command) ? [command[0], command.slice(1), false] : [command, [], true];
+    return new Promise((resolve) => {
+      const child = spawn(file, args, { cwd: this.root, shell, env: process.env });
+      let stdout = "";
+      let stderr = "";
+      let truncated = false;
+      const cap = (existing, chunk) => {
+        if (existing.length >= EXEC_MAX_BUFFER) {
+          truncated = true;
+          return existing;
+        }
+        return existing + chunk.toString("utf8");
+      };
+      child.stdout?.on("data", (chunk) => stdout = cap(stdout, chunk));
+      child.stderr?.on("data", (chunk) => stderr = cap(stderr, chunk));
+      child.on("error", (error) => resolve({ stdout, stderr: error.message, exitCode: 127 }));
+      child.on("close", (code) => {
+        if (truncated) stderr += "\n[output truncated]";
+        resolve({ stdout, stderr, exitCode: code ?? 0 });
+      });
+    });
+  }
+};
+function tryDecodeUtf8(bytes) {
+  try {
+    const text = new TextDecoder("utf8", { fatal: true }).decode(bytes);
+    return text;
+  } catch {
+    return null;
+  }
+}
+function rethrow(rel) {
+  return (error) => {
+    if (error.code === "ENOENT") throw new ControlFsError(CONTROL_ERROR.NOT_FOUND, `not found: ${rel}`);
+    if (error.code === "EACCES") throw new ControlFsError(CONTROL_ERROR.PERMISSION_DENIED, rel);
+    throw new ControlFsError(CONTROL_ERROR.IO, error.message);
+  };
+}
+
 // src/tunnel/protocol.ts
 var MAX_PAYLOAD = 262144;
 var HEADER_LEN2 = 9;
@@ -419,13 +823,13 @@ function decodeFrame(bytes) {
   }
   return { streamId, frameType: rawType, payload: bytes.subarray(HEADER_LEN2) };
 }
-var textEncoder3 = new TextEncoder();
-var textDecoder2 = new TextDecoder();
+var textEncoder4 = new TextEncoder();
+var textDecoder3 = new TextDecoder();
 function encodeJsonPayload(value) {
-  return textEncoder3.encode(JSON.stringify(value));
+  return textEncoder4.encode(JSON.stringify(value));
 }
 function decodeJsonPayload(payload) {
-  return JSON.parse(textDecoder2.decode(payload));
+  return JSON.parse(textDecoder3.decode(payload));
 }
 function* chunkPayload(bytes) {
   if (bytes.length === 0) {
@@ -454,8 +858,8 @@ var HOP_BY_HOP_HEADERS2 = /* @__PURE__ */ new Set([
   "transfer-encoding",
   "upgrade"
 ]);
-var textEncoder4 = new TextEncoder();
-var textDecoder3 = new TextDecoder();
+var textEncoder5 = new TextEncoder();
+var textDecoder4 = new TextDecoder();
 function defaultSocketFactory(url, protocols) {
   const ctor = globalThis.WebSocket;
   if (!ctor) {
@@ -705,7 +1109,7 @@ var HttpProxyStream = class {
       status: 502,
       headers: [HEADER_CONTENT_TYPE_TEXT]
     });
-    this.ctx.send(FRAME_TYPE.BODY, textEncoder4.encode(`dev server unreachable: ${err.message}`));
+    this.ctx.send(FRAME_TYPE.BODY, textEncoder5.encode(`dev server unreachable: ${err.message}`));
     this.ctx.send(FRAME_TYPE.END, EMPTY_PAYLOAD);
     this.ctx.finish();
   }
@@ -736,7 +1140,7 @@ var WsProxyStream = class {
         status: 502,
         headers: [HEADER_CONTENT_TYPE_TEXT]
       });
-      this.ctx.send(FRAME_TYPE.BODY, textEncoder4.encode("dev server refused the websocket"));
+      this.ctx.send(FRAME_TYPE.BODY, textEncoder5.encode("dev server refused the websocket"));
       this.ctx.send(FRAME_TYPE.END, EMPTY_PAYLOAD);
       this.ctx.finish();
     });
@@ -748,7 +1152,7 @@ var WsProxyStream = class {
   handleFrame(frame) {
     switch (frame.frameType) {
       case FRAME_TYPE.WS_TEXT:
-        this.local.send(textDecoder3.decode(frame.payload));
+        this.local.send(textDecoder4.decode(frame.payload));
         break;
       case FRAME_TYPE.WS_BIN:
         this.local.send(frame.payload);
@@ -776,7 +1180,7 @@ var WsProxyStream = class {
     let payload;
     let frameType;
     if (typeof data === "string") {
-      payload = textEncoder4.encode(data);
+      payload = textEncoder5.encode(data);
       frameType = FRAME_TYPE.WS_TEXT;
     } else if (data instanceof ArrayBuffer) {
       payload = new Uint8Array(data);
@@ -902,8 +1306,11 @@ var StreamHandleV2 = class {
   }
 };
 var CONNECTION_STREAM_ID = 0;
-var textEncoder5 = new TextEncoder();
-var textDecoder4 = new TextDecoder();
+var LIVENESS_PING_INTERVAL_MS = 15e3;
+var LIVENESS_TIMEOUT_MS = 45e3;
+var FROZEN_TICK_GAP_MS = 6e4;
+var textEncoder6 = new TextEncoder();
+var textDecoder5 = new TextDecoder();
 var SessionV2 = class {
   constructor(transport, options) {
     this.transport = transport;
@@ -911,6 +1318,10 @@ var SessionV2 = class {
     this.nextStreamId = options.role === "service" ? 1 : 2;
     this.connectionSend = new SendWindow(0);
     this.connectionRecv = new RecvWindow(options.local.connection_window);
+    this.lastInboundAt = Date.now();
+    this.lastTickAt = Date.now();
+    this.livenessTimer = setInterval(() => this.onLivenessTick(), LIVENESS_PING_INTERVAL_MS);
+    this.livenessTimer.unref?.();
     transport.onMessage((bytes) => this.onMessage(bytes));
     transport.onClose((reason) => this.teardown(reason));
   }
@@ -925,9 +1336,36 @@ var SessionV2 = class {
   draining = false;
   closed = false;
   sending = Promise.resolve();
+  lastInboundAt;
+  lastTickAt;
+  livenessTimer;
+  onLivenessTick() {
+    if (this.closed) return;
+    const now = Date.now();
+    const tickGap = now - this.lastTickAt;
+    this.lastTickAt = now;
+    if (tickGap > FROZEN_TICK_GAP_MS) {
+      this.abort(`process froze ${Math.round(tickGap / 1e3)}s (suspend/resume); redialing`);
+      return;
+    }
+    if (now - this.lastInboundAt > LIVENESS_TIMEOUT_MS) {
+      this.abort(`no inbound frames for ${Math.round((now - this.lastInboundAt) / 1e3)}s`);
+      return;
+    }
+    void this.enqueueSend({
+      streamId: CONNECTION_STREAM_ID,
+      frameType: FRAME_TYPE_V2.PING,
+      payload: new Uint8Array(0)
+    });
+  }
+  /** Presumed-dead teardown: no farewell frames — the socket is a zombie. */
+  abort(reason) {
+    this.teardown(reason);
+    this.transport.close(1001, reason.slice(0, 100));
+  }
   /** Send our HELLO; the peer's must arrive as its first frame. */
   async start() {
-    const payload = textEncoder5.encode(JSON.stringify(this.options.local));
+    const payload = textEncoder6.encode(JSON.stringify(this.options.local));
     await this.transport.send(
       encodeFrameV2({ streamId: CONNECTION_STREAM_ID, frameType: FRAME_TYPE_V2.HELLO, payload })
     );
@@ -981,6 +1419,7 @@ var SessionV2 = class {
       this.fail(`undecodable frame: ${error.message}`);
       return;
     }
+    this.lastInboundAt = Date.now();
     if (!this.peer) {
       this.onHandshakeFrame(frame);
       return;
@@ -1153,7 +1592,7 @@ var SessionV2 = class {
     }
   }
   sendHead(streamId, frameType, value) {
-    const payload = textEncoder5.encode(JSON.stringify(value ?? null));
+    const payload = textEncoder6.encode(JSON.stringify(value ?? null));
     if (payload.length > MAX_HEAD_BYTES) {
       return Promise.reject(new SessionV2Error("head exceeds MAX_HEAD_BYTES"));
     }
@@ -1268,6 +1707,7 @@ var SessionV2 = class {
   teardown(reason) {
     if (this.closed) return;
     this.closed = true;
+    clearInterval(this.livenessTimer);
     for (const streamId of this.streams.keys()) {
       this.dropStream(streamId);
     }
@@ -1277,7 +1717,7 @@ var SessionV2 = class {
 function parseJson(payload) {
   if (payload.length === 0) return null;
   try {
-    return JSON.parse(textDecoder4.decode(payload));
+    return JSON.parse(textDecoder5.decode(payload));
   } catch {
     return null;
   }
@@ -1373,7 +1813,13 @@ var NegotiatingAgentClient = class {
     const hello = defaultHello();
     const transport = new WsTransportV2(socket);
     const createLocalSocket = this.options.createLocalSocket ?? defaultSocketFactory;
-    const dispatcher = new AgentDispatcher().register(new HttpProxyKind(makeAgentContext(this.options.localPort, hello, createLocalSocket))).register(new WsSpliceKind(makeAgentContext(this.options.localPort, hello, createLocalSocket)));
+    const dispatcher = new AgentDispatcher().register(new HttpProxyKind(makeAgentContext(this.options.localPort, hello, createLocalSocket))).register(new WsSpliceKind(makeAgentContext(this.options.localPort, hello, createLocalSocket))).register(
+      new ControlKind({
+        fs: new NodeControlFs(this.options.workspaceRoot),
+        watcher: new NodeControlWatcher(this.options.workspaceRoot),
+        exec: new NodeControlExec(this.options.workspaceRoot)
+      })
+    );
     const session = new SessionV2(transport, {
       role: "agent",
       local: hello,
@@ -1412,7 +1858,7 @@ var TUNNEL_CONFIG_DIR = ".cimplify";
 var TUNNEL_CONFIG_FILE = "tunnel.json";
 var DEFAULT_DEV_SERVER_PORT = 3e3;
 function tunnelConfigPath(cwd) {
-  return path2.join(cwd, TUNNEL_CONFIG_DIR, TUNNEL_CONFIG_FILE);
+  return path.join(cwd, TUNNEL_CONFIG_DIR, TUNNEL_CONFIG_FILE);
 }
 async function readTunnelConfig(cwd, env = process.env) {
   const url = env[TUNNEL_URL_ENV];
@@ -1461,17 +1907,18 @@ var CONFIG_POLL_MS = 2e3;
 var RECONNECT_MIN_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
 var CLOSE_CODE_REPLACED = 4e3;
-function defaultCreateClient(config, events) {
-  return new NegotiatingAgentClient({
+function makeDefaultCreateClient(workspaceRoot) {
+  return (config, events) => new NegotiatingAgentClient({
     url: config.url,
     token: config.token,
     localPort: config.localPort,
+    workspaceRoot,
     events
   });
 }
 function startTunnelRuntime(cwd, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? CONFIG_POLL_MS;
-  const createClient = options.createClient ?? defaultCreateClient;
+  const createClient = options.createClient ?? makeDefaultCreateClient(cwd);
   const onStatus = options.onStatus ?? ((message) => info(dim(message)));
   let stopped = false;
   let generation = 0;
@@ -1609,11 +2056,11 @@ function envEndpoint(businessId, projectId) {
   return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/env-vars`;
 }
 async function detectPackageManager(cwd) {
-  if (await pathExists(path2.join(cwd, LOCKFILE_BUN))) return PM_BUN;
-  if (await pathExists(path2.join(cwd, LOCKFILE_BUN_BINARY))) return PM_BUN;
-  if (await pathExists(path2.join(cwd, BUNFIG))) return PM_BUN;
-  if (await pathExists(path2.join(cwd, LOCKFILE_PNPM))) return PM_PNPM;
-  if (await pathExists(path2.join(cwd, LOCKFILE_YARN))) return PM_YARN;
+  if (await pathExists(path.join(cwd, LOCKFILE_BUN))) return PM_BUN;
+  if (await pathExists(path.join(cwd, LOCKFILE_BUN_BINARY))) return PM_BUN;
+  if (await pathExists(path.join(cwd, BUNFIG))) return PM_BUN;
+  if (await pathExists(path.join(cwd, LOCKFILE_PNPM))) return PM_PNPM;
+  if (await pathExists(path.join(cwd, LOCKFILE_YARN))) return PM_YARN;
   return PM_NPM;
 }
 async function pathExists(target) {
@@ -1626,7 +2073,7 @@ async function pathExists(target) {
   }
 }
 async function readPackageJson(cwd) {
-  const pkgPath = path2.join(cwd, PACKAGE_JSON);
+  const pkgPath = path.join(cwd, PACKAGE_JSON);
   let raw;
   try {
     raw = await promises.readFile(pkgPath, "utf8");
@@ -1657,7 +2104,7 @@ async function applyRemoteEnv(client, businessId, projectId, apiBaseUrl, cwd) {
   });
   const incoming = records.filter((r) => r.value !== null && !r.is_secret).map((r) => ({ key: r.key, value: r.value }));
   incoming.push({ key: PUBLIC_API_URL_KEY, value: apiBaseUrl });
-  const envPath = path2.join(cwd, ENV_LOCAL_FILE);
+  const envPath = path.join(cwd, ENV_LOCAL_FILE);
   let existing = [];
   try {
     const raw = await promises.readFile(envPath, "utf8");

package/dist/dispatcher.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { package_default } from './chunk-W64GWXPF.mjs';
+import { package_default } from './chunk-PVHB2MHV.mjs';
 import { TEMPLATES } from './chunk-W3WLADJP.mjs';
 
 // src/dispatcher.ts
@@ -142,18 +142,18 @@ var COMMANDS = {
   domains: () => import('./domains-H3K2WW55.mjs'),
   logs: () => import('./logs-2ECJQ3MU.mjs'),
   status: () => import('./status-IA7PJ4TV.mjs'),
-  dev: () => import('./dev-3TPDHU67.mjs'),
+  dev: () => import('./dev-5MB2BJ6L.mjs'),
   mock: () => import('./mock-TSUKCLWU.mjs'),
-  introspect: () => import('./introspect-TB2QFQMF.mjs'),
+  introspect: () => import('./introspect-YBDCOO3I.mjs'),
   inspect: () => import('./inspect-CGYX4DDF.mjs'),
-  doctor: () => import('./doctor-JQYXARYQ.mjs'),
-  explain: () => import('./explain-2I4MWMPY.mjs'),
+  doctor: () => import('./doctor-6Z6YR37N.mjs'),
+  explain: () => import('./explain-2FLJFJP3.mjs'),
   assets: () => import('./assets-4D7VXRUE.mjs'),
   repo: () => import('./repo-WSUAHXWO.mjs'),
   list: () => import('./list-27TS2L47.mjs'),
   add: () => import('./add-5ODVFWVR.mjs'),
-  update: () => import('./update-T5O6YCIC.mjs'),
-  upgrade: () => import('./update-T5O6YCIC.mjs'),
+  update: () => import('./update-VIDP5OKO.mjs'),
+  upgrade: () => import('./update-VIDP5OKO.mjs'),
   "auth-step-up": () => import('./auth-step-up-NOSM4PUR.mjs')
 };
 var COMMAND_PREFIXES = {

package/dist/{doctor-JQYXARYQ.mjs → doctor-6Z6YR37N.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { gatherIntrospection } from './chunk-EL34CORK.mjs';
+import { gatherIntrospection } from './chunk-7P2OGMZ4.mjs';
 import './chunk-K5464A3L.mjs';
 import './chunk-DBZ3UOQ2.mjs';
-import './chunk-W64GWXPF.mjs';
+import './chunk-PVHB2MHV.mjs';
 import { parseArgs, flagBool } from './chunk-C4M3DXKC.mjs';
 import { SDK_ENV_API_URL, DEFAULT_API_BASE_URL, ApiClient, ENV_API_BASE_URL } from './chunk-F4S5KETY.mjs';
 import { readAuthOrNull } from './chunk-UBAI443T.mjs';

package/dist/{explain-2I4MWMPY.mjs → explain-2FLJFJP3.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { package_default } from './chunk-W64GWXPF.mjs';
+import { package_default } from './chunk-PVHB2MHV.mjs';
 import { parseArgs } from './chunk-C4M3DXKC.mjs';
 import { bold, dim, info, result, CliError, CLI_ERROR_CODE } from './chunk-E2T2SBP5.mjs';
 

package/dist/{introspect-TB2QFQMF.mjs → introspect-YBDCOO3I.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-export { run as default, extractMockSeed, gatherIntrospection, renderIntrospection } from './chunk-EL34CORK.mjs';
+export { run as default, extractMockSeed, gatherIntrospection, renderIntrospection } from './chunk-7P2OGMZ4.mjs';
 import './chunk-K5464A3L.mjs';
 import './chunk-DBZ3UOQ2.mjs';
-import './chunk-W64GWXPF.mjs';
+import './chunk-PVHB2MHV.mjs';
 import './chunk-C4M3DXKC.mjs';
 import './chunk-UBAI443T.mjs';
 import './chunk-E2T2SBP5.mjs';

package/dist/{update-T5O6YCIC.mjs → update-VIDP5OKO.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { package_default } from './chunk-W64GWXPF.mjs';
+import { package_default } from './chunk-PVHB2MHV.mjs';
 import { promptYesNo } from './chunk-ITAFAORS.mjs';
 import { parseArgs, flagBool, flagString } from './chunk-C4M3DXKC.mjs';
 import { success, bold, info, dim, result, failure, CliError, CLI_ERROR_CODE, step, isJsonMode } from './chunk-E2T2SBP5.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cimplify/cli",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Cimplify CLI — deploy, manage env vars, link projects, and scaffold storefronts",
   "keywords": [
     "cimplify",