@cimplify/cli 0.10.1 → 0.11.0

package/dist/dev-OF335HZZ.mjs

@@ -0,0 +1,762 @@
+#!/usr/bin/env node
+import { parseEnvFile, formatEnvFile } from './chunk-DBZ3UOQ2.mjs';
+import { ENV_SCOPE, PUBLIC_ENV_PREFIX } from './chunk-MXYUAJEW.mjs';
+import { parseArgs, flagBool } from './chunk-C4M3DXKC.mjs';
+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 http from 'http';
+
+// src/tunnel/protocol.ts
+var MAX_PAYLOAD = 262144;
+var HEADER_LEN = 9;
+var SUBPROTOCOL = "cimplify-tunnel.v1";
+var CONNECT_PATH = "/__cimplify/connect";
+var FRAME_TYPE = {
+  OPEN_HTTP: 1,
+  OPEN_WS: 2,
+  RESP_HEAD: 3,
+  BODY: 4,
+  END: 5,
+  WS_TEXT: 6,
+  WS_BIN: 7,
+  CLOSE: 8
+};
+var KNOWN_FRAME_TYPES = new Set(Object.values(FRAME_TYPE));
+var TunnelProtocolError = class extends Error {
+};
+function encodeFrame(frame) {
+  if (frame.payload.length > MAX_PAYLOAD) {
+    throw new TunnelProtocolError(`payload length ${frame.payload.length} exceeds ${MAX_PAYLOAD}`);
+  }
+  const bytes = new Uint8Array(HEADER_LEN + frame.payload.length);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, frame.streamId);
+  view.setUint8(4, frame.frameType);
+  view.setUint32(5, frame.payload.length);
+  bytes.set(frame.payload, HEADER_LEN);
+  return bytes;
+}
+function decodeFrame(bytes) {
+  if (bytes.length < HEADER_LEN) {
+    throw new TunnelProtocolError(`frame truncated: ${bytes.length} bytes`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const streamId = view.getUint32(0);
+  const rawType = view.getUint8(4);
+  if (!KNOWN_FRAME_TYPES.has(rawType)) {
+    throw new TunnelProtocolError(`unknown frame type 0x${rawType.toString(16).padStart(2, "0")}`);
+  }
+  const declared = view.getUint32(5);
+  if (declared > MAX_PAYLOAD) {
+    throw new TunnelProtocolError(`payload length ${declared} exceeds ${MAX_PAYLOAD}`);
+  }
+  const actual = bytes.length - HEADER_LEN;
+  if (declared !== actual) {
+    throw new TunnelProtocolError(
+      `payload length field ${declared} does not match remaining ${actual} bytes`
+    );
+  }
+  return { streamId, frameType: rawType, payload: bytes.subarray(HEADER_LEN) };
+}
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeJsonPayload(value) {
+  return textEncoder.encode(JSON.stringify(value));
+}
+function decodeJsonPayload(payload) {
+  return JSON.parse(textDecoder.decode(payload));
+}
+function* chunkPayload(bytes) {
+  if (bytes.length === 0) {
+    return;
+  }
+  for (let offset = 0; offset < bytes.length; offset += MAX_PAYLOAD) {
+    yield bytes.subarray(offset, Math.min(offset + MAX_PAYLOAD, bytes.length));
+  }
+}
+
+// src/tunnel/client.ts
+var LOCAL_HOST = "127.0.0.1";
+var SEND_HIGH_WATER_BYTES = 4 * 1024 * 1024;
+var BACKPRESSURE_POLL_MS = 25;
+var EMPTY_PAYLOAD = new Uint8Array(0);
+var HEADER_SEC_WS_PROTOCOL = "sec-websocket-protocol";
+var HEADER_CONTENT_TYPE_TEXT = ["content-type", "text/plain; charset=utf-8"];
+var WS_CLOSE_NORMAL = 1e3;
+var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var textEncoder2 = new TextEncoder();
+var textDecoder2 = new TextDecoder();
+function defaultSocketFactory(url, protocols) {
+  const ctor = globalThis.WebSocket;
+  if (!ctor) {
+    throw new Error("global WebSocket is unavailable; the preview tunnel requires Bun or Node 22+");
+  }
+  return new ctor(url, protocols);
+}
+function connectUrl(baseUrl, token) {
+  return `${baseUrl.replace(/\/+$/, "")}${CONNECT_PATH}?token=${encodeURIComponent(token)}`;
+}
+var TunnelClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  streams = /* @__PURE__ */ new Map();
+  socket = null;
+  closed = false;
+  start() {
+    const factory = this.options.createSocket ?? defaultSocketFactory;
+    const socket = factory(connectUrl(this.options.url, this.options.token), [SUBPROTOCOL]);
+    socket.binaryType = "arraybuffer";
+    this.socket = socket;
+    socket.addEventListener("open", () => {
+      if (!this.closed) this.options.events?.onConnected?.();
+    });
+    socket.addEventListener("message", (event) => this.handleMessage(event.data));
+    socket.addEventListener(
+      "close",
+      (event) => this.teardown(`connection closed (${event.code ?? "unknown"})`)
+    );
+    socket.addEventListener("error", () => this.teardown("connection error"));
+  }
+  stop() {
+    if (this.closed) return;
+    try {
+      this.socket?.close(WS_CLOSE_NORMAL);
+    } catch {
+    }
+    this.teardown("stopped");
+  }
+  teardown(reason) {
+    if (this.closed) return;
+    this.closed = true;
+    for (const handler of this.streams.values()) {
+      handler.abort();
+    }
+    this.streams.clear();
+    this.socket = null;
+    this.options.events?.onClosed?.(reason);
+  }
+  handleMessage(data) {
+    if (this.closed) return;
+    let bytes;
+    if (data instanceof ArrayBuffer) {
+      bytes = new Uint8Array(data);
+    } else if (data instanceof Uint8Array) {
+      bytes = data;
+    } else {
+      this.failConnection("non-binary message violates the tunnel protocol");
+      return;
+    }
+    let frame;
+    try {
+      frame = decodeFrame(bytes);
+    } catch (err) {
+      this.failConnection(`undecodable frame: ${err.message}`);
+      return;
+    }
+    this.dispatch(frame);
+  }
+  dispatch(frame) {
+    const handler = this.streams.get(frame.streamId);
+    if (handler) {
+      if (frame.frameType === FRAME_TYPE.CLOSE) this.streams.delete(frame.streamId);
+      handler.handleFrame(frame);
+      return;
+    }
+    switch (frame.frameType) {
+      case FRAME_TYPE.OPEN_HTTP:
+        this.openHttp(frame);
+        break;
+      case FRAME_TYPE.OPEN_WS:
+        this.openWs(frame);
+        break;
+      case FRAME_TYPE.CLOSE:
+        break;
+      default:
+        this.sendClose(frame.streamId);
+    }
+  }
+  openHttp(frame) {
+    let head;
+    try {
+      head = decodeJsonPayload(frame.payload);
+    } catch {
+      this.sendClose(frame.streamId);
+      return;
+    }
+    this.streams.set(
+      frame.streamId,
+      new HttpProxyStream(this.contextFor(frame.streamId), head, this.options.localPort)
+    );
+  }
+  openWs(frame) {
+    let head;
+    try {
+      head = decodeJsonPayload(frame.payload);
+    } catch {
+      this.sendClose(frame.streamId);
+      return;
+    }
+    const factory = this.options.createLocalSocket ?? defaultSocketFactory;
+    this.streams.set(
+      frame.streamId,
+      new WsProxyStream(this.contextFor(frame.streamId), head, this.options.localPort, factory)
+    );
+  }
+  contextFor(streamId) {
+    return {
+      send: (frameType, payload) => this.sendFrame({ streamId, frameType, payload }),
+      sendJson: (frameType, value) => this.sendFrame({ streamId, frameType, payload: encodeJsonPayload(value) }),
+      finish: () => {
+        this.streams.delete(streamId);
+      },
+      fail: (info2) => {
+        this.streams.delete(streamId);
+        this.sendClose(streamId, info2);
+      },
+      bufferedAmount: () => this.socket?.bufferedAmount ?? 0
+    };
+  }
+  sendClose(streamId, info2) {
+    const payload = info2 && (info2.code !== void 0 || info2.reason !== void 0) ? encodeJsonPayload(info2) : EMPTY_PAYLOAD;
+    this.sendFrame({ streamId, frameType: FRAME_TYPE.CLOSE, payload });
+  }
+  sendFrame(frame) {
+    if (this.closed || !this.socket) return false;
+    try {
+      this.socket.send(encodeFrame(frame));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  failConnection(reason) {
+    try {
+      this.socket?.close(WS_CLOSE_NORMAL);
+    } catch {
+    }
+    this.teardown(reason);
+  }
+};
+var HttpProxyStream = class {
+  constructor(ctx, head, localPort) {
+    this.ctx = ctx;
+    this.request = http.request({
+      host: LOCAL_HOST,
+      port: localPort,
+      method: head.method,
+      path: head.path,
+      headers: toNodeHeaders(head.headers)
+    });
+    this.request.on("response", (response) => this.pumpResponse(response));
+    this.request.on("error", (err) => this.handleRequestError(err));
+  }
+  ctx;
+  request;
+  responded = false;
+  done = false;
+  handleFrame(frame) {
+    switch (frame.frameType) {
+      case FRAME_TYPE.BODY:
+        this.request.write(Buffer.from(frame.payload));
+        break;
+      case FRAME_TYPE.END:
+        this.request.end();
+        break;
+      case FRAME_TYPE.CLOSE:
+        this.abort();
+        break;
+      default:
+        this.ctx.fail();
+        this.abort();
+    }
+  }
+  abort() {
+    this.done = true;
+    this.request.destroy();
+  }
+  pumpResponse(response) {
+    this.responded = true;
+    const headers = [];
+    for (let i = 0; i + 1 < response.rawHeaders.length; i += 2) {
+      headers.push([response.rawHeaders[i].toLowerCase(), response.rawHeaders[i + 1]]);
+    }
+    const head = { status: response.statusCode ?? 502, headers };
+    if (!this.ctx.sendJson(FRAME_TYPE.RESP_HEAD, head)) {
+      this.abort();
+      return;
+    }
+    response.on("data", (chunk) => {
+      for (const piece of chunkPayload(chunk)) {
+        if (!this.ctx.send(FRAME_TYPE.BODY, piece)) {
+          this.abort();
+          return;
+        }
+      }
+      this.applyBackpressure(response);
+    });
+    response.on("end", () => {
+      if (this.done) return;
+      this.done = true;
+      this.ctx.send(FRAME_TYPE.END, EMPTY_PAYLOAD);
+      this.ctx.finish();
+    });
+    response.on("error", () => {
+      if (this.done) return;
+      this.done = true;
+      this.ctx.fail();
+    });
+  }
+  /** The mux socket has no stream-level flow control; pause the local read
+   * side when the shared connection's send buffer backs up. */
+  applyBackpressure(response) {
+    if (this.ctx.bufferedAmount() <= SEND_HIGH_WATER_BYTES) return;
+    response.pause();
+    const poll = () => {
+      if (this.done) return;
+      if (this.ctx.bufferedAmount() <= SEND_HIGH_WATER_BYTES) {
+        response.resume();
+      } else {
+        setTimeout(poll, BACKPRESSURE_POLL_MS);
+      }
+    };
+    setTimeout(poll, BACKPRESSURE_POLL_MS);
+  }
+  handleRequestError(err) {
+    if (this.done) return;
+    this.done = true;
+    if (this.responded) {
+      this.ctx.fail();
+      return;
+    }
+    this.ctx.sendJson(FRAME_TYPE.RESP_HEAD, {
+      status: 502,
+      headers: [HEADER_CONTENT_TYPE_TEXT]
+    });
+    this.ctx.send(FRAME_TYPE.BODY, textEncoder2.encode(`dev server unreachable: ${err.message}`));
+    this.ctx.send(FRAME_TYPE.END, EMPTY_PAYLOAD);
+    this.ctx.finish();
+  }
+};
+var WsProxyStream = class {
+  constructor(ctx, head, localPort, factory) {
+    this.ctx = ctx;
+    const protocols = head.headers.filter(([name]) => name === HEADER_SEC_WS_PROTOCOL).flatMap(([, value]) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+    this.local = factory(`ws://${LOCAL_HOST}:${localPort}${head.path}`, protocols);
+    this.local.binaryType = "arraybuffer";
+    this.local.addEventListener("open", () => {
+      this.opened = true;
+      const headers = this.local.protocol ? [[HEADER_SEC_WS_PROTOCOL, this.local.protocol]] : [];
+      if (!this.ctx.sendJson(FRAME_TYPE.RESP_HEAD, { status: 101, headers })) {
+        this.abort();
+      }
+    });
+    this.local.addEventListener("message", (event) => this.forward(event.data));
+    this.local.addEventListener("close", (event) => {
+      if (this.done) return;
+      this.done = true;
+      this.ctx.fail({ code: event.code, reason: event.reason || void 0 });
+    });
+    this.local.addEventListener("error", () => {
+      if (this.done || this.opened) return;
+      this.done = true;
+      this.ctx.sendJson(FRAME_TYPE.RESP_HEAD, {
+        status: 502,
+        headers: [HEADER_CONTENT_TYPE_TEXT]
+      });
+      this.ctx.send(FRAME_TYPE.BODY, textEncoder2.encode("dev server refused the websocket"));
+      this.ctx.send(FRAME_TYPE.END, EMPTY_PAYLOAD);
+      this.ctx.finish();
+    });
+  }
+  ctx;
+  local;
+  opened = false;
+  done = false;
+  handleFrame(frame) {
+    switch (frame.frameType) {
+      case FRAME_TYPE.WS_TEXT:
+        this.local.send(textDecoder2.decode(frame.payload));
+        break;
+      case FRAME_TYPE.WS_BIN:
+        this.local.send(frame.payload);
+        break;
+      case FRAME_TYPE.CLOSE: {
+        this.done = true;
+        const info2 = parseCloseInfo(frame.payload);
+        this.local.close(sanitizeCloseCode(info2.code), info2.reason);
+        break;
+      }
+      default:
+        this.ctx.fail();
+        this.abort();
+    }
+  }
+  abort() {
+    this.done = true;
+    try {
+      this.local.close();
+    } catch {
+    }
+  }
+  forward(data) {
+    if (this.done) return;
+    let payload;
+    let frameType;
+    if (typeof data === "string") {
+      payload = textEncoder2.encode(data);
+      frameType = FRAME_TYPE.WS_TEXT;
+    } else if (data instanceof ArrayBuffer) {
+      payload = new Uint8Array(data);
+      frameType = FRAME_TYPE.WS_BIN;
+    } else if (data instanceof Uint8Array) {
+      payload = data;
+      frameType = FRAME_TYPE.WS_BIN;
+    } else {
+      return;
+    }
+    if (payload.length > MAX_PAYLOAD) {
+      this.done = true;
+      this.ctx.fail({ reason: "message exceeds tunnel frame cap" });
+      this.abort();
+      return;
+    }
+    if (!this.ctx.send(frameType, payload)) this.abort();
+  }
+};
+function toNodeHeaders(pairs) {
+  const out = {};
+  for (const [name, value] of pairs) {
+    if (HOP_BY_HOP_HEADERS.has(name)) continue;
+    const existing = out[name];
+    if (existing === void 0) {
+      out[name] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      out[name] = [existing, value];
+    }
+  }
+  return out;
+}
+function parseCloseInfo(payload) {
+  if (payload.length === 0) return {};
+  try {
+    return decodeJsonPayload(payload);
+  } catch {
+    return {};
+  }
+}
+function sanitizeCloseCode(code) {
+  if (code === void 0) return void 0;
+  return code === WS_CLOSE_NORMAL || code >= 3e3 && code <= 4999 ? code : void 0;
+}
+var TUNNEL_URL_ENV = "CIMPLIFY_TUNNEL_URL";
+var TUNNEL_TOKEN_ENV = "CIMPLIFY_TUNNEL_TOKEN";
+var TUNNEL_LOCAL_PORT_ENV = "CIMPLIFY_TUNNEL_LOCAL_PORT";
+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);
+}
+async function readTunnelConfig(cwd, env = process.env) {
+  const url = env[TUNNEL_URL_ENV];
+  const token = env[TUNNEL_TOKEN_ENV];
+  if (url && token) {
+    return { url, token, localPort: envPort(env) ?? DEFAULT_DEV_SERVER_PORT };
+  }
+  return readTunnelConfigFile(cwd);
+}
+function envPort(env) {
+  const raw = env[TUNNEL_LOCAL_PORT_ENV];
+  if (!raw) return null;
+  const port = Number.parseInt(raw, 10);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
+async function readTunnelConfigFile(cwd) {
+  let raw;
+  try {
+    raw = await promises.readFile(tunnelConfigPath(cwd), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record = parsed;
+  if (typeof record.url !== "string" || record.url.length === 0) return null;
+  if (typeof record.token !== "string" || record.token.length === 0) return null;
+  const localPort = typeof record.port === "number" && Number.isInteger(record.port) && record.port > 0 ? record.port : DEFAULT_DEV_SERVER_PORT;
+  return { url: record.url, token: record.token, localPort };
+}
+function sameTunnelConfig(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.url === b.url && a.token === b.token && a.localPort === b.localPort;
+}
+
+// src/tunnel/manager.ts
+var CONFIG_POLL_MS = 2e3;
+var RECONNECT_MIN_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+function defaultCreateClient(config, events) {
+  return new TunnelClient({
+    url: config.url,
+    token: config.token,
+    localPort: config.localPort,
+    events
+  });
+}
+function startTunnelRuntime(cwd, options = {}) {
+  const pollIntervalMs = options.pollIntervalMs ?? CONFIG_POLL_MS;
+  const createClient = options.createClient ?? defaultCreateClient;
+  const onStatus = options.onStatus ?? ((message) => info(dim(message)));
+  let stopped = false;
+  let generation = 0;
+  let activeConfig = null;
+  let activeClient = null;
+  let reconnectDelay = RECONNECT_MIN_MS;
+  let reconnectTimer = null;
+  let polling = false;
+  const clearReconnect = () => {
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+  };
+  const startClient = (config) => {
+    generation += 1;
+    const myGeneration = generation;
+    const client = createClient(config, {
+      onConnected: () => {
+        if (stopped || myGeneration !== generation) return;
+        reconnectDelay = RECONNECT_MIN_MS;
+        onStatus("(preview tunnel: connected)");
+      },
+      onClosed: (reason) => {
+        if (stopped || myGeneration !== generation) return;
+        onStatus(`(preview tunnel: disconnected \u2014 ${reason})`);
+        scheduleReconnect();
+      }
+    });
+    activeConfig = config;
+    activeClient = client;
+    client.start();
+  };
+  const retireClient = () => {
+    generation += 1;
+    activeClient?.stop();
+    activeClient = null;
+  };
+  const scheduleReconnect = () => {
+    if (reconnectTimer !== null) return;
+    const delay = reconnectDelay + Math.floor(Math.random() * (reconnectDelay / 4));
+    reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      if (stopped || activeConfig === null) return;
+      retireClient();
+      startClient(activeConfig);
+    }, delay);
+  };
+  const stopClient = () => {
+    clearReconnect();
+    retireClient();
+    activeConfig = null;
+  };
+  const poll = async () => {
+    if (polling || stopped) return;
+    polling = true;
+    try {
+      const config = await readTunnelConfig(cwd, options.env);
+      if (stopped || sameTunnelConfig(config, activeConfig)) return;
+      stopClient();
+      if (config) {
+        onStatus("(preview tunnel: credentials found, connecting)");
+        reconnectDelay = RECONNECT_MIN_MS;
+        startClient(config);
+      } else {
+        onStatus("(preview tunnel: credentials removed, stopped)");
+      }
+    } finally {
+      polling = false;
+    }
+  };
+  const interval = setInterval(() => {
+    void poll();
+  }, pollIntervalMs);
+  void poll();
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(interval);
+    stopClient();
+  };
+}
+
+// src/commands/dev.ts
+var FLAG_REMOTE = "remote";
+var PACKAGE_JSON = "package.json";
+var ENV_LOCAL_FILE = ".env.local";
+var PUBLIC_API_URL_KEY = "NEXT_PUBLIC_CIMPLIFY_API_URL";
+var SCRIPT_DEV = "dev";
+var PREVIEW_ORIGIN_ENV = "CIMPLIFY_PREVIEW_ORIGIN";
+async function applyPreviewOrigin(cwd, origin) {
+  const { ensurePreviewOrigin } = await import('./preview-config-CHDYYWUY.mjs');
+  try {
+    const result = await ensurePreviewOrigin(cwd, origin);
+    if (result.status === "unrecognized") {
+      info(
+        dim(
+          `(preview: could not resolve ${result.file} config shape; hot-reload may be limited)`
+        )
+      );
+    }
+  } catch (err) {
+    info(dim(`(preview: dev-origin setup skipped: ${err.message})`));
+  }
+}
+var PM_BUN = "bun";
+var PM_PNPM = "pnpm";
+var PM_YARN = "yarn";
+var PM_NPM = "npm";
+var LOCKFILE_BUN = "bun.lock";
+var LOCKFILE_BUN_BINARY = "bun.lockb";
+var LOCKFILE_PNPM = "pnpm-lock.yaml";
+var LOCKFILE_YARN = "yarn.lock";
+var BUNFIG = "bunfig.toml";
+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;
+  return PM_NPM;
+}
+async function pathExists(target) {
+  try {
+    await promises.stat(target);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function readPackageJson(cwd) {
+  const pkgPath = path2.join(cwd, PACKAGE_JSON);
+  let raw;
+  try {
+    raw = await promises.readFile(pkgPath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `No package.json in ${cwd}. \`cimplify dev\` runs your project's dev script.`
+      );
+    }
+    throw err;
+  }
+  return JSON.parse(raw);
+}
+function mergeEnvEntries(existing, incoming) {
+  const seen = new Set(existing.map((e) => e.key));
+  const merged = [...existing];
+  for (const entry of incoming) {
+    if (seen.has(entry.key)) continue;
+    merged.push(entry);
+    seen.add(entry.key);
+  }
+  return merged;
+}
+async function applyRemoteEnv(client, businessId, projectId, apiBaseUrl, cwd) {
+  const records = await client.get(envEndpoint(businessId, projectId), {
+    query: { scope: ENV_SCOPE.PRODUCTION }
+  });
+  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);
+  let existing = [];
+  try {
+    const raw = await promises.readFile(envPath, "utf8");
+    existing = parseEnvFile(raw);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const merged = mergeEnvEntries(existing, incoming);
+  await promises.writeFile(envPath, formatEnvFile(merged), "utf8");
+  const publicCount = incoming.filter((e) => e.key.startsWith(PUBLIC_ENV_PREFIX)).length;
+  return publicCount;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const remote = flagBool(args, FLAG_REMOTE);
+  const cwd = process.cwd();
+  const previewOrigin = process.env[PREVIEW_ORIGIN_ENV];
+  if (remote) {
+    const auth = await readAuth();
+    const link = await readProjectLink();
+    const client = ApiClient.fromAuth(auth);
+    const publicCount = await applyRemoteEnv(
+      client,
+      link.businessId,
+      link.projectId,
+      auth.apiBaseUrl,
+      cwd
+    );
+    const label = link.businessHandle ?? auth.businessHandle ?? auth.businessId;
+    info(`Dev mode: connected to ${label} production data (${publicCount} public var${publicCount === 1 ? "" : "s"} merged)`);
+  } else if (previewOrigin) {
+    info("Dev mode: hosted preview");
+  } else {
+    info("Dev mode: using local mock (`cimplify mock`)");
+  }
+  const pkg = await readPackageJson(cwd);
+  if (!pkg.scripts || !pkg.scripts[SCRIPT_DEV]) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `No "${SCRIPT_DEV}" script in package.json. Add one (e.g. "next dev") and re-run.`
+    );
+  }
+  let stopTunnel = null;
+  if (previewOrigin) {
+    await applyPreviewOrigin(cwd, previewOrigin);
+    stopTunnel = startTunnelRuntime(cwd);
+  }
+  const pm = await detectPackageManager(cwd);
+  info(dim(`(running: ${pm} run ${SCRIPT_DEV})`));
+  const child = spawn(pm, ["run", SCRIPT_DEV], { cwd, stdio: "inherit" });
+  try {
+    await new Promise((resolve, reject) => {
+      child.on("error", (err) => reject(new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Failed to spawn ${pm}: ${err.message}`)));
+      child.on("close", (code) => {
+        process.exitCode = code ?? 0;
+        resolve();
+      });
+    });
+  } finally {
+    stopTunnel?.();
+  }
+}
+
+export { run as default, detectPackageManager, mergeEnvEntries };