@mindstudio-ai/local-model-tunnel 0.5.7 → 0.5.8

package/dist/chunk-C3JPRLSS.js

@@ -0,0 +1,1485 @@
+// src/config.ts
+import Conf from "conf";
+import os from "os";
+import path from "path";
+var config = new Conf({
+  projectName: "mindstudio-local",
+  cwd: path.join(os.homedir(), ".mindstudio-local-tunnel"),
+  configName: "config",
+  defaults: {
+    environment: "prod",
+    providerBaseUrls: {},
+    providerInstallPaths: {},
+    localInterfaces: {},
+    environments: {
+      prod: {
+        apiBaseUrl: "https://api.mindstudio.ai"
+      },
+      local: {
+        apiBaseUrl: "http://localhost:3129"
+      }
+    }
+  }
+});
+function getEnvironment() {
+  return config.get("environment");
+}
+function getEnvConfig() {
+  const env = getEnvironment();
+  return config.get(`environments.${env}`);
+}
+function setEnvConfig(key, value) {
+  const env = getEnvironment();
+  config.set(`environments.${env}.${key}`, value);
+}
+function getApiKey() {
+  return getEnvConfig().apiKey;
+}
+function setApiKey(key) {
+  setEnvConfig("apiKey", key);
+}
+function getUserId() {
+  return getEnvConfig().userId;
+}
+function setUserId(id) {
+  setEnvConfig("userId", id);
+}
+function getApiBaseUrl() {
+  return getEnvConfig().apiBaseUrl;
+}
+function getConfigPath() {
+  return config.path;
+}
+function getProviderBaseUrl(name, defaultUrl) {
+  const urls = config.get("providerBaseUrls");
+  return urls[name] ?? defaultUrl;
+}
+function setProviderBaseUrl(name, url) {
+  const urls = config.get("providerBaseUrls");
+  urls[name] = url;
+  config.set("providerBaseUrls", urls);
+}
+function getProviderInstallPath(name) {
+  const paths = config.get("providerInstallPaths");
+  return paths[name];
+}
+function setProviderInstallPath(name, installPath) {
+  const paths = config.get("providerInstallPaths");
+  paths[name] = installPath;
+  config.set("providerInstallPaths", paths);
+}
+function getLocalInterfacesDir() {
+  return path.join(os.homedir(), ".mindstudio-local-tunnel", "interfaces");
+}
+function getLocalInterfacePath(key) {
+  const interfaces = config.get("localInterfaces");
+  return interfaces[key];
+}
+function setLocalInterfacePath(key, dirPath) {
+  const interfaces = config.get("localInterfaces");
+  interfaces[key] = dirPath;
+  config.set("localInterfaces", interfaces);
+}
+function deleteLocalInterfacePath(key) {
+  const interfaces = config.get("localInterfaces");
+  delete interfaces[key];
+  config.set("localInterfaces", interfaces);
+}
+
+// src/dev/logger.ts
+import fs from "fs";
+var LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var currentLevel = LEVELS.error;
+var writeFn = () => {
+};
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function write(level, msg, data) {
+  if (LEVELS[level] > currentLevel) {
+    return;
+  }
+  const parts = [`[${timestamp()}]`, level.toUpperCase().padEnd(5), msg];
+  if (data) {
+    parts.push(JSON.stringify(data));
+  }
+  writeFn(parts.join(" "));
+}
+var log = {
+  error(msg, data) {
+    write("error", msg, data);
+  },
+  warn(msg, data) {
+    write("warn", msg, data);
+  },
+  info(msg, data) {
+    write("info", msg, data);
+  },
+  debug(msg, data) {
+    write("debug", msg, data);
+  }
+};
+function initLoggerHeadless(level = "info") {
+  currentLevel = LEVELS[level];
+  writeFn = (line) => {
+    process.stderr.write(line + "\n");
+  };
+}
+function initLoggerInteractive(level = "error") {
+  currentLevel = LEVELS[level];
+  let fd = null;
+  writeFn = (line) => {
+    try {
+      if (fd === null) {
+        fd = fs.openSync(".mindstudio-dev.log", "a");
+      }
+      fs.writeSync(fd, line + "\n");
+    } catch {
+    }
+  };
+}
+
+// src/dev/api.ts
+function getHeaders(sessionId) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("Not authenticated. Run mindstudio-local to set up.");
+  }
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  if (sessionId) headers["x-dev-session"] = sessionId;
+  return headers;
+}
+function basePath(appId) {
+  return `${getApiBaseUrl()}/_internal/v2/apps/${appId}/dev`;
+}
+async function apiRequest(method, url, headers, body) {
+  const start = Date.now();
+  const logTag = `${method} ${url.replace(getApiBaseUrl(), "")}`;
+  const response = await fetch(url, {
+    method,
+    headers,
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+  });
+  const duration = Date.now() - start;
+  if (response.status === 204) {
+    log.debug(`api ${logTag} \u2192 204 (${duration}ms)`);
+    return null;
+  }
+  if (!response.ok) {
+    const error = await response.text();
+    log.error(`api ${logTag} \u2192 ${response.status} (${duration}ms)`, { error });
+    throw new ApiError(`${logTag} failed: ${response.status} ${error}`, response.status);
+  }
+  const data = await response.json();
+  log.info(`api ${logTag} \u2192 ${response.status} (${duration}ms)`);
+  return data;
+}
+async function startDevSession(appId, opts) {
+  const body = {};
+  if (opts?.branch) body.branch = opts.branch;
+  if (opts?.proxyUrl) body.proxyUrl = opts.proxyUrl;
+  if (opts?.methods) body.methods = opts.methods;
+  return apiRequest("POST", `${basePath(appId)}/manage/start`, getHeaders(), body);
+}
+async function stopDevSession(appId, sessionId) {
+  await apiRequest("POST", `${basePath(appId)}/manage/stop`, getHeaders(sessionId));
+}
+async function pollDevRequest(appId, sessionId, proxyUrl) {
+  const url = proxyUrl ? `${basePath(appId)}/poll?proxyUrl=${encodeURIComponent(proxyUrl)}` : `${basePath(appId)}/poll`;
+  try {
+    return await apiRequest("GET", url, getHeaders(sessionId));
+  } catch (err) {
+    if (err instanceof ApiError) {
+      throw new DevPollError(err.message, err.statusCode);
+    }
+    throw err;
+  }
+}
+async function submitDevResult(appId, sessionId, requestId, result) {
+  await apiRequest(
+    "POST",
+    `${basePath(appId)}/result/${requestId}`,
+    getHeaders(sessionId),
+    result
+  );
+}
+async function syncSchema(appId, sessionId, tables) {
+  return apiRequest(
+    "POST",
+    `${basePath(appId)}/manage/sync-schema`,
+    getHeaders(sessionId),
+    { tables }
+  );
+}
+async function resetDevDatabase(appId, sessionId, mode = "snapshot") {
+  const data = await apiRequest(
+    "POST",
+    `${basePath(appId)}/manage/reset?mode=${mode}`,
+    getHeaders(sessionId)
+  );
+  return data.databases;
+}
+async function impersonate(appId, sessionId, roles) {
+  return apiRequest(
+    "POST",
+    `${basePath(appId)}/manage/impersonate`,
+    getHeaders(sessionId),
+    { roles: roles && roles.length > 0 ? roles : null }
+  );
+}
+async function refreshContext(appId, sessionId) {
+  const data = await apiRequest(
+    "POST",
+    `${basePath(appId)}/manage/refresh-context`,
+    getHeaders(sessionId)
+  );
+  return data.clientContext;
+}
+async function fetchCallbackToken(appId, sessionId) {
+  const data = await apiRequest(
+    "POST",
+    `${basePath(appId)}/manage/token`,
+    getHeaders(sessionId)
+  );
+  return data.authorizationToken;
+}
+var ApiError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+var DevPollError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "DevPollError";
+  }
+};
+
+// src/dev/events.ts
+import { EventEmitter } from "events";
+var DevEventEmitter = class extends EventEmitter {
+  emitStart(event) {
+    this.emit("dev:start", event);
+  }
+  emitComplete(event) {
+    this.emit("dev:complete", event);
+  }
+  emitSessionExpired() {
+    this.emit("dev:session-expired");
+  }
+  emitAuthRefreshStart(url) {
+    this.emit("dev:auth-refresh-start", url);
+  }
+  emitAuthRefreshSuccess() {
+    this.emit("dev:auth-refresh-success");
+  }
+  emitAuthRefreshFailed() {
+    this.emit("dev:auth-refresh-failed");
+  }
+  emitConnectionWarning(message) {
+    this.emit("dev:connection-warning", message);
+  }
+  emitConnectionRestored() {
+    this.emit("dev:connection-restored");
+  }
+  emitImpersonate(event) {
+    this.emit("dev:impersonate", event);
+  }
+  emitScenarioStart(event) {
+    this.emit("dev:scenario-start", event);
+  }
+  emitScenarioComplete(event) {
+    this.emit("dev:scenario-complete", event);
+  }
+  onStart(handler) {
+    this.on("dev:start", handler);
+    return () => this.off("dev:start", handler);
+  }
+  onComplete(handler) {
+    this.on("dev:complete", handler);
+    return () => this.off("dev:complete", handler);
+  }
+  onSessionExpired(handler) {
+    this.on("dev:session-expired", handler);
+    return () => this.off("dev:session-expired", handler);
+  }
+  onAuthRefreshStart(handler) {
+    this.on("dev:auth-refresh-start", handler);
+    return () => this.off("dev:auth-refresh-start", handler);
+  }
+  onAuthRefreshSuccess(handler) {
+    this.on("dev:auth-refresh-success", handler);
+    return () => this.off("dev:auth-refresh-success", handler);
+  }
+  onAuthRefreshFailed(handler) {
+    this.on("dev:auth-refresh-failed", handler);
+    return () => this.off("dev:auth-refresh-failed", handler);
+  }
+  onConnectionWarning(handler) {
+    this.on("dev:connection-warning", handler);
+    return () => this.off("dev:connection-warning", handler);
+  }
+  onConnectionRestored(handler) {
+    this.on("dev:connection-restored", handler);
+    return () => this.off("dev:connection-restored", handler);
+  }
+  onImpersonate(handler) {
+    this.on("dev:impersonate", handler);
+    return () => this.off("dev:impersonate", handler);
+  }
+  onScenarioStart(handler) {
+    this.on("dev:scenario-start", handler);
+    return () => this.off("dev:scenario-start", handler);
+  }
+  onScenarioComplete(handler) {
+    this.on("dev:scenario-complete", handler);
+    return () => this.off("dev:scenario-complete", handler);
+  }
+};
+var devRequestEvents = new DevEventEmitter();
+
+// src/dev/transpiler.ts
+import { unlink, mkdir, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve, dirname, basename, join } from "path";
+import { build } from "esbuild";
+var Transpiler = class {
+  projectRoot;
+  outputFiles = /* @__PURE__ */ new Set();
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.cleanupOrphans();
+  }
+  /** Remove any .__ms_dev__.mjs files found in the project source tree (not in node_modules/.cache). */
+  async cleanupOrphans() {
+    try {
+      await removeOrphanedDevFiles(this.projectRoot);
+    } catch {
+    }
+  }
+  /**
+   * Transpile a method file to ESM JavaScript.
+   * Returns the absolute path to the output .mjs file.
+   * Output is written inside the nearest node_modules/.cache/mindstudio-dev/
+   * so ESM resolver can find packages and the repo stays clean.
+   */
+  async transpile(methodPath) {
+    const start = Date.now();
+    const absolutePath = resolve(this.projectRoot, methodPath);
+    const name = basename(absolutePath).replace(/\.[^.]+$/, "");
+    log.debug("transpiler Transpiling", { methodPath });
+    const nodeModulesDir = findNearestNodeModules(dirname(absolutePath));
+    if (!nodeModulesDir) {
+      log.error("transpiler No node_modules found", { methodPath, searchStart: dirname(absolutePath) });
+      throw new Error(
+        `No node_modules found near ${methodPath}. Run npm install first.`
+      );
+    }
+    log.debug("transpiler Found node_modules", { path: nodeModulesDir });
+    const outDir = join(nodeModulesDir, ".cache", "mindstudio-dev");
+    await mkdir(outDir, { recursive: true });
+    const outfile = join(outDir, `${name}.__ms_dev__.mjs`);
+    await build({
+      entryPoints: [absolutePath],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node22",
+      outfile,
+      external: ["@mindstudio-ai/agent"],
+      absWorkingDir: this.projectRoot,
+      logLevel: "silent"
+    });
+    this.outputFiles.add(outfile);
+    log.info(`transpiler Transpiled in ${Date.now() - start}ms`, { methodPath, outfile });
+    return outfile;
+  }
+  /**
+   * Clean up all transpiled output files.
+   */
+  async cleanup() {
+    log.debug("transpiler Cleaning up", { fileCount: this.outputFiles.size });
+    for (const file of this.outputFiles) {
+      await unlink(file).catch(() => {
+      });
+    }
+    this.outputFiles.clear();
+  }
+};
+async function removeOrphanedDevFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await removeOrphanedDevFiles(fullPath);
+    } else if (entry.name.endsWith(".__ms_dev__.mjs")) {
+      log.debug("transpiler Removing orphaned file", { path: fullPath });
+      await unlink(fullPath).catch(() => {
+      });
+    }
+  }
+}
+function findNearestNodeModules(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join(dir, "node_modules");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/dev/executor.ts
+import { spawn } from "child_process";
+import { writeFile, unlink as unlink2 } from "fs/promises";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+var EXECUTION_TIMEOUT_MS = 3e4;
+function buildBootstrapScript(opts) {
+  return `
+global.ai = {
+  auth: ${JSON.stringify(opts.auth)},
+  databases: ${JSON.stringify(opts.databases)},
+};
+
+function serializeError(err) {
+  if (!err) return { message: 'Unknown error' };
+
+  const serialized = {
+    message: String(err.message ?? err),
+    stack: err.stack,
+  };
+
+  // Capture common extra properties from SDK/HTTP errors
+  if (err.code !== undefined) serialized.code = err.code;
+  if (err.statusCode !== undefined) serialized.statusCode = err.statusCode;
+  if (err.status !== undefined) serialized.status = err.status;
+  if (err.response !== undefined) {
+    try { serialized.response = typeof err.response === 'string' ? err.response : JSON.stringify(err.response); } catch {}
+  }
+  if (err.body !== undefined) {
+    try { serialized.body = typeof err.body === 'string' ? err.body : JSON.stringify(err.body); } catch {}
+  }
+  if (err.cause !== undefined) {
+    serialized.cause = serializeError(err.cause);
+  }
+
+  // Capture any other enumerable properties
+  for (const key of Object.keys(err)) {
+    if (!(key in serialized)) {
+      try {
+        const val = err[key];
+        if (val !== undefined && typeof val !== 'function') {
+          serialized[key] = typeof val === 'object' ? JSON.stringify(val) : val;
+        }
+      } catch {}
+    }
+  }
+
+  return serialized;
+}
+
+// Capture console output from method code
+const _stdout = [];
+console.log = (...args) => _stdout.push(args.map(String).join(' '));
+console.warn = (...args) => _stdout.push(args.map(String).join(' '));
+console.error = (...args) => _stdout.push(args.map(String).join(' '));
+
+const _startTime = Date.now();
+
+const { ${opts.methodExport} } = await import(${JSON.stringify(opts.transpiledPath + "?t=" + Date.now())});
+
+try {
+  const returnValue = await ${opts.methodExport}(${JSON.stringify(opts.input)});
+  const _stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - _startTime };
+  process.stdout.write(JSON.stringify({ success: true, output: returnValue, stdout: _stdout, stats: _stats }));
+} catch (err) {
+  const _stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - _startTime };
+  process.stdout.write(JSON.stringify({
+    success: false,
+    error: serializeError(err),
+    stdout: _stdout,
+    stats: _stats,
+  }));
+}
+`;
+}
+async function executeMethod(opts) {
+  const tempFile = join2(
+    tmpdir(),
+    `ms-dev-${randomBytes(8).toString("hex")}.mjs`
+  );
+  const script = buildBootstrapScript(opts);
+  try {
+    await writeFile(tempFile, script, "utf-8");
+    log.debug("executor Spawning node process", { methodExport: opts.methodExport, cwd: opts.projectRoot, tempFile });
+    return await new Promise((resolve2, reject) => {
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      const child = spawn("node", [tempFile], {
+        cwd: opts.projectRoot,
+        env: {
+          ...process.env,
+          // Auth + config env vars read by @mindstudio-ai/agent SDK
+          // for platform callbacks (db queries, etc.)
+          CALLBACK_TOKEN: opts.authorizationToken,
+          REMOTE_HOSTNAME: opts.apiBaseUrl,
+          ...opts.streamId ? { STREAM_ID: opts.streamId } : {}
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+      const timeout = setTimeout(() => {
+        log.warn("executor Timeout after 30s, sending SIGKILL", { methodExport: opts.methodExport });
+        child.kill("SIGKILL");
+        reject(new Error("Method execution timed out after 30s"));
+      }, EXECUTION_TIMEOUT_MS);
+      child.on("close", (code) => {
+        clearTimeout(timeout);
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        log.debug("executor Process exited", { code, stdoutLen: stdout.length, stderrLen: stderr.length });
+        if (stdout) {
+          try {
+            resolve2(JSON.parse(stdout));
+            return;
+          } catch {
+            log.warn("executor Invalid JSON from stdout", { stdout: stdout.slice(0, 200) });
+          }
+        }
+        const errorMessage = stderr || stdout || `Method process exited with code ${code ?? "unknown"}`;
+        resolve2({
+          success: false,
+          error: { message: errorMessage }
+        });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        log.error("executor Process error", { error: err.message });
+        reject(err);
+      });
+    });
+  } finally {
+    await unlink2(tempFile).catch(() => {
+    });
+  }
+}
+
+// src/api.ts
+function getHeaders2() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("Not authenticated. Run: mindstudio-local auth");
+  }
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const userId = getUserId();
+  if (userId) {
+    headers["x-user-id"] = userId;
+  }
+  return headers;
+}
+async function pollForRequest(modelIds) {
+  const baseUrl = getApiBaseUrl();
+  const modelIdsParam = modelIds.join(",");
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/poll?modelIds=${encodeURIComponent(modelIdsParam)}`,
+    {
+      method: "GET",
+      headers: getHeaders2()
+    }
+  );
+  if (response.status === 204) {
+    return null;
+  }
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Poll failed: ${response.status} ${error}`);
+  }
+  const data = await response.json();
+  return data.request;
+}
+async function submitProgress(requestId, content, type = "chunk") {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/requests/${requestId}/progress`,
+    {
+      method: "POST",
+      headers: getHeaders2(),
+      body: JSON.stringify({ type, content })
+    }
+  );
+  if (!response.ok) {
+    console.warn(`Progress update failed: ${response.status}`);
+  }
+}
+async function submitResult(requestId, success, result, error) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/requests/${requestId}/result`,
+    {
+      method: "POST",
+      headers: getHeaders2(),
+      body: JSON.stringify({ success, result, error })
+    }
+  );
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Result submission failed: ${response.status} ${errorText}`
+    );
+  }
+}
+async function verifyApiKey() {
+  const baseUrl = getApiBaseUrl();
+  try {
+    const response = await fetch(`${baseUrl}/v1/local-models/verify-api-key`, {
+      method: "GET",
+      headers: getHeaders2()
+    });
+    return response.status === 204 || response.ok;
+  } catch {
+    return false;
+  }
+}
+async function syncModels(models) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/v1/local-models/models/sync`, {
+    method: "POST",
+    headers: getHeaders2(),
+    body: JSON.stringify({ models })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Sync failed: ${response.status} ${errorText}`);
+  }
+}
+async function getSyncedModels() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/v1/local-models/models`, {
+    method: "GET",
+    headers: getHeaders2()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to fetch synced models: ${response.status} ${errorText}`
+    );
+  }
+  const data = await response.json();
+  return data.models;
+}
+async function requestDeviceAuth() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/developer/v2/request-auth-url`, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Device auth request failed: ${response.status} ${error}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function pollDeviceAuth(token) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/developer/v2/poll-auth-url`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Device auth poll failed: ${response.status} ${error}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function getEditorSessions() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/v1/local-editor/sessions`, {
+    method: "GET",
+    headers: getHeaders2()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to fetch editor sessions: ${response.status} ${errorText}`
+    );
+  }
+  const data = await response.json();
+  return data.editors;
+}
+async function disconnectHeartbeat() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/v1/local-models/disconnect`, {
+    method: "POST",
+    headers: getHeaders2()
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Heartbeat disconnect failed: ${response.status} ${error}`);
+  }
+}
+
+// src/dev/runner.ts
+var DevRunner = class {
+  constructor(appId, projectRoot, startOpts = {}) {
+    this.appId = appId;
+    this.projectRoot = projectRoot;
+    this.startOpts = startOpts;
+  }
+  isRunning = false;
+  session = null;
+  transpiler = null;
+  backoffMs = 1e3;
+  hadConnectionWarning = false;
+  proxyUrl;
+  proxy = null;
+  // proxyUrl is sent on every poll request so the platform dashboard can
+  // show the developer's preview URL. Also included in the start request
+  // so the dashboard sees it immediately without waiting for the first poll.
+  setProxyUrl(url) {
+    this.proxyUrl = url;
+    this.startOpts.proxyUrl = url;
+  }
+  setProxy(proxy) {
+    this.proxy = proxy;
+  }
+  async start() {
+    if (this.isRunning) {
+      throw new Error("DevRunner is already running");
+    }
+    log.info("runner Starting session", { appId: this.appId, branch: this.startOpts.branch });
+    const session = await startDevSession(this.appId, this.startOpts);
+    this.session = session;
+    this.transpiler = new Transpiler(this.projectRoot);
+    this.isRunning = true;
+    this.backoffMs = 1e3;
+    log.info("runner Session started", { sessionId: session.sessionId, branch: session.branch });
+    this.pollLoop();
+    return session;
+  }
+  async stop() {
+    log.info("runner Stopping session");
+    this.isRunning = false;
+    if (this.session) {
+      try {
+        await stopDevSession(this.appId, this.session.sessionId);
+      } catch (err) {
+        log.warn("runner Failed to stop session cleanly", { error: err instanceof Error ? err.message : String(err) });
+      }
+      this.session = null;
+    }
+    if (this.transpiler) {
+      await this.transpiler.cleanup();
+      this.transpiler = null;
+    }
+  }
+  getSession() {
+    return this.session;
+  }
+  // Set role override for subsequent method executions.
+  async setImpersonation(roles) {
+    if (!this.session) return;
+    log.info("runner Impersonating", { roles });
+    const result = await impersonate(this.appId, this.session.sessionId, roles);
+    await this.refreshClientContext();
+    devRequestEvents.emitImpersonate({ roles: result.roles });
+  }
+  // Clear role override — revert to session's default roles.
+  async clearImpersonation() {
+    if (!this.session) return;
+    log.info("runner Clearing impersonation");
+    const result = await impersonate(this.appId, this.session.sessionId, null);
+    await this.refreshClientContext();
+    devRequestEvents.emitImpersonate({ roles: result.roles });
+  }
+  // Fetch fresh clientContext from platform and update the proxy.
+  // Called after impersonation changes so the browser gets a new ms_iface token.
+  async refreshClientContext() {
+    if (!this.session || !this.proxy) return;
+    try {
+      const context = await refreshContext(this.appId, this.session.sessionId);
+      this.session.clientContext = context;
+      this.proxy.updateClientContext(context);
+    } catch (err) {
+      log.warn("runner Failed to refresh client context", { error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  // Run a scenario: truncate tables → execute seed → impersonate roles.
+  // Called directly (not via poll loop) by the TUI or headless stdin.
+  async runScenario(scenario) {
+    if (!this.session || !this.transpiler) {
+      return { success: false, databases: [], error: "Session not started" };
+    }
+    const startTime = Date.now();
+    const scenarioName = scenario.name ?? scenario.export;
+    devRequestEvents.emitScenarioStart({
+      id: scenario.id,
+      name: scenarioName,
+      timestamp: startTime
+    });
+    log.info("runner Running scenario", { id: scenario.id, name: scenarioName });
+    try {
+      log.debug("runner Truncating database for scenario");
+      const databases = await resetDevDatabase(this.appId, this.session.sessionId, "truncate");
+      this.session.databases = databases;
+      log.debug("runner Transpiling scenario", { path: scenario.path });
+      const transpiledPath = await this.transpiler.transpile(scenario.path);
+      log.debug("runner Fetching callback token for scenario");
+      const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
+      log.debug("runner Executing scenario seed", { export: scenario.export });
+      const result = await executeMethod({
+        transpiledPath,
+        methodExport: scenario.export,
+        input: {},
+        auth: this.session.auth,
+        databases: this.session.databases,
+        authorizationToken,
+        apiBaseUrl: getApiBaseUrl(),
+        projectRoot: this.projectRoot
+      });
+      if (!result.success) {
+        const error = result.error?.message ?? "Scenario seed failed";
+        log.error("runner Scenario seed failed", { id: scenario.id, error });
+        devRequestEvents.emitScenarioComplete({
+          id: scenario.id,
+          success: false,
+          duration: Date.now() - startTime,
+          roles: scenario.roles,
+          error
+        });
+        return { success: false, databases, error };
+      }
+      if (scenario.roles.length > 0) {
+        log.debug("runner Impersonating for scenario", { roles: scenario.roles });
+        await impersonate(this.appId, this.session.sessionId, scenario.roles);
+        await this.refreshClientContext();
+      }
+      const duration = Date.now() - startTime;
+      log.info("runner Scenario complete", { id: scenario.id, duration, roles: scenario.roles });
+      devRequestEvents.emitScenarioComplete({
+        id: scenario.id,
+        success: true,
+        duration,
+        roles: scenario.roles
+      });
+      return { success: true, databases };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error";
+      log.error("runner Scenario failed", { id: scenario.id, error });
+      devRequestEvents.emitScenarioComplete({
+        id: scenario.id,
+        success: false,
+        duration: Date.now() - startTime,
+        roles: scenario.roles,
+        error
+      });
+      return { success: false, databases: this.session.databases, error };
+    }
+  }
+  async pollLoop() {
+    while (this.isRunning) {
+      try {
+        const request = await pollDevRequest(
+          this.appId,
+          this.session.sessionId,
+          this.proxyUrl
+        );
+        if (this.hadConnectionWarning) {
+          this.hadConnectionWarning = false;
+          log.info("runner Connection restored");
+          devRequestEvents.emitConnectionRestored();
+        }
+        if (request) {
+          this.handleRequest(request);
+        }
+        this.backoffMs = 1e3;
+      } catch (error) {
+        if (error instanceof DevPollError && error.statusCode === 404) {
+          log.error("runner Session expired (404)");
+          devRequestEvents.emitSessionExpired();
+          this.isRunning = false;
+          return;
+        }
+        if ((error instanceof DevPollError || error instanceof ApiError) && error.statusCode === 401) {
+          log.warn("runner Auth token expired (401), attempting refresh");
+          const refreshed = await this.refreshAuth();
+          if (refreshed) {
+            this.backoffMs = 1e3;
+            continue;
+          }
+          log.error("runner Auth refresh failed, stopping");
+          devRequestEvents.emitSessionExpired();
+          this.isRunning = false;
+          return;
+        }
+        if (!this.hadConnectionWarning) {
+          this.hadConnectionWarning = true;
+          log.warn("runner Connection lost, retrying...");
+          devRequestEvents.emitConnectionWarning(
+            "Lost connection to platform, retrying..."
+          );
+        }
+        log.debug("runner Backing off", { ms: this.backoffMs });
+        await this.sleep(this.backoffMs);
+        this.backoffMs = Math.min(this.backoffMs * 2, 3e4);
+      }
+    }
+  }
+  async handleRequest(request) {
+    const startTime = Date.now();
+    devRequestEvents.emitStart({
+      id: request.requestId,
+      type: request.type,
+      method: request.methodExport,
+      timestamp: startTime
+    });
+    log.info("runner Request received", { requestId: request.requestId, method: request.methodExport });
+    try {
+      log.debug("runner Transpiling", { path: request.methodPath });
+      const transpiledPath = await this.transpiler.transpile(request.methodPath);
+      const auth = request.roleOverride ? {
+        userId: this.session.auth.userId,
+        roleAssignments: request.roleOverride.map((roleName) => ({
+          userId: this.session.auth.userId,
+          roleName
+        }))
+      } : this.session.auth;
+      const result = await executeMethod({
+        transpiledPath,
+        methodExport: request.methodExport,
+        input: request.input,
+        auth,
+        databases: this.session.databases,
+        authorizationToken: request.authorizationToken,
+        apiBaseUrl: getApiBaseUrl(),
+        projectRoot: this.projectRoot,
+        streamId: request.streamId
+      });
+      const devResult = {
+        type: "execute",
+        success: result.success,
+        output: result.output,
+        error: result.error,
+        stdout: result.stdout,
+        stats: result.stats
+      };
+      await submitDevResult(
+        this.appId,
+        this.session.sessionId,
+        request.requestId,
+        devResult
+      );
+      const duration = Date.now() - startTime;
+      log.info("runner Request complete", { requestId: request.requestId, success: result.success, duration });
+      devRequestEvents.emitComplete({
+        id: request.requestId,
+        success: result.success,
+        duration,
+        error: result.error ? formatErrorForDisplay(result.error) : void 0
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      const duration = Date.now() - startTime;
+      log.error("runner Request failed", { requestId: request.requestId, duration, error: message });
+      try {
+        await submitDevResult(
+          this.appId,
+          this.session.sessionId,
+          request.requestId,
+          {
+            type: "execute",
+            success: false,
+            error: { message }
+          }
+        );
+      } catch (submitErr) {
+        log.error("runner Failed to submit error result", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+      }
+      devRequestEvents.emitComplete({
+        id: request.requestId,
+        success: false,
+        duration: Date.now() - startTime,
+        error: message
+      });
+    }
+  }
+  /**
+   * Attempt to refresh expired auth credentials via the device auth flow.
+   * Opens the browser for the user to re-authorize, polls for the new token.
+   * Returns true if refresh succeeded.
+   */
+  async refreshAuth() {
+    const POLL_INTERVAL = 2e3;
+    const MAX_ATTEMPTS = 30;
+    try {
+      log.info("runner Auth expired, requesting re-authentication");
+      const { url, token } = await requestDeviceAuth();
+      devRequestEvents.emitAuthRefreshStart(url);
+      try {
+        const open = (await import("open")).default;
+        await open(url);
+      } catch {
+        log.warn("runner Could not open browser for auth \u2014 user must visit URL manually");
+      }
+      for (let i = 0; i < MAX_ATTEMPTS; i++) {
+        await this.sleep(POLL_INTERVAL);
+        if (!this.isRunning) return false;
+        const result = await pollDeviceAuth(token);
+        if (result.status === "completed" && result.apiKey) {
+          setApiKey(result.apiKey);
+          if (result.userId) {
+            setUserId(result.userId);
+          }
+          log.info("runner Auth refreshed successfully");
+          devRequestEvents.emitAuthRefreshSuccess();
+          return true;
+        }
+        if (result.status === "expired") {
+          break;
+        }
+      }
+      log.error("runner Auth refresh timed out or was denied");
+      devRequestEvents.emitAuthRefreshFailed();
+      return false;
+    } catch (err) {
+      log.error("runner Auth refresh failed", { error: err instanceof Error ? err.message : String(err) });
+      devRequestEvents.emitAuthRefreshFailed();
+      return false;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+};
+function formatErrorForDisplay(error) {
+  const parts = [];
+  if (error.message) {
+    parts.push(String(error.message));
+  }
+  const code = error.code ?? error.statusCode ?? error.status;
+  if (code !== void 0) {
+    parts.push(`(code: ${code})`);
+  }
+  if (error.body) {
+    parts.push(`Response: ${String(error.body).slice(0, 200)}`);
+  } else if (error.response) {
+    parts.push(`Response: ${String(error.response).slice(0, 200)}`);
+  }
+  if (error.cause && typeof error.cause === "object") {
+    const cause = error.cause;
+    if (cause.message) {
+      parts.push(`Caused by: ${cause.message}`);
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/dev/proxy.ts
+import http from "http";
+var DevProxy = class {
+  constructor(upstreamPort, clientContext, bindAddress = "127.0.0.1") {
+    this.upstreamPort = upstreamPort;
+    this.clientContext = clientContext;
+    this.bindAddress = bindAddress;
+  }
+  server = null;
+  proxyPort = null;
+  updateClientContext(context) {
+    this.clientContext = context;
+    log.info("proxy Client context updated");
+  }
+  async start(preferredPort) {
+    const server = http.createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    server.on("upgrade", (req, socket, head) => {
+      this.handleUpgrade(req, socket, head);
+    });
+    const portsToTry = preferredPort ? [preferredPort, 0] : [0];
+    for (const port of portsToTry) {
+      try {
+        const assignedPort = await this.listenOnPort(server, port);
+        this.server = server;
+        this.proxyPort = assignedPort;
+        log.info("proxy Started", { port: assignedPort, bind: this.bindAddress });
+        return assignedPort;
+      } catch {
+        log.warn("proxy Port in use, trying next", { port });
+      }
+    }
+    throw new Error("Failed to start proxy server");
+  }
+  listenOnPort(server, port) {
+    return new Promise((resolve2, reject) => {
+      const onError = (err) => {
+        server.removeListener("error", onError);
+        reject(err);
+      };
+      server.on("error", onError);
+      server.listen(port, this.bindAddress, () => {
+        server.removeListener("error", onError);
+        const addr = server.address();
+        if (!addr || typeof addr === "string") {
+          reject(new Error("Failed to get proxy server address"));
+          return;
+        }
+        resolve2(addr.port);
+      });
+    });
+  }
+  stop() {
+    if (this.server) {
+      log.info("proxy Stopping");
+      this.server.close();
+      this.server = null;
+      this.proxyPort = null;
+    }
+  }
+  getPort() {
+    return this.proxyPort;
+  }
+  handleRequest(clientReq, clientRes) {
+    const origin = clientReq.headers.origin;
+    if (clientReq.method === "OPTIONS" && origin) {
+      clientRes.writeHead(204, {
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Private-Network": "true",
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "*"
+      });
+      clientRes.end();
+      return;
+    }
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.upstreamPort,
+      path: clientReq.url,
+      method: clientReq.method,
+      headers: { ...clientReq.headers, host: `localhost:${this.upstreamPort}` }
+    };
+    const upstreamReq = http.request(options, (upstreamRes) => {
+      const contentType = upstreamRes.headers["content-type"] ?? "";
+      const isHtml = contentType.startsWith("text/html");
+      if (isHtml) {
+        const chunks = [];
+        upstreamRes.on("data", (chunk) => chunks.push(chunk));
+        upstreamRes.on("end", () => {
+          let html = Buffer.concat(chunks).toString("utf-8");
+          html = injectClientContext(html, this.clientContext);
+          const headers = { ...upstreamRes.headers };
+          headers["content-length"] = String(Buffer.byteLength(html, "utf-8"));
+          headers["cache-control"] = "no-store, no-cache, must-revalidate";
+          delete headers["content-encoding"];
+          delete headers["etag"];
+          if (origin) {
+            headers["access-control-allow-origin"] = origin;
+            headers["access-control-allow-private-network"] = "true";
+          }
+          log.debug("proxy HTML injected", { path: clientReq.url, size: html.length });
+          clientRes.writeHead(upstreamRes.statusCode ?? 200, headers);
+          clientRes.end(html);
+        });
+      } else {
+        const headers = { ...upstreamRes.headers };
+        headers["cache-control"] = "no-store, no-cache, must-revalidate";
+        delete headers["etag"];
+        if (origin) {
+          headers["access-control-allow-origin"] = origin;
+          headers["access-control-allow-private-network"] = "true";
+        }
+        clientRes.writeHead(upstreamRes.statusCode ?? 200, headers);
+        upstreamRes.pipe(clientRes);
+      }
+    });
+    upstreamReq.on("error", (err) => {
+      log.warn("proxy Upstream error", { path: clientReq.url, error: err.message });
+      clientRes.writeHead(502);
+      clientRes.end(`Proxy error: ${err.message}`);
+    });
+    clientReq.pipe(upstreamReq);
+  }
+  handleUpgrade(clientReq, clientSocket, head) {
+    log.debug("proxy WebSocket upgrade", { path: clientReq.url });
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.upstreamPort,
+      path: clientReq.url,
+      method: clientReq.method,
+      headers: { ...clientReq.headers, host: `localhost:${this.upstreamPort}` }
+    };
+    const upstreamReq = http.request(options);
+    upstreamReq.on("upgrade", (upstreamRes, upstreamSocket, upgradeHead) => {
+      let responseHead = `HTTP/${upstreamRes.httpVersion} ${upstreamRes.statusCode} ${upstreamRes.statusMessage}\r
+`;
+      for (let i = 0; i < upstreamRes.rawHeaders.length; i += 2) {
+        responseHead += `${upstreamRes.rawHeaders[i]}: ${upstreamRes.rawHeaders[i + 1]}\r
+`;
+      }
+      responseHead += "\r\n";
+      clientSocket.write(responseHead);
+      if (upgradeHead.length > 0) {
+        clientSocket.write(upgradeHead);
+      }
+      if (head.length > 0) {
+        upstreamSocket.write(head);
+      }
+      upstreamSocket.pipe(clientSocket);
+      clientSocket.pipe(upstreamSocket);
+      clientSocket.on("close", () => upstreamSocket.destroy());
+      upstreamSocket.on("close", () => clientSocket.destroy());
+      clientSocket.on("error", () => upstreamSocket.destroy());
+      upstreamSocket.on("error", () => clientSocket.destroy());
+    });
+    upstreamReq.on("error", () => {
+      clientSocket.destroy();
+    });
+    upstreamReq.end();
+  }
+};
+function injectClientContext(html, context) {
+  const script = `<script>window.__MINDSTUDIO__=${JSON.stringify(context)};</script>`;
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${script}
+</head>`);
+  }
+  return script + "\n" + html;
+}
+
+// src/dev/app-config.ts
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+function detectAppConfig(cwd = process.cwd()) {
+  const appJsonPath = join3(cwd, "mindstudio.json");
+  if (!existsSync2(appJsonPath)) {
+    log.debug("config mindstudio.json not found", { path: appJsonPath });
+    return null;
+  }
+  try {
+    const raw = readFileSync(appJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.name || !Array.isArray(parsed.methods)) {
+      return null;
+    }
+    const config2 = {
+      appId: parsed.appId,
+      name: parsed.name,
+      description: parsed.description,
+      roles: parsed.roles ?? [],
+      tables: parsed.tables ?? [],
+      methods: parsed.methods,
+      scenarios: parsed.scenarios ?? [],
+      interfaces: parsed.interfaces ?? []
+    };
+    log.debug("config Detected mindstudio.json", {
+      appId: config2.appId,
+      roles: config2.roles.length,
+      methods: config2.methods.length,
+      tables: config2.tables.length,
+      scenarios: config2.scenarios.length,
+      interfaces: config2.interfaces.length
+    });
+    return config2;
+  } catch (err) {
+    log.warn("config Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
+    return null;
+  }
+}
+function getWebInterfaceConfig(appConfig, cwd = process.cwd()) {
+  const webInterface = appConfig.interfaces.find(
+    (i) => i.type === "web" && i.enabled !== false
+  );
+  if (!webInterface) {
+    return null;
+  }
+  const configPath = join3(cwd, webInterface.path);
+  if (!existsSync2(configPath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const web = parsed.web;
+    if (!web || typeof web !== "object") {
+      return null;
+    }
+    return {
+      devPort: typeof web.devPort === "number" ? web.devPort : void 0,
+      devCommand: typeof web.devCommand === "string" ? web.devCommand : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function getWebProjectDir(appConfig, cwd = process.cwd()) {
+  const webInterface = appConfig.interfaces.find(
+    (i) => i.type === "web" && i.enabled !== false
+  );
+  if (!webInterface) {
+    return null;
+  }
+  return dirname2(join3(cwd, webInterface.path));
+}
+function readTableSources(appConfig, cwd = process.cwd()) {
+  const results = [];
+  for (const table of appConfig.tables) {
+    const filePath = join3(cwd, table.path);
+    if (!existsSync2(filePath)) {
+      continue;
+    }
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      const name = table.export;
+      results.push({ name, source });
+    } catch {
+    }
+  }
+  return results;
+}
+function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
+  const dirs = [];
+  if (appConfig.methods.length > 0) {
+    const firstMethodPath = appConfig.methods[0].path;
+    const parts = firstMethodPath.split("/");
+    for (let i = parts.length - 1; i >= 1; i--) {
+      const candidate = join3(cwd, ...parts.slice(0, i));
+      if (existsSync2(join3(candidate, "package.json"))) {
+        if (!existsSync2(join3(candidate, "node_modules"))) {
+          dirs.push(candidate);
+        }
+        break;
+      }
+    }
+  }
+  const webProjectDir = getWebProjectDir(appConfig, cwd);
+  if (webProjectDir && existsSync2(join3(webProjectDir, "package.json"))) {
+    if (!existsSync2(join3(webProjectDir, "node_modules"))) {
+      dirs.push(webProjectDir);
+    }
+  }
+  return dirs;
+}
+
+// src/dev/utils.ts
+import { execSync } from "child_process";
+function stablePort(appId) {
+  let hash = 0;
+  for (let i = 0; i < appId.length; i++) {
+    hash = (hash << 5) - hash + appId.charCodeAt(i) | 0;
+  }
+  return 3100 + Math.abs(hash) % 900;
+}
+function detectGitBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/dev/table-watcher.ts
+import { watch } from "fs";
+import { join as join4, dirname as dirname3, basename as basename2 } from "path";
+function watchTableFiles(tables, cwd, onChanged) {
+  if (tables.length === 0) return () => {
+  };
+  const dirToFiles = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const absPath = join4(cwd, table.path);
+    const dir = dirname3(absPath);
+    const file = basename2(absPath);
+    if (!dirToFiles.has(dir)) dirToFiles.set(dir, /* @__PURE__ */ new Set());
+    dirToFiles.get(dir).add(file);
+  }
+  let syncTimer;
+  const cleanups = [];
+  cleanups.push(() => clearTimeout(syncTimer));
+  for (const [dir, expectedFiles] of dirToFiles) {
+    try {
+      const w = watch(dir, (_eventType, filename) => {
+        if (filename && !expectedFiles.has(filename)) return;
+        clearTimeout(syncTimer);
+        syncTimer = setTimeout(onChanged, 500);
+      });
+      cleanups.push(() => w.close());
+    } catch {
+    }
+  }
+  log.info("table-watcher Watching directories", {
+    dirs: dirToFiles.size,
+    tables: tables.length
+  });
+  return () => {
+    for (const cleanup of cleanups) cleanup();
+  };
+}
+
+export {
+  getEnvironment,
+  getApiKey,
+  setApiKey,
+  getUserId,
+  setUserId,
+  getApiBaseUrl,
+  getConfigPath,
+  getProviderBaseUrl,
+  setProviderBaseUrl,
+  getProviderInstallPath,
+  setProviderInstallPath,
+  getLocalInterfacesDir,
+  getLocalInterfacePath,
+  setLocalInterfacePath,
+  deleteLocalInterfacePath,
+  log,
+  initLoggerHeadless,
+  initLoggerInteractive,
+  syncSchema,
+  devRequestEvents,
+  pollForRequest,
+  submitProgress,
+  submitResult,
+  verifyApiKey,
+  syncModels,
+  getSyncedModels,
+  requestDeviceAuth,
+  pollDeviceAuth,
+  getEditorSessions,
+  disconnectHeartbeat,
+  DevRunner,
+  DevProxy,
+  detectAppConfig,
+  getWebInterfaceConfig,
+  getWebProjectDir,
+  readTableSources,
+  findDirsNeedingInstall,
+  stablePort,
+  detectGitBranch,
+  watchTableFiles
+};
+//# sourceMappingURL=chunk-C3JPRLSS.js.map