framer-dalton 0.0.18 → 0.0.21

package/dist/start-relay-server.js

@@ -8,14 +8,14 @@ import http from 'http';
 import { createHTTPHandler } from '@trpc/server/adapters/standalone';
 import { initTRPC, TRPCError } from '@trpc/server';
 import { z } from 'zod';
-import crypto from 'crypto';
+import { connect } from 'framer-api';
+import crypto, { randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import * as vm from 'vm';
-import { connect } from 'framer-api';
 
-/* @framer/ai relay server v0.0.18 */
+/* @framer/ai relay server v0.0.21 */
 var __defProp = Object.defineProperty;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name2);
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
@@ -57,6 +57,20 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
+
+// package.json
+var name = "framer-dalton";
+
+// 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);
+}
 function getLogPath() {
   if (process.env.XDG_STATE_HOME) {
     return path.join(process.env.XDG_STATE_HOME, "framer", "relay.log");
@@ -76,9 +90,7 @@ var initialized = false;
 function ensureLogDir() {
   if (initialized) return;
   const dir = path.dirname(logPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
+  fs2.mkdirSync(dir, { recursive: true });
   initialized = true;
 }
 __name(ensureLogDir, "ensureLogDir");
@@ -89,11 +101,15 @@ function log(message) {
 `);
 }
 __name(log, "log");
+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.18" 
+  "0.0.21" 
 );
 
 // src/relay-client.ts
@@ -381,7 +397,7 @@ async function sandboxedImport(scopedFs, specifier) {
   return import(specifier);
 }
 __name(sandboxedImport, "sandboxedImport");
-async function execute(session, framer, code, options = {}) {
+async function execute(session, code, options = {}) {
   const { cwd } = options;
   const output = [];
   const customConsole = {
@@ -402,7 +418,7 @@ async function execute(session, framer, code, options = {}) {
   const sandboxedRequire = createSandboxedRequire(scopedFs);
   const vmContextObj = {
     // Framer API
-    framer,
+    framer: session.connection.framer,
     state: session.state,
     // Console
     console: customConsole,
@@ -454,6 +470,9 @@ async function execute(session, framer, code, options = {}) {
     return { output };
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
+    if (isConnectionError(errorMessage)) {
+      session.connection.markDisconnected();
+    }
     return {
       output,
       error: errorMessage
@@ -463,36 +482,44 @@ async function execute(session, framer, code, options = {}) {
   }
 }
 __name(execute, "execute");
-async function executeWithReconnect(session, framer, code, options, reconnect, execId) {
-  const result = await tryExecute(session, framer, code, options);
+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 {
+      return {
+        output: [],
+        error: "Failed to get connection for session"
+      };
+    }
+  }
+  const result = await execute(session, code, options);
   if (!result.error || !isConnectionError(result.error)) {
     return result;
   }
-  const reqId = framer.requestId;
-  const tag = `exec=${execId} session=${session.id}${reqId ? ` req=${reqId}` : ""}`;
-  log(`reconnect ${tag} project=${session.projectId} reason="${result.error}"`);
-  const newFramer = await reconnect();
-  if (!newFramer) {
-    log(`reconnect.failed ${tag} error="no connection returned"`);
+  log(
+    `reconnect exec=${execId} session=${session.id} req=${session.connection.framer.requestId} reason="${result.error}"`
+  );
+  try {
+    await session.connection.reconnect();
+  } catch {
+    log(
+      `reconnect.failed exec=${execId} session=${session.id} req=${session.connection.framer.requestId} error="reconnect failed"`
+    );
     return {
       output: [],
       error: "Connection lost and failed to reconnect"
     };
   }
-  const newReqId = newFramer.requestId;
-  log(`reconnect.success ${tag}${newReqId ? ` new_req=${newReqId}` : ""}`);
-  return tryExecute(session, newFramer, code, options);
+  log(
+    `reconnect.success exec=${execId} session=${session.id} req=${session.connection.framer.requestId}`
+  );
+  return execute(session, code, options);
 }
 __name(executeWithReconnect, "executeWithReconnect");
-async function tryExecute(session, framer, code, options) {
-  try {
-    return await execute(session, framer, code, options);
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    return { output: [], error };
-  }
-}
-__name(tryExecute, "tryExecute");
 function formatValue(value) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
@@ -513,191 +540,477 @@ function formatValue(value) {
   }
 }
 __name(formatValue, "formatValue");
-var ConnectionPool = class {
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, "framer");
+  }
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || os.homedir(), "framer");
+  }
+  return path.join(os.homedir(), ".config", "framer");
+}
+__name(getConfigDir, "getConfigDir");
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  fs2.mkdirSync(configDir, { recursive: true, mode: 448 });
+}
+__name(ensureConfigDir, "ensureConfigDir");
+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, "ConnectionPool");
-  }
-  pool = /* @__PURE__ */ new Map();
-  reconnectPromises = /* @__PURE__ */ new Map();
-  /**
-   * Acquire a connection for a session.
-   * If a connection already exists for the project, the session is added to it.
-   * Otherwise, a new connection is created.
-   */
-  async acquire(projectId, apiKey, session) {
-    const entry = this.pool.get(projectId);
-    if (entry) {
-      entry.sessions.add(session);
-      if (!entry.connected) {
-        await entry.connection.reconnect();
-        entry.connected = true;
+    __name(this, "SettingsWatcher");
+  }
+  start(callback) {
+    fs2.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 entry.connection;
-    }
-    const connection = await connect(projectId, apiKey, {
-      clientId: `dalton/${VERSION}`
-    });
-    this.pool.set(projectId, {
-      connection,
-      sessions: /* @__PURE__ */ new Set([session]),
-      connected: true
+    );
+    return this;
+  }
+  stop() {
+    fs2.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 path.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 connection;
   }
-  /**
-   * Get the connection for a project.
-   */
-  getConnection(projectId) {
-    const entry = this.pool.get(projectId);
-    return entry?.connection ?? null;
-  }
-  /**
-   * Reconnect a project's connection (call after catching a connection error).
-   * Concurrent callers for the same project share a single reconnect attempt.
-   */
-  async reconnect(projectId) {
-    const existingPromise = this.reconnectPromises.get(projectId);
-    if (existingPromise) return existingPromise;
-    const promise = this.doReconnect(projectId).finally(() => {
-      this.reconnectPromises.delete(projectId);
+  return settings;
+}
+__name(getSettings, "getSettings");
+function readSettingsFile() {
+  const settingsPath = getSettingsPath();
+  try {
+    const raw = JSON.parse(fs2.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();
+  fs2.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();
+function sharedFields() {
+  return {
+    machineId: getMachineId(),
+    cliVersion: VERSION
+  };
+}
+__name(sharedFields, "sharedFields");
+function wrapEvent(event) {
+  return {
+    source: "framer-dalton",
+    timestamp: Date.now(),
+    type: "track",
+    uuid: randomUUID(),
+    data: event
+  };
+}
+__name(wrapEvent, "wrapEvent");
+function postEvent(event) {
+  if (!isTelemetryEnabled()) return false;
+  if (process.env.NODE_ENV === "test" && true) return false;
+  const promise = fetch(trackingEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": `framer-dalton/${VERSION}`
+    },
+    body: JSON.stringify([wrapEvent(event)]),
+    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
     });
-    this.reconnectPromises.set(projectId, promise);
-    return promise;
+    return new _Connection(projectId, userId, apiKey, headlessServerUrl, framer);
   }
-  async doReconnect(projectId) {
-    const entry = this.pool.get(projectId);
-    if (!entry) return null;
-    try {
-      await entry.connection.reconnect();
-      entry.connected = true;
-      return entry.connection;
-    } catch {
-      return null;
+  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) {
+    const session = {
+      id,
+      state: {},
+      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);
     }
   }
-  /**
-   * Disconnect a project's connection without removing sessions.
-   * The next exec will trigger a reconnect via executeWithReconnect.
-   */
-  async disconnect(projectId) {
-    const entry = this.pool.get(projectId);
-    if (!entry || !entry.connected) return;
-    entry.connected = false;
-    await entry.connection.disconnect();
-  }
-  isConnected(projectId) {
-    const entry = this.pool.get(projectId);
-    return entry?.connected ?? false;
-  }
-  /**
-   * Release a session from a connection.
-   * If no sessions remain, the connection is disconnected and removed.
-   */
-  async release(projectId, session) {
-    const entry = this.pool.get(projectId);
-    if (!entry) {
+  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;
     }
-    entry.sessions.delete(session);
-    if (entry.sessions.size === 0) {
-      await entry.connection.disconnect();
-      this.pool.delete(projectId);
+    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;
   }
-  /**
-   * Release all connections (for cleanup).
-   */
-  async releaseAll() {
-    for (const [projectId, entry] of this.pool) {
-      await entry.connection.disconnect();
-      this.pool.delete(projectId);
+  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 connectionPool = new ConnectionPool();
-
-// src/session-manager.ts
-var SESSION_IDLE_TIMEOUT_MS = 60 * 1e3;
-var SESSION_IDLE_CHECK_INTERVAL_MS = 30 * 1e3;
 var SessionManager = class {
   static {
     __name(this, "SessionManager");
   }
-  sessions = /* @__PURE__ */ new Map();
+  connections = [];
   idleCheck = null;
-  async create(projectId, apiKey) {
-    let id = 1;
-    while (this.sessions.has(String(id))) {
-      id++;
-    }
-    const session = {
-      id: String(id),
+  async create(projectId, userId, apiKey, headlessServerUrl) {
+    const connection = await this.findOrCreateConnection(
       projectId,
+      userId,
       apiKey,
-      state: {},
-      lastActivityAt: 0,
-      inflight: 0
-    };
+      headlessServerUrl
+    );
+    const session = connection.createSession(this.getNextSessionId());
     this.startIdleCheck();
-    await connectionPool.acquire(projectId, apiKey, session);
-    session.lastActivityAt = Date.now();
-    this.sessions.set(String(id), session);
-    return String(id);
+    return session;
   }
   list() {
-    return Array.from(this.sessions.values()).map((session) => ({
-      id: session.id,
-      projectId: session.projectId,
-      stateKeys: Object.keys(session.state)
-    }));
+    return this.connections.flatMap(
+      (connection) => connection.listSessionInfo()
+    );
   }
   get(id) {
-    return this.sessions.get(id);
+    return this.findSession(id);
   }
-  getFramer(session) {
-    return connectionPool.getConnection(session.projectId);
-  }
-  isConnected(session) {
-    return connectionPool.isConnected(session.projectId);
+  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(),
+        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);
+    }
   }
-  async reconnect(session) {
-    return connectionPool.reconnect(session.projectId);
+  exec(session) {
+    return this.startExecution(session);
   }
-  /** Marks session as actively executing. Dispose to release. */
-  exec(id) {
-    const session = this.sessions.get(id);
-    if (session) {
-      session.inflight++;
-    }
+  startExecution(session) {
+    session.inflight++;
     return {
       [Symbol.dispose]: () => {
-        if (session) {
-          session.inflight--;
-          session.lastActivityAt = Date.now();
-        }
+        session.inflight--;
+        session.lastActivityAt = Date.now();
       }
     };
   }
   async destroy(id) {
-    const session = this.sessions.get(id);
+    const session = this.findSession(id);
     if (!session) {
       return;
     }
-    await connectionPool.release(session.projectId, session);
-    this.sessions.delete(id);
-    if (this.sessions.size === 0) {
+    trackSessionDestroy({
+      projectId: session.connection.projectId,
+      userId: session.connection.userId,
+      sessionId: session.connection.getServerSessionId()
+    });
+    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() {
-    for (const id of this.sessions.keys()) {
-      await this.destroy(id);
+    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.reapIdleSessions().catch((err) => {
+      this.reapIdleConnections().catch((err) => {
         log(`reap error: ${err instanceof Error ? err.message : err}`);
       });
     }, SESSION_IDLE_CHECK_INTERVAL_MS);
@@ -709,36 +1022,94 @@ var SessionManager = class {
       this.idleCheck = null;
     }
   }
-  async reapIdleSessions() {
+  async reapIdleConnections() {
     const now = Date.now();
-    const projectSessions = /* @__PURE__ */ new Map();
-    for (const session of this.sessions.values()) {
-      const existing = projectSessions.get(session.projectId);
-      if (existing) existing.push(session);
-      else projectSessions.set(session.projectId, [session]);
-    }
     const disconnects = [];
-    for (const [projectId, sessions] of projectSessions) {
-      if (!connectionPool.isConnected(projectId)) continue;
-      const allIdle = sessions.every(
-        (s) => s.inflight === 0 && now - s.lastActivityAt >= SESSION_IDLE_TIMEOUT_MS
-      );
-      if (!allIdle) continue;
-      const reqId = connectionPool.getConnection(projectId)?.requestId;
+    for (const connection of this.connections) {
+      if (!connection.isConnected()) continue;
+      if (!connection.isIdle(now, SESSION_IDLE_TIMEOUT_MS)) continue;
       log(
-        `idle disconnect project=${projectId}${reqId ? ` req=${reqId}` : ""}`
+        `idle disconnect project=${connection.projectId} req=${connection.framer.requestId}`
       );
-      disconnects.push(connectionPool.disconnect(projectId));
+      disconnects.push({
+        projectId: connection.projectId,
+        userId: connection.userId,
+        sessionId: connection.getServerSessionId(),
+        disconnectPromise: connection.disconnect()
+      });
     }
-    const results = await Promise.allSettled(disconnects);
-    for (const result of results) {
+    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") {
-        log(
-          `disconnect error: ${result.reason instanceof Error ? result.reason.message : result.reason}`
-        );
+        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();
 
@@ -752,13 +1123,40 @@ var appRouter = t.router({
   listSessions: t.procedure.query(() => {
     return sessionManager.list();
   }),
-  createSession: t.procedure.input(z.object({ projectId: z.string(), apiKey: z.string() })).mutation(async ({ input }) => {
+  createSession: t.procedure.input(
+    z.object({
+      projectId: z.string(),
+      apiKey: z.string(),
+      userId: z.string().optional(),
+      headlessServerUrl: z.string()
+    })
+  ).mutation(async ({ input }) => {
+    const start = performance.now();
     try {
-      const id = await sessionManager.create(input.projectId, input.apiKey);
-      log(`session.new id=${id} project=${input.projectId}`);
-      return { id };
+      const session = await sessionManager.create(
+        input.projectId,
+        input.userId,
+        input.apiKey,
+        input.headlessServerUrl
+      );
+      log(
+        `session.new id=${session.id} project=${input.projectId} headlessServerUrl=${input.headlessServerUrl}`
+      );
+      trackSessionCreate({
+        projectId: input.projectId,
+        userId: session.connection.userId,
+        sessionId: session.connection.getServerSessionId(),
+        durationMs: Math.round(performance.now() - start)
+      });
+      return { id: session.id };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      trackError({
+        errorType: "session_create_error",
+        projectId: input.projectId,
+        userId: input.userId,
+        errorMessage: message
+      });
       throw new TRPCError({
         code: isAuthError(message) ? "UNAUTHORIZED" : "INTERNAL_SERVER_ERROR",
         message
@@ -776,61 +1174,29 @@ var appRouter = t.router({
       cwd: z.string().optional()
     })
   ).mutation(async ({ input }) => {
-    var _stack = [];
-    try {
-      const { sessionId, code, cwd } = input;
-      const session = sessionManager.get(sessionId);
-      if (!session) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: `Session ${sessionId} not found`
-        });
-      }
-      const _guard = __using(_stack, sessionManager.exec(sessionId));
-      const execId = nextExecId++;
-      let framer = sessionManager.getFramer(session);
-      if (framer && !sessionManager.isConnected(session)) {
-        log(
-          `exec.reconnect exec=${execId} session=${sessionId} reason="idle disconnected"`
-        );
-        framer = await sessionManager.reconnect(session);
-      }
-      const reqId = framer?.requestId;
-      const tag = `exec=${execId} session=${sessionId}${reqId ? ` req=${reqId}` : ""}`;
-      log(`exec ${tag} code=${JSON.stringify(code).slice(0, 100)}`);
-      if (!framer) {
-        log(`exec.error ${tag} error="no connection"`);
-        return {
-          output: [],
-          error: "Failed to get connection for session"
-        };
-      }
-      const start = performance.now();
-      const result = await executeWithReconnect(
-        session,
-        framer,
-        code,
-        { cwd },
-        () => sessionManager.reconnect(session),
-        execId
-      );
-      const elapsed = (performance.now() - start).toFixed(0);
-      if (result.error) {
-        log(`exec.error ${tag} ${elapsed}ms error="${result.error}"`);
-      } else {
-        log(`exec.done ${tag} ${elapsed}ms`);
-      }
-      return result;
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
+    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(() => {
-      process.exit(0);
+      waitForTrackingToFinish().finally(() => {
+        process.exit(0);
+      });
     }, 100);
   })
 });
@@ -851,7 +1217,10 @@ async function startRelayServer(port = RELAY_PORT) {
       log(`idle for ${Math.round(idleMs / 1e3)}s, shutting down`);
       clearInterval(idleCheck);
       server.close();
-      process.exit(0);
+      trackRelayShutdown();
+      waitForTrackingToFinish().finally(() => {
+        process.exit(0);
+      });
     }
   }, IDLE_CHECK_INTERVAL_MS);
   idleCheck.unref();
@@ -870,32 +1239,57 @@ process.title = "framer-relay-server";
 process.on("uncaughtException", (err) => {
   log(`uncaught exception: ${err.message}`);
   console.error("Uncaught Exception:", err);
-  process.exit(1);
+  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);
-  process.exit(1);
+  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();
-    process.exit(0);
+    trackRelayShutdown();
+    waitForTrackingToFinish().finally(() => {
+      process.exit(0);
+    });
   });
   process.on("SIGTERM", () => {
     log("shutdown SIGTERM");
     console.log("\nShutting down...");
     server.close();
-    process.exit(0);
+    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);
-  process.exit(1);
+  trackError({
+    errorType: "relay_startup_error",
+    errorMessage: err.message
+  });
+  waitForTrackingToFinish().finally(() => {
+    process.exit(1);
+  });
 });