@framer/agent 0.0.0 → 0.0.29

package/dist/start-relay-server.js

@@ -0,0 +1,1669 @@
+import fs4 from 'fs';
+import os5 from 'os';
+import path5 from 'path';
+import { execFileSync } from 'child_process';
+import 'net';
+import { fileURLToPath } from 'url';
+import { createTRPCClient, httpLink } from '@trpc/client';
+import crypto, { randomUUID, timingSafeEqual } from 'crypto';
+import http from 'http';
+import { createHTTPHandler } from '@trpc/server/adapters/standalone';
+import { initTRPC, TRPCError } from '@trpc/server';
+import { connect, FramerAPIError } from 'framer-api';
+import { z } from 'zod';
+import { createRequire } from 'module';
+import * as vm from 'vm';
+
+/* @framer/ai relay server v0.0.29 */
+var __defProp = Object.defineProperty;
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name2);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+// package.json
+var name = "@framer/agent";
+
+// src/check-node-version.ts
+var MINIMUM_NODE_VERSION = 22;
+var currentMajor = Number(process.versions.node.split(".")[0]);
+if (currentMajor < MINIMUM_NODE_VERSION) {
+  console.error(
+    `${name} requires Node.js >= ${MINIMUM_NODE_VERSION}. You are running Node.js ${process.versions.node}.
+Please upgrade: https://nodejs.org/`
+  );
+  process.exit(1);
+}
+var DEFAULT_MAX_LOG_FILE_BYTES = 1024 * 1024;
+var DEFAULT_RETAINED_LOG_FILE_BYTES = 512 * 1024;
+var LOG_TRIM_CHECK_INTERVAL = 10;
+var maxLogFileBytes = DEFAULT_MAX_LOG_FILE_BYTES;
+var retainedLogFileBytes = DEFAULT_RETAINED_LOG_FILE_BYTES;
+function getLogPath() {
+  if (process.env.XDG_STATE_HOME) {
+    return path5.join(process.env.XDG_STATE_HOME, "framer", "relay.log");
+  }
+  if (process.platform === "win32") {
+    return path5.join(
+      process.env.APPDATA || os5.homedir(),
+      "framer",
+      "relay.log"
+    );
+  }
+  return path5.join(os5.homedir(), ".local", "state", "framer", "relay.log");
+}
+__name(getLogPath, "getLogPath");
+var logPath = getLogPath();
+var initialized = false;
+var logEntriesSinceTrimCheck = LOG_TRIM_CHECK_INTERVAL - 1;
+function ensureLogDir() {
+  if (initialized) return;
+  const dir = path5.dirname(logPath);
+  fs4.mkdirSync(dir, { recursive: true });
+  initialized = true;
+}
+__name(ensureLogDir, "ensureLogDir");
+function trimLogFileIfNeeded() {
+  logEntriesSinceTrimCheck += 1;
+  if (logEntriesSinceTrimCheck < LOG_TRIM_CHECK_INTERVAL) return;
+  logEntriesSinceTrimCheck = 0;
+  let size;
+  try {
+    size = fs4.statSync(logPath).size;
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return;
+    }
+    throw err;
+  }
+  if (size <= maxLogFileBytes) return;
+  const retainedBytes = Math.min(retainedLogFileBytes, size);
+  const buffer = Buffer.alloc(retainedBytes);
+  const file = fs4.openSync(logPath, "r");
+  let bytesRead = 0;
+  try {
+    bytesRead = fs4.readSync(
+      file,
+      buffer,
+      0,
+      retainedBytes,
+      size - retainedBytes
+    );
+  } finally {
+    fs4.closeSync(file);
+  }
+  fs4.writeFileSync(logPath, buffer.subarray(0, bytesRead));
+}
+__name(trimLogFileIfNeeded, "trimLogFileIfNeeded");
+function log(message) {
+  ensureLogDir();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  fs4.appendFileSync(logPath, `${timestamp} ${message}
+`);
+  trimLogFileIfNeeded();
+}
+__name(log, "log");
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path5.join(process.env.XDG_CONFIG_HOME, "framer");
+  }
+  if (process.platform === "win32") {
+    return path5.join(process.env.APPDATA || os5.homedir(), "framer");
+  }
+  return path5.join(os5.homedir(), ".config", "framer");
+}
+__name(getConfigDir, "getConfigDir");
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  fs4.mkdirSync(configDir, { recursive: true, mode: 448 });
+}
+__name(ensureConfigDir, "ensureConfigDir");
+
+// src/config/relay-token.ts
+function getRelayTokenPath() {
+  return path5.join(getConfigDir(), "relay-token");
+}
+__name(getRelayTokenPath, "getRelayTokenPath");
+function generateRelayToken() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+__name(generateRelayToken, "generateRelayToken");
+function readRelayToken() {
+  try {
+    const token = fs4.readFileSync(getRelayTokenPath(), "utf-8").trim();
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+__name(readRelayToken, "readRelayToken");
+function writeRelayToken(token) {
+  ensureConfigDir();
+  fs4.writeFileSync(getRelayTokenPath(), token, { mode: 384 });
+}
+__name(writeRelayToken, "writeRelayToken");
+function clearRelayToken(expectedToken) {
+  const filePath = getRelayTokenPath();
+  if (expectedToken) {
+    const currentToken = readRelayToken();
+    if (currentToken !== expectedToken) {
+      return;
+    }
+  }
+  fs4.rmSync(filePath, { force: true });
+}
+__name(clearRelayToken, "clearRelayToken");
+function debug(tag, message) {
+  return;
+}
+__name(debug, "debug");
+
+// src/version.ts
+var VERSION = (
+  // typeof is used to ensure this can be used just via tsx or node etc. without build
+  "0.0.29" 
+);
+
+// src/relay-client.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+path5.dirname(__filename$1);
+var RELAY_PORT = Number(process.env.FRAMER_CLI_PORT) || 19988;
+createTRPCClient({
+  links: [
+    httpLink({
+      url: `http://127.0.0.1:${RELAY_PORT}`,
+      headers() {
+        const token = readRelayToken();
+        if (!token) {
+          return {};
+        }
+        return { Authorization: `Bearer ${token}` };
+      }
+    })
+  ]
+});
+
+// src/agent-thread-context.ts
+var MAX_AGENT_THREAD_ID_LENGTH = 256;
+var MAX_AGENT_PROVIDER_LENGTH = 64;
+var SAFE_VALUE_PATTERN = /^[A-Za-z0-9._:-]+$/;
+function normalizeValue(value, maxLength) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.length > maxLength) return void 0;
+  if (!SAFE_VALUE_PATTERN.test(trimmed)) return void 0;
+  return trimmed;
+}
+__name(normalizeValue, "normalizeValue");
+function normalizeAgentThreadContext(input) {
+  const agentThreadId = normalizeValue(
+    input.agentThreadId,
+    MAX_AGENT_THREAD_ID_LENGTH
+  );
+  if (!agentThreadId) return {};
+  const agentProvider = normalizeValue(
+    input.agentProvider,
+    MAX_AGENT_PROVIDER_LENGTH
+  );
+  return {
+    agentThreadId,
+    ...agentProvider ? { agentProvider } : {}
+  };
+}
+__name(normalizeAgentThreadContext, "normalizeAgentThreadContext");
+
+// src/connection-errors.ts
+var CONNECTION_ERROR_PATTERNS = [
+  "Connection closed",
+  // FramerAPIError PROJECT_CLOSED
+  "Connection to the server was closed",
+  // FramerAPIError PROJECT_CLOSED
+  "Connection timeout after",
+  // FramerAPIError TIMEOUT
+  "No connection to the server",
+  // FramerAPIError INTERNAL
+  "WebSocket upgrade failed",
+  // WebSocket handshake failure
+  "Session is not connected",
+  // Our own check in executor.ts
+  "Execution timed out after",
+  // Likely dead connection
+  "Session expired",
+  // Server-side session expiry
+  // Typed page-death (PROJECT_CLOSED) for the string fallback; isRetryableError is the primary path.
+  "Project session crashed",
+  // PageCrashedError (renderer crash / OOM)
+  "Project was closed",
+  // StaleSessionError (page closed/reaped)
+  "Session was recycled"
+  // SessionRecycledError (destroy->respawn reconnect race)
+];
+function isConnectionError(errorMessage) {
+  return CONNECTION_ERROR_PATTERNS.some(
+    (pattern) => errorMessage.includes(pattern)
+  );
+}
+__name(isConnectionError, "isConnectionError");
+function isRetryableError(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (e.retryable === true) return true;
+    if (e.code === "PROJECT_CLOSED") return true;
+    if (typeof e.message === "string" && isConnectionError(e.message))
+      return true;
+    return false;
+  }
+  return typeof err === "string" && isConnectionError(err);
+}
+__name(isRetryableError, "isRetryableError");
+var AUTH_ERROR_PATTERNS = ["does not have access", "UNAUTHORIZED"];
+function isAuthError(errorMessage) {
+  return AUTH_ERROR_PATTERNS.some((p) => errorMessage.includes(p));
+}
+__name(isAuthError, "isAuthError");
+var ScopedFS = class {
+  static {
+    __name(this, "ScopedFS");
+  }
+  allowedRoots;
+  constructor(allowedDirs) {
+    const defaultDirs = [process.cwd(), "/tmp", os5.tmpdir()];
+    const dirs = allowedDirs ?? defaultDirs;
+    this.allowedRoots = [
+      ...new Set(dirs.map((dir) => this.canonicalizePath(dir)))
+    ];
+  }
+  isPathAllowed(candidatePath) {
+    return this.allowedRoots.some((allowedRoot) => {
+      return candidatePath === allowedRoot || candidatePath.startsWith(allowedRoot + path5.sep);
+    });
+  }
+  resolvePath(filePath) {
+    const resolvedPath = path5.resolve(filePath);
+    const canonicalPath = this.canonicalizePath(resolvedPath);
+    if (!this.isPathAllowed(canonicalPath)) {
+      this.throwOutsideAllowedRoots(filePath);
+    }
+    return resolvedPath;
+  }
+  canonicalizePath(inputPath) {
+    const resolvedPath = path5.resolve(inputPath);
+    const missingSegments = [];
+    let ancestorPath = resolvedPath;
+    while (true) {
+      const realPath = this.resolveRealPath(ancestorPath);
+      if (realPath !== null) {
+        return path5.resolve(realPath, ...missingSegments);
+      }
+      if (this.isSymbolicLink(ancestorPath)) {
+        this.throwOutsideAllowedRoots(inputPath);
+      }
+      const parentPath = path5.dirname(ancestorPath);
+      if (parentPath === ancestorPath) {
+        return resolvedPath;
+      }
+      missingSegments.unshift(path5.basename(ancestorPath));
+      ancestorPath = parentPath;
+    }
+  }
+  resolveRealPath(targetPath) {
+    try {
+      return path5.resolve(fs4.realpathSync.native(targetPath));
+    } catch (error) {
+      const errnoError = error;
+      if (errnoError.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  isSymbolicLink(targetPath) {
+    try {
+      return fs4.lstatSync(targetPath).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  throwOutsideAllowedRoots(filePath) {
+    const error = new Error(
+      `EPERM: operation not permitted, access outside allowed directories: ${filePath}`
+    );
+    error.code = "EPERM";
+    error.errno = -1;
+    error.syscall = "access";
+    error.path = filePath;
+    throw error;
+  }
+  // Sync methods
+  readFileSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs4.readFileSync(resolved, options);
+  }, "readFileSync");
+  writeFileSync = /* @__PURE__ */ __name((filePath, data, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs4.writeFileSync(
+      resolved,
+      data,
+      options
+    );
+  }, "writeFileSync");
+  appendFileSync = /* @__PURE__ */ __name((filePath, data, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs4.appendFileSync(
+      resolved,
+      data,
+      options
+    );
+  }, "appendFileSync");
+  readdirSync = /* @__PURE__ */ __name((dirPath, options) => {
+    const resolved = this.resolvePath(dirPath.toString());
+    return fs4.readdirSync(resolved, options);
+  }, "readdirSync");
+  mkdirSync = /* @__PURE__ */ __name((dirPath, options) => {
+    const resolved = this.resolvePath(dirPath.toString());
+    return fs4.mkdirSync(resolved, options);
+  }, "mkdirSync");
+  rmdirSync = /* @__PURE__ */ __name((dirPath, options) => {
+    const resolved = this.resolvePath(dirPath.toString());
+    fs4.rmdirSync(resolved, options);
+  }, "rmdirSync");
+  unlinkSync = /* @__PURE__ */ __name((filePath) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs4.unlinkSync(resolved);
+  }, "unlinkSync");
+  statSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs4.statSync(resolved, options);
+  }, "statSync");
+  lstatSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs4.lstatSync(resolved, options);
+  }, "lstatSync");
+  existsSync = /* @__PURE__ */ __name((filePath) => {
+    try {
+      const resolved = this.resolvePath(filePath.toString());
+      return fs4.existsSync(resolved);
+    } catch {
+      return false;
+    }
+  }, "existsSync");
+  accessSync = /* @__PURE__ */ __name((filePath, mode) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs4.accessSync(resolved, mode);
+  }, "accessSync");
+  copyFileSync = /* @__PURE__ */ __name((src, dest, mode) => {
+    const resolvedSrc = this.resolvePath(src.toString());
+    const resolvedDest = this.resolvePath(dest.toString());
+    fs4.copyFileSync(resolvedSrc, resolvedDest, mode);
+  }, "copyFileSync");
+  renameSync = /* @__PURE__ */ __name((oldPath, newPath) => {
+    const resolvedOld = this.resolvePath(oldPath.toString());
+    const resolvedNew = this.resolvePath(newPath.toString());
+    fs4.renameSync(resolvedOld, resolvedNew);
+  }, "renameSync");
+  rmSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs4.rmSync(resolved, options);
+  }, "rmSync");
+  // Stream methods
+  createReadStream = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs4.createReadStream(resolved, options);
+  }, "createReadStream");
+  createWriteStream = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs4.createWriteStream(resolved, options);
+  }, "createWriteStream");
+  // Promise-based API (fs.promises equivalent)
+  get promises() {
+    return {
+      readFile: /* @__PURE__ */ __name(async (filePath, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.readFile(
+          resolved,
+          options
+        );
+      }, "readFile"),
+      writeFile: /* @__PURE__ */ __name(async (filePath, data, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.writeFile(
+          resolved,
+          data,
+          options
+        );
+      }, "writeFile"),
+      appendFile: /* @__PURE__ */ __name(async (filePath, data, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.appendFile(
+          resolved,
+          data,
+          options
+        );
+      }, "appendFile"),
+      readdir: /* @__PURE__ */ __name(async (dirPath, options) => {
+        const resolved = this.resolvePath(dirPath.toString());
+        return fs4.promises.readdir(
+          resolved,
+          options
+        );
+      }, "readdir"),
+      mkdir: /* @__PURE__ */ __name(async (dirPath, options) => {
+        const resolved = this.resolvePath(dirPath.toString());
+        return fs4.promises.mkdir(resolved, options);
+      }, "mkdir"),
+      rmdir: /* @__PURE__ */ __name(async (dirPath, options) => {
+        const resolved = this.resolvePath(dirPath.toString());
+        return fs4.promises.rmdir(resolved, options);
+      }, "rmdir"),
+      unlink: /* @__PURE__ */ __name(async (filePath) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.unlink(resolved);
+      }, "unlink"),
+      stat: /* @__PURE__ */ __name(async (filePath, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.stat(resolved, options);
+      }, "stat"),
+      access: /* @__PURE__ */ __name(async (filePath, mode) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.access(resolved, mode);
+      }, "access"),
+      copyFile: /* @__PURE__ */ __name(async (src, dest, mode) => {
+        const resolvedSrc = this.resolvePath(src.toString());
+        const resolvedDest = this.resolvePath(dest.toString());
+        return fs4.promises.copyFile(resolvedSrc, resolvedDest, mode);
+      }, "copyFile"),
+      rename: /* @__PURE__ */ __name(async (oldPath, newPath) => {
+        const resolvedOld = this.resolvePath(oldPath.toString());
+        const resolvedNew = this.resolvePath(newPath.toString());
+        return fs4.promises.rename(resolvedOld, resolvedNew);
+      }, "rename"),
+      rm: /* @__PURE__ */ __name(async (filePath, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs4.promises.rm(resolved, options);
+      }, "rm")
+    };
+  }
+  constants = fs4.constants;
+};
+function getErrorRef(error) {
+  if (!(error instanceof Error)) return void 0;
+  const ref = error.ref;
+  return typeof ref === "string" && ref.length > 0 ? ref : void 0;
+}
+__name(getErrorRef, "getErrorRef");
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+__name(formatError, "formatError");
+
+// src/execute.ts
+var EXECUTION_TIMEOUT = 10 * 60 * 1e3;
+var baseRequire = createRequire(import.meta.url);
+var ALLOWED_MODULES = /* @__PURE__ */ new Set([
+  "path",
+  "node:path",
+  "url",
+  "node:url",
+  "fs",
+  "node:fs",
+  "fs/promises",
+  "node:fs/promises",
+  "crypto",
+  "node:crypto",
+  "buffer",
+  "node:buffer",
+  "util",
+  "node:util",
+  "os",
+  "node:os"
+]);
+function createSandboxedRequire(scopedFs) {
+  const sandboxedRequire = /* @__PURE__ */ __name(((id) => {
+    if (!ALLOWED_MODULES.has(id)) {
+      const error = new Error(
+        `Module "${id}" is not allowed. Allowed: ${[...ALLOWED_MODULES].filter((m) => !m.startsWith("node:")).join(", ")}`
+      );
+      error.name = "ModuleNotAllowedError";
+      throw error;
+    }
+    if (id === "fs" || id === "node:fs") {
+      return scopedFs;
+    }
+    if (id === "fs/promises" || id === "node:fs/promises") {
+      return scopedFs.promises;
+    }
+    return baseRequire(id);
+  }), "sandboxedRequire");
+  sandboxedRequire.resolve = baseRequire.resolve;
+  sandboxedRequire.cache = baseRequire.cache;
+  sandboxedRequire.extensions = baseRequire.extensions;
+  sandboxedRequire.main = baseRequire.main;
+  return sandboxedRequire;
+}
+__name(createSandboxedRequire, "createSandboxedRequire");
+async function sandboxedImport(scopedFs, specifier) {
+  if (!ALLOWED_MODULES.has(specifier)) {
+    const error = new Error(
+      `Module "${specifier}" is not allowed. Allowed: ${[...ALLOWED_MODULES].filter((m) => !m.startsWith("node:")).join(", ")}`
+    );
+    error.name = "ModuleNotAllowedError";
+    throw error;
+  }
+  if (specifier === "fs" || specifier === "node:fs") {
+    return scopedFs;
+  }
+  if (specifier === "fs/promises" || specifier === "node:fs/promises") {
+    return scopedFs.promises;
+  }
+  return import(specifier);
+}
+__name(sandboxedImport, "sandboxedImport");
+async function execute(session, code, options = {}) {
+  const { cwd } = options;
+  const output = [];
+  const customConsole = {
+    log: /* @__PURE__ */ __name((...args) => {
+      output.push(args.map((arg) => formatValue(arg)).join(" "));
+    }, "log"),
+    error: /* @__PURE__ */ __name((...args) => {
+      output.push(`[ERROR] ${args.map((arg) => formatValue(arg)).join(" ")}`);
+    }, "error"),
+    warn: /* @__PURE__ */ __name((...args) => {
+      output.push(`[WARN] ${args.map((arg) => formatValue(arg)).join(" ")}`);
+    }, "warn"),
+    info: /* @__PURE__ */ __name((...args) => {
+      output.push(args.map((arg) => formatValue(arg)).join(" "));
+    }, "info")
+  };
+  const scopedFs = cwd ? new ScopedFS([cwd, "/tmp", os5.tmpdir()]) : new ScopedFS();
+  const sandboxedRequire = createSandboxedRequire(scopedFs);
+  const vmContextObj = {
+    // Framer API
+    framer: session.connection.framer,
+    state: session.state,
+    // Console
+    console: customConsole,
+    // Module system (sandboxed)
+    require: sandboxedRequire,
+    import: /* @__PURE__ */ __name((specifier) => sandboxedImport(scopedFs, specifier), "import"),
+    // Timers
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    // Fetch & network
+    fetch,
+    // Common globals
+    Buffer,
+    URL,
+    URLSearchParams,
+    TextEncoder,
+    TextDecoder,
+    crypto: crypto,
+    AbortController,
+    AbortSignal,
+    structuredClone
+  };
+  const vmContext = vm.createContext(vmContextObj);
+  const wrappedCode = `(async () => { ${code} })()`;
+  let timeoutId;
+  try {
+    const script = new vm.Script(wrappedCode, {
+      filename: "framer-exec.js"
+    });
+    const resultPromise = script.runInContext(vmContext, {
+      timeout: 5e3
+    });
+    const result = await Promise.race([
+      resultPromise,
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(
+          () => reject(
+            new Error(`Execution timed out after ${EXECUTION_TIMEOUT}ms`)
+          ),
+          EXECUTION_TIMEOUT
+        );
+      })
+    ]);
+    if (result !== void 0) {
+      output.push(formatValue(result));
+    }
+    return { output };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const retryable = isRetryableError(err);
+    if (retryable || isConnectionError(errorMessage)) {
+      session.connection.markDisconnected();
+    }
+    const errorRef = getErrorRef(err);
+    return {
+      output,
+      error: errorMessage,
+      ...errorRef ? { errorRef } : {},
+      ...retryable ? { retryable: true } : {}
+    };
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+__name(execute, "execute");
+function isReconnectable(err) {
+  return isRetryableError(err) || isConnectionError(err instanceof Error ? err.message : String(err));
+}
+__name(isReconnectable, "isReconnectable");
+function connectionFailureResult(prefix, err) {
+  const inner = err instanceof Error ? err.message : String(err);
+  const errorRef = getErrorRef(err);
+  return {
+    output: [],
+    error: `${prefix}: ${inner}`,
+    ...errorRef ? { errorRef } : {},
+    ...isRetryableError(err) ? { retryable: true } : {}
+  };
+}
+__name(connectionFailureResult, "connectionFailureResult");
+async function executeWithReconnect(session, code, options, execId) {
+  if (!session.connection.isConnected()) {
+    log(
+      `exec.reconnect exec=${execId} session=${session.id} reason="idle disconnected"`
+    );
+    try {
+      await session.connection.reconnect();
+    } catch (err) {
+      if (!isReconnectable(err)) {
+        return connectionFailureResult(
+          "Failed to get connection for session",
+          err
+        );
+      }
+      log(
+        `exec.reconnect.retry exec=${execId} session=${session.id} reason="${err instanceof Error ? err.message : String(err)}"`
+      );
+      try {
+        await session.connection.reconnect();
+      } catch (err2) {
+        return connectionFailureResult(
+          "Failed to get connection for session",
+          err2
+        );
+      }
+    }
+  }
+  const result = await execute(session, code, options);
+  if (!result.error || !(result.retryable || isConnectionError(result.error))) {
+    return result;
+  }
+  log(
+    `reconnect exec=${execId} session=${session.id} req=${session.connection.framer.requestId} reason="${result.error}"`
+  );
+  try {
+    await session.connection.reconnect();
+  } catch (err) {
+    log(
+      `reconnect.failed exec=${execId} session=${session.id} req=${session.connection.framer.requestId} error="${err instanceof Error ? err.message : String(err)}"`
+    );
+    return connectionFailureResult(
+      "Connection lost and failed to reconnect",
+      err
+    );
+  }
+  log(
+    `reconnect.success exec=${execId} session=${session.id} req=${session.connection.framer.requestId}`
+  );
+  return execute(session, code, options);
+}
+__name(executeWithReconnect, "executeWithReconnect");
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (typeof value === "function")
+    return `[Function: ${value.name || "anonymous"}]`;
+  if (value instanceof Error) return value.message;
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Map) return `Map(${value.size})`;
+  if (value instanceof Set) return `Set(${value.size})`;
+  if (Buffer.isBuffer(value)) return `Buffer(${value.length})`;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+__name(formatValue, "formatValue");
+var DEFAULT_FS_POLL_INTERVAL_MS = 1e3;
+var fsPollIntervalMs = DEFAULT_FS_POLL_INTERVAL_MS;
+var SettingsWatcher = class {
+  constructor(settingsPath) {
+    this.settingsPath = settingsPath;
+  }
+  settingsPath;
+  static {
+    __name(this, "SettingsWatcher");
+  }
+  start(callback) {
+    fs4.watchFile(
+      this.settingsPath,
+      { persistent: false, interval: fsPollIntervalMs },
+      (curr, prev) => {
+        if (
+          // File was modified
+          curr.mtimeMs !== prev.mtimeMs || // File was renamed and replaced by a new file with the same name
+          curr.ino !== prev.ino || // File changed without any of the above changing for some reason?
+          curr.size !== prev.size
+        ) {
+          callback();
+        }
+      }
+    );
+    return this;
+  }
+  stop() {
+    fs4.unwatchFile(this.settingsPath);
+    return this;
+  }
+};
+
+// src/config/settings.ts
+var DEFAULT_MACHINE_ID = "unknown-machine-id-this-should-never-be-persisted";
+var DEFAULT_SETTINGS = {
+  machineId: DEFAULT_MACHINE_ID,
+  telemetryEnabled: true,
+  telemetryNoticeShown: false
+};
+var SettingsFileSchema = z.object({
+  machineId: z.string().optional(),
+  telemetryEnabled: z.boolean().optional(),
+  telemetryNoticeShown: z.boolean().optional()
+});
+function getSettingsPath() {
+  return path5.join(getConfigDir(), "settings.json");
+}
+__name(getSettingsPath, "getSettingsPath");
+var settings;
+var settingsWatcher;
+function getSettings() {
+  if (settings) return settings;
+  settings = readSettingsFile();
+  if (!settingsWatcher) {
+    settingsWatcher = new SettingsWatcher(getSettingsPath()).start(() => {
+      settings = void 0;
+    });
+  }
+  return settings;
+}
+__name(getSettings, "getSettings");
+function readSettingsFile() {
+  const settingsPath = getSettingsPath();
+  try {
+    const raw = JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
+    const result = SettingsFileSchema.parse(raw);
+    return {
+      machineId: result.machineId ?? DEFAULT_SETTINGS.machineId,
+      telemetryEnabled: result.telemetryEnabled ?? DEFAULT_SETTINGS.telemetryEnabled,
+      telemetryNoticeShown: result.telemetryNoticeShown ?? DEFAULT_SETTINGS.telemetryNoticeShown
+    };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+__name(readSettingsFile, "readSettingsFile");
+function setSettings(newSettings) {
+  settings = newSettings;
+  writeSettingsFile(newSettings);
+}
+__name(setSettings, "setSettings");
+function writeSettingsFile(settings2) {
+  ensureConfigDir();
+  fs4.writeFileSync(getSettingsPath(), JSON.stringify(settings2, null, "	"), {
+    mode: 384
+  });
+}
+__name(writeSettingsFile, "writeSettingsFile");
+function getMachineId() {
+  const settings2 = getSettings();
+  if (settings2.machineId === DEFAULT_MACHINE_ID) {
+    const machineId = crypto.randomUUID();
+    setSettings({ ...settings2, machineId });
+  }
+  return getSettings().machineId;
+}
+__name(getMachineId, "getMachineId");
+function isTelemetryEnabled() {
+  return getSettings().telemetryEnabled;
+}
+__name(isTelemetryEnabled, "isTelemetryEnabled");
+var trackingEndpoint = "https://events.framer.com/track";
+var inProgressTrackings = /* @__PURE__ */ new Set();
+var cachedSharedFields;
+function getOsName(platform) {
+  switch (platform) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    case "linux":
+      return "linux";
+    default:
+      return "unknown";
+  }
+}
+__name(getOsName, "getOsName");
+function getMacOsVersion() {
+  try {
+    const version = execFileSync("/usr/bin/sw_vers", ["-productVersion"], {
+      encoding: "utf8",
+      timeout: 1e3
+    }).trim();
+    return version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+__name(getMacOsVersion, "getMacOsVersion");
+function getOsVersion(platform) {
+  if (platform === "darwin") return getMacOsVersion();
+  const version = os5.release().trim();
+  return version || "unknown";
+}
+__name(getOsVersion, "getOsVersion");
+function getOsMetadata() {
+  const platform = os5.platform();
+  const arch = os5.arch();
+  return {
+    arch: arch || "unknown",
+    osName: getOsName(platform),
+    osVersion: getOsVersion(platform)
+  };
+}
+__name(getOsMetadata, "getOsMetadata");
+function sharedFields() {
+  cachedSharedFields ??= {
+    machineId: getMachineId(),
+    cliVersion: VERSION,
+    ...getOsMetadata()
+  };
+  return cachedSharedFields;
+}
+__name(sharedFields, "sharedFields");
+function wrapEvent(event) {
+  return {
+    source: "framer-dalton",
+    timestamp: Date.now(),
+    type: "track",
+    uuid: randomUUID(),
+    data: event
+  };
+}
+__name(wrapEvent, "wrapEvent");
+function postEvent(createEvent) {
+  if (!isTelemetryEnabled()) return false;
+  if (process.env.NODE_ENV === "test" && true) return false;
+  const event = createEvent();
+  const body = JSON.stringify([wrapEvent(event)]);
+  debug("tracking", `sending ${event.event} to ${trackingEndpoint}: ${body}`);
+  const promise = fetch(trackingEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": `framer-dalton/${VERSION}`
+    },
+    body,
+    signal: AbortSignal.timeout(
+      5e3
+      /* 5 seconds */
+    )
+  }).then((response) => {
+    if (!response.ok) {
+      debug(
+        "tracking",
+        `failed to send ${event.event}: HTTP ${response.status}`
+      );
+    }
+  }).catch((error) => {
+    debug(
+      "tracking",
+      `failed to send ${event.event}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }).finally(() => {
+    inProgressTrackings.delete(promise);
+  });
+  inProgressTrackings.add(promise);
+  return true;
+}
+__name(postEvent, "postEvent");
+function waitForTrackingToFinish() {
+  return Promise.allSettled(Array.from(inProgressTrackings));
+}
+__name(waitForTrackingToFinish, "waitForTrackingToFinish");
+function trackRelayStart() {
+  postEvent(
+    () => ({
+      event: "local_agents_relay_start",
+      ...sharedFields()
+    })
+  );
+}
+__name(trackRelayStart, "trackRelayStart");
+var relayShutdownTracked = false;
+function trackRelayShutdown() {
+  if (relayShutdownTracked) return;
+  relayShutdownTracked = postEvent(
+    () => ({
+      event: "local_agents_relay_shutdown",
+      ...sharedFields()
+    })
+  );
+}
+__name(trackRelayShutdown, "trackRelayShutdown");
+function trackSessionCreate(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_session_create",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackSessionCreate, "trackSessionCreate");
+function trackSessionDestroy(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_session_destroy",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackSessionDestroy, "trackSessionDestroy");
+function trackExec(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_exec",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackExec, "trackExec");
+function trackConnectionAcquire(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_connection_acquire",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackConnectionAcquire, "trackConnectionAcquire");
+function trackConnectionReconnect(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_connection_reconnect",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackConnectionReconnect, "trackConnectionReconnect");
+function trackConnectionIdleDisconnect(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_connection_idle_disconnect",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackConnectionIdleDisconnect, "trackConnectionIdleDisconnect");
+function trackError(payload) {
+  postEvent(
+    () => ({
+      event: "local_agents_error",
+      ...sharedFields(),
+      ...payload
+    })
+  );
+}
+__name(trackError, "trackError");
+
+// src/session-manager.ts
+var SESSION_IDLE_TIMEOUT_MS = 60 * 1e3;
+var SESSION_IDLE_CHECK_INTERVAL_MS = 30 * 1e3;
+var MISSING_SERVER_SESSION_ID = "missing-session-id-should-not-happen";
+var Connection = class _Connection {
+  constructor(projectId, userId, apiKey, headlessServerUrl, framer) {
+    this.projectId = projectId;
+    this.userId = userId;
+    this.apiKey = apiKey;
+    this.headlessServerUrl = headlessServerUrl;
+    this.framer = framer;
+  }
+  projectId;
+  userId;
+  apiKey;
+  headlessServerUrl;
+  framer;
+  static {
+    __name(this, "Connection");
+  }
+  sessions = [];
+  status = "connected";
+  pendingReconnect;
+  static async open(projectId, userId, apiKey, headlessServerUrl) {
+    const framer = await connect(projectId, apiKey, {
+      clientId: `dalton/${VERSION}`,
+      serverUrl: headlessServerUrl
+    });
+    return new _Connection(projectId, userId, apiKey, headlessServerUrl, framer);
+  }
+  isConnected() {
+    return this.status === "connected";
+  }
+  markDisconnected() {
+    this.status = "disconnected";
+  }
+  getServerSessionId() {
+    return this.framer.sessionId ?? MISSING_SERVER_SESSION_ID;
+  }
+  listSessionInfo() {
+    return this.sessions.map((session) => ({
+      id: session.id,
+      projectId: this.projectId,
+      stateKeys: Object.keys(session.state),
+      headlessServerUrl: this.headlessServerUrl
+    }));
+  }
+  createSession(id, agentThreadContext) {
+    const session = {
+      id,
+      state: {},
+      agentThreadContext,
+      lastActivityAt: Date.now(),
+      inflight: 0,
+      connection: this
+    };
+    this.sessions.push(session);
+    return session;
+  }
+  findSession(id) {
+    return this.sessions.find((session) => session.id === id);
+  }
+  removeSession(id) {
+    const index = this.sessions.findIndex((session) => session.id === id);
+    if (index >= 0) {
+      this.sessions.splice(index, 1);
+    }
+  }
+  hasSessions() {
+    return this.sessions.length > 0;
+  }
+  clearSessions() {
+    this.sessions.length = 0;
+  }
+  isIdle(now, timeoutMs) {
+    return this.sessions.every(
+      (session) => session.inflight === 0 && now - session.lastActivityAt >= timeoutMs
+    );
+  }
+  async reconnect() {
+    if (this.status === "connected") {
+      return;
+    }
+    if (this.pendingReconnect) {
+      return this.pendingReconnect;
+    }
+    this.status = "reconnecting";
+    this.pendingReconnect = this.framer.reconnect().then(() => {
+      this.status = "connected";
+      trackConnectionReconnect({
+        projectId: this.projectId,
+        userId: this.userId,
+        sessionId: this.getServerSessionId()
+      });
+    }).catch((error) => {
+      this.status = "disconnected";
+      throw error;
+    }).finally(() => {
+      this.pendingReconnect = void 0;
+    });
+    return this.pendingReconnect;
+  }
+  async disconnect() {
+    if (this.pendingReconnect) {
+      try {
+        await this.pendingReconnect;
+      } catch {
+      }
+    }
+    if (this.status === "connected") {
+      await this.framer.disconnect();
+    }
+    this.status = "disconnected";
+    this.pendingReconnect = void 0;
+  }
+};
+var SessionManager = class {
+  static {
+    __name(this, "SessionManager");
+  }
+  connections = [];
+  idleCheck = null;
+  async create(projectId, userId, apiKey, headlessServerUrl, agentThreadContext = {}) {
+    const connection = await this.findOrCreateConnection(
+      projectId,
+      userId,
+      apiKey,
+      headlessServerUrl
+    );
+    const session = connection.createSession(
+      this.getNextSessionId(),
+      agentThreadContext
+    );
+    this.startIdleCheck();
+    return session;
+  }
+  list() {
+    return this.connections.flatMap(
+      (connection) => connection.listSessionInfo()
+    );
+  }
+  get(id) {
+    return this.findSession(id);
+  }
+  async execute(id, code, options, execId) {
+    var _stack = [];
+    try {
+      const session = this.findSession(id);
+      if (!session) {
+        return void 0;
+      }
+      log(
+        `exec exec=${execId} session=${id} req=${session.connection.framer.requestId} code=${JSON.stringify(code).slice(0, 100)}`
+      );
+      const start = performance.now();
+      const _guard = __using(_stack, this.startExecution(session));
+      const result = await executeWithReconnect(session, code, options, execId);
+      const durationMs = Math.round(performance.now() - start);
+      trackExec({
+        projectId: session.connection.projectId,
+        userId: session.connection.userId,
+        sessionId: session.connection.getServerSessionId(),
+        ...session.agentThreadContext,
+        durationMs,
+        hasError: result.error !== void 0,
+        ...result.error ? { errorMessage: result.error } : {}
+      });
+      if (result.error) {
+        log(
+          `exec.error exec=${execId} session=${id} req=${session.connection.framer.requestId} ${durationMs}ms error="${result.error}"`
+        );
+      } else {
+        log(
+          `exec.done exec=${execId} session=${id} req=${session.connection.framer.requestId} ${durationMs}ms`
+        );
+      }
+      return result;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  exec(session) {
+    return this.startExecution(session);
+  }
+  startExecution(session) {
+    session.inflight++;
+    return {
+      [Symbol.dispose]: () => {
+        session.inflight--;
+        session.lastActivityAt = Date.now();
+      }
+    };
+  }
+  async destroy(id) {
+    const session = this.findSession(id);
+    if (!session) {
+      return;
+    }
+    trackSessionDestroy({
+      projectId: session.connection.projectId,
+      userId: session.connection.userId,
+      sessionId: session.connection.getServerSessionId(),
+      ...session.agentThreadContext
+    });
+    session.connection.removeSession(id);
+    if (!session.connection.hasSessions()) {
+      await session.connection.disconnect();
+      const index = this.connections.indexOf(session.connection);
+      if (index >= 0) {
+        this.connections.splice(index, 1);
+      }
+    }
+    if (this.connections.length === 0) {
+      this.stopIdleCheck();
+    }
+  }
+  async destroyAll() {
+    const connections = [...this.connections];
+    this.connections = [];
+    this.stopIdleCheck();
+    for (const connection of connections) {
+      connection.clearSessions();
+      await connection.disconnect();
+    }
+  }
+  startIdleCheck() {
+    if (this.idleCheck) return;
+    this.idleCheck = setInterval(() => {
+      this.reapIdleConnections().catch((err) => {
+        log(`reap error: ${err instanceof Error ? err.message : err}`);
+      });
+    }, SESSION_IDLE_CHECK_INTERVAL_MS);
+    this.idleCheck.unref();
+  }
+  stopIdleCheck() {
+    if (this.idleCheck) {
+      clearInterval(this.idleCheck);
+      this.idleCheck = null;
+    }
+  }
+  async reapIdleConnections() {
+    const now = Date.now();
+    const disconnects = [];
+    for (const connection of this.connections) {
+      if (!connection.isConnected()) continue;
+      if (!connection.isIdle(now, SESSION_IDLE_TIMEOUT_MS)) continue;
+      log(
+        `idle disconnect project=${connection.projectId} req=${connection.framer.requestId}`
+      );
+      disconnects.push({
+        projectId: connection.projectId,
+        userId: connection.userId,
+        sessionId: connection.getServerSessionId(),
+        disconnectPromise: connection.disconnect()
+      });
+    }
+    const results = await Promise.allSettled(
+      disconnects.map((d) => d.disconnectPromise)
+    );
+    for (const [index, result] of results.entries()) {
+      const { projectId, sessionId, userId } = disconnects[index];
+      if (result.status === "fulfilled") {
+        trackConnectionIdleDisconnect({ projectId, sessionId, userId });
+        continue;
+      }
+      if (result.status === "rejected") {
+        const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        log(`disconnect error: ${errorMessage}`);
+        trackError({
+          errorType: "connection_idle_disconnect_error",
+          projectId,
+          sessionId,
+          userId,
+          errorMessage
+        });
+      }
+    }
+  }
+  findConnection(projectId, apiKey, headlessServerUrl) {
+    return this.connections.find(
+      (connection) => connection.projectId === projectId && connection.apiKey === apiKey && connection.headlessServerUrl === headlessServerUrl
+    );
+  }
+  async findOrCreateConnection(projectId, userId, apiKey, headlessServerUrl) {
+    const existingConnection = this.findConnection(
+      projectId,
+      apiKey,
+      headlessServerUrl
+    );
+    if (existingConnection) {
+      await existingConnection.reconnect();
+      trackConnectionAcquire({
+        projectId,
+        userId: existingConnection.userId,
+        sessionId: existingConnection.getServerSessionId(),
+        isReuse: true
+      });
+      return existingConnection;
+    }
+    const connection = await Connection.open(
+      projectId,
+      userId,
+      apiKey,
+      headlessServerUrl
+    );
+    trackConnectionAcquire({
+      projectId,
+      userId: connection.userId,
+      sessionId: connection.getServerSessionId(),
+      isReuse: false
+    });
+    this.connections.push(connection);
+    return connection;
+  }
+  findSession(id) {
+    for (const connection of this.connections) {
+      const session = connection.findSession(id);
+      if (session) return session;
+    }
+    return void 0;
+  }
+  getNextSessionId() {
+    let id = 1;
+    while (this.findSession(String(id))) {
+      id++;
+    }
+    return String(id);
+  }
+};
+var sessionManager = new SessionManager();
+
+// src/router.ts
+var t = initTRPC.create({
+  errorFormatter({ shape, error }) {
+    const cause = error.cause;
+    if (cause instanceof FramerAPIError) {
+      const framerApi = { code: cause.code };
+      if (cause.ref !== void 0) framerApi.ref = cause.ref;
+      return { ...shape, data: { ...shape.data, framerApi } };
+    }
+    return shape;
+  }
+});
+var nextExecId = 0;
+var appRouter = t.router({
+  version: t.procedure.query(() => {
+    return { version: VERSION };
+  }),
+  listSessions: t.procedure.query(() => {
+    return sessionManager.list();
+  }),
+  createSession: t.procedure.input(
+    z.object({
+      projectId: z.string(),
+      apiKey: z.string(),
+      userId: z.string().optional(),
+      headlessServerUrl: z.string(),
+      agentThreadId: z.string().optional(),
+      agentProvider: z.string().optional()
+    })
+  ).mutation(async ({ input }) => {
+    const start = performance.now();
+    const agentThreadContext = normalizeAgentThreadContext(input);
+    try {
+      const session = await sessionManager.create(
+        input.projectId,
+        input.userId,
+        input.apiKey,
+        input.headlessServerUrl,
+        agentThreadContext
+      );
+      log(
+        `session.new id=${session.id} project=${input.projectId} headlessServerUrl=${input.headlessServerUrl}`
+      );
+      trackSessionCreate({
+        projectId: input.projectId,
+        userId: session.connection.userId,
+        sessionId: session.connection.getServerSessionId(),
+        ...session.agentThreadContext,
+        durationMs: Math.round(performance.now() - start)
+      });
+      return { id: session.id };
+    } catch (err) {
+      const message = formatError(err);
+      trackError({
+        errorType: "session_create_error",
+        projectId: input.projectId,
+        userId: input.userId,
+        ...agentThreadContext,
+        errorMessage: message
+      });
+      throw new TRPCError({
+        code: isAuthError(message) ? "UNAUTHORIZED" : "INTERNAL_SERVER_ERROR",
+        message,
+        cause: err
+      });
+    }
+  }),
+  destroySession: t.procedure.input(z.object({ sessionId: z.string() })).mutation(async ({ input }) => {
+    await sessionManager.destroy(input.sessionId);
+    log(`session.destroy id=${input.sessionId}`);
+  }),
+  exec: t.procedure.input(
+    z.object({
+      sessionId: z.string(),
+      code: z.string(),
+      cwd: z.string().optional()
+    })
+  ).mutation(async ({ input }) => {
+    const { sessionId, code, cwd } = input;
+    const execId = nextExecId++;
+    const result = await sessionManager.execute(
+      sessionId,
+      code,
+      { cwd },
+      execId
+    );
+    if (!result) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: `Session ${sessionId} is invalid or has expired`
+      });
+    }
+    return result;
+  }),
+  shutdown: t.procedure.mutation(() => {
+    log("shutdown requested");
+    trackRelayShutdown();
+    setTimeout(() => {
+      waitForTrackingToFinish().finally(() => {
+        process.exit(0);
+      });
+    }, 100);
+  })
+});
+
+// src/relay-server.ts
+var IDLE_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+var IDLE_CHECK_INTERVAL_MS = 60 * 1e3;
+var trpcHandler = createHTTPHandler({ router: appRouter });
+function getHostHeader(req) {
+  const host = req.headers.host;
+  if (typeof host === "string") {
+    return host;
+  }
+  return null;
+}
+__name(getHostHeader, "getHostHeader");
+function isAllowedHost(hostHeader, listeningPort) {
+  if (!hostHeader || listeningPort === null) {
+    return false;
+  }
+  const normalizedHost = hostHeader.trim().toLowerCase();
+  return normalizedHost === `127.0.0.1:${listeningPort}`;
+}
+__name(isAllowedHost, "isAllowedHost");
+function getAuthorizationHeader(req) {
+  const header = req.headers.authorization;
+  if (typeof header === "string") {
+    return header;
+  }
+  return null;
+}
+__name(getAuthorizationHeader, "getAuthorizationHeader");
+function isAuthorized(authorizationHeader, expectedToken) {
+  if (!authorizationHeader) {
+    return false;
+  }
+  const match = /^Bearer\s+(.+)$/i.exec(authorizationHeader.trim());
+  if (!match) {
+    return false;
+  }
+  const providedToken = match[1] ?? "";
+  const expectedBuffer = Buffer.from(expectedToken);
+  const providedBuffer = Buffer.from(providedToken);
+  if (expectedBuffer.length !== providedBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(expectedBuffer, providedBuffer);
+}
+__name(isAuthorized, "isAuthorized");
+function getListeningPort(server) {
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    return null;
+  }
+  return address.port;
+}
+__name(getListeningPort, "getListeningPort");
+async function startRelayServer(port = RELAY_PORT) {
+  let lastActivityAt = Date.now();
+  const relayToken = generateRelayToken();
+  const server = http.createServer((req, res) => {
+    const listeningPort = getListeningPort(server);
+    if (!isAllowedHost(getHostHeader(req), listeningPort)) {
+      res.writeHead(403).end("Forbidden");
+      return;
+    }
+    if (!isAuthorized(getAuthorizationHeader(req), relayToken)) {
+      res.writeHead(401).end("Unauthorized");
+      return;
+    }
+    lastActivityAt = Date.now();
+    trpcHandler(req, res);
+  });
+  server.on("close", () => {
+    clearRelayToken(relayToken);
+  });
+  const idleCheck = setInterval(() => {
+    const idleMs = Date.now() - lastActivityAt;
+    if (idleMs >= IDLE_TIMEOUT_MS) {
+      log(`idle for ${Math.round(idleMs / 1e3)}s, shutting down`);
+      clearInterval(idleCheck);
+      server.close();
+      trackRelayShutdown();
+      waitForTrackingToFinish().finally(() => {
+        process.exit(0);
+      });
+    }
+  }, IDLE_CHECK_INTERVAL_MS);
+  idleCheck.unref();
+  return new Promise((resolve, reject) => {
+    server.on("error", (error) => {
+      clearRelayToken(relayToken);
+      reject(error);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      writeRelayToken(relayToken);
+      const listeningPort = getListeningPort(server) ?? port;
+      log(`started v${VERSION} on port ${listeningPort}`);
+      resolve(server);
+    });
+  });
+}
+__name(startRelayServer, "startRelayServer");
+
+// src/start-relay-server.ts
+process.title = "framer-relay-server";
+process.on("uncaughtException", (err) => {
+  log(`uncaught exception: ${err.message}`);
+  console.error("Uncaught Exception:", err);
+  trackError({
+    errorType: "relay_uncaught_exception",
+    errorMessage: err.message
+  });
+  waitForTrackingToFinish().finally(() => {
+    process.exit(1);
+  });
+});
+process.on("unhandledRejection", (reason) => {
+  log(`unhandled rejection: ${reason}`);
+  console.error("Unhandled Rejection:", reason);
+  trackError({
+    errorType: "relay_unhandled_rejection",
+    errorMessage: reason instanceof Error ? reason.message : String(reason)
+  });
+  waitForTrackingToFinish().finally(() => {
+    process.exit(1);
+  });
+});
+async function main() {
+  const server = await startRelayServer(RELAY_PORT);
+  console.log(`Framer relay server v${VERSION} running on port ${RELAY_PORT}`);
+  trackRelayStart();
+  process.on("SIGINT", () => {
+    log("shutdown SIGINT");
+    console.log("\nShutting down...");
+    server.close();
+    trackRelayShutdown();
+    waitForTrackingToFinish().finally(() => {
+      process.exit(0);
+    });
+  });
+  process.on("SIGTERM", () => {
+    log("shutdown SIGTERM");
+    console.log("\nShutting down...");
+    server.close();
+    trackRelayShutdown();
+    waitForTrackingToFinish().finally(() => {
+      process.exit(0);
+    });
+  });
+}
+__name(main, "main");
+main().catch((err) => {
+  log(`startup failed: ${err.message}`);
+  console.error("Failed to start relay server:", err);
+  trackError({
+    errorType: "relay_startup_error",
+    errorMessage: err.message
+  });
+  waitForTrackingToFinish().finally(() => {
+    process.exit(1);
+  });
+});