@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-GCNWCYJI.js

@@ -0,0 +1,249 @@
+// src/gateway/crm-bridge.ts
+var config = null;
+var disabledLogged = false;
+function initCRMBridge() {
+  const apiToken = process.env.CRM_API_TOKEN;
+  if (!apiToken) {
+    if (!disabledLogged) {
+      console.log("[crm-bridge] Disabled \u2014 CRM_API_TOKEN not set");
+      disabledLogged = true;
+    }
+    config = null;
+    return false;
+  }
+  const graphqlUrl = process.env.CRM_GRAPHQL_URL || "http://localhost:3000";
+  config = { graphqlUrl, apiToken };
+  console.log(`[crm-bridge] Enabled \u2014 pushing to ${graphqlUrl}`);
+  return true;
+}
+function isCRMBridgeEnabled() {
+  return config !== null;
+}
+async function gqlRequest(query, variables) {
+  const res = await fetch(`${config.graphqlUrl}/api`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiToken}`
+    },
+    body: JSON.stringify({ query, variables }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) {
+    throw new Error(`CRM GraphQL request failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function findPersonByContact(platform, senderId) {
+  const isEmail = platform === "email";
+  const query = isEmail ? `query FindPerson($value: String!) {
+        people(filter: { emails: { primaryEmail: { eq: $value } } }, first: 1) {
+          edges { node { id } }
+        }
+      }` : `query FindPerson($value: String!) {
+        people(filter: { phones: { primaryPhoneNumber: { eq: $value } } }, first: 1) {
+          edges { node { id } }
+        }
+      }`;
+  const res = await gqlRequest(query, { value: senderId });
+  if (res.errors && res.errors.length > 0) {
+    console.error("[crm-bridge] findPerson error:", res.errors[0].message);
+    return null;
+  }
+  const edges = res.data?.people?.edges;
+  return edges && edges.length > 0 ? edges[0].node.id : null;
+}
+async function createPerson(platform, senderId, senderName) {
+  const firstName = senderName?.split(" ")[0] || "";
+  const lastName = senderName?.split(" ").slice(1).join(" ") || "";
+  const isEmail = platform === "email";
+  const input = {
+    name: { firstName, lastName }
+  };
+  if (isEmail) {
+    input.emails = { primaryEmail: senderId, additionalEmails: [] };
+  } else {
+    input.phones = {
+      primaryPhoneNumber: senderId,
+      primaryPhoneCountryCode: "",
+      primaryPhoneCallingCode: "",
+      additionalPhones: []
+    };
+  }
+  const query = `
+    mutation CreatePerson($input: PersonCreateInput!) {
+      createPerson(data: $input) {
+        id
+      }
+    }
+  `;
+  const res = await gqlRequest(query, {
+    input
+  });
+  if (res.errors && res.errors.length > 0) {
+    console.error("[crm-bridge] createPerson error:", res.errors[0].message);
+    return null;
+  }
+  return res.data?.createPerson?.id ?? null;
+}
+async function createTimelineActivity(personId, params) {
+  const channelLabel = params.platform.charAt(0).toUpperCase() + params.platform.slice(1);
+  const label = params.direction === "inbound" ? "message from" : "conversation with";
+  const input = {
+    name: `${channelLabel} ${label} ${params.senderName || params.senderId}`,
+    happensAt: params.timestamp,
+    properties: {
+      channel: params.platform,
+      senderId: params.senderId,
+      senderName: params.senderName || null,
+      messageText: params.messageText,
+      agentResponse: params.agentResponse || null,
+      agentName: params.agentName || null,
+      threadId: `${params.platform}:${params.senderId}`,
+      direction: params.direction,
+      accountId: params.accountId || null
+    },
+    targetPersonId: personId
+  };
+  const query = `
+    mutation CreateTimelineActivity($input: TimelineActivityCreateInput!) {
+      createTimelineActivity(data: $input) {
+        id
+      }
+    }
+  `;
+  const res = await gqlRequest(
+    query,
+    { input }
+  );
+  if (res.errors && res.errors.length > 0) {
+    console.error(
+      "[crm-bridge] createTimelineActivity error:",
+      res.errors[0].message
+    );
+    return false;
+  }
+  return true;
+}
+async function pushConversationToCRM(params) {
+  if (!config) return;
+  try {
+    let personId = await findPersonByContact(params.platform, params.senderId);
+    if (!personId) {
+      personId = await createPerson(
+        params.platform,
+        params.senderId,
+        params.senderName
+      );
+    }
+    if (!personId) {
+      console.error("[crm-bridge] Failed to find or create person for", params.senderId);
+      return;
+    }
+    const ok = await createTimelineActivity(personId, {
+      ...params,
+      direction: "conversation"
+    });
+    if (ok) {
+      console.log(
+        `[crm-bridge] Pushed ${params.platform}/${params.senderId} \u2192 person ${personId}`
+      );
+    }
+  } catch (err) {
+    console.error("[crm-bridge] Push failed:", err instanceof Error ? err.message : err);
+  }
+}
+async function pushInboundMessageToCRM(params) {
+  if (!config) return;
+  try {
+    let personId = await findPersonByContact(params.platform, params.senderId);
+    if (!personId) {
+      personId = await createPerson(
+        params.platform,
+        params.senderId,
+        params.senderName
+      );
+    }
+    if (!personId) {
+      console.error("[crm-bridge] Failed to find or create person for", params.senderId);
+      return;
+    }
+    const ok = await createTimelineActivity(personId, {
+      ...params,
+      direction: "inbound"
+    });
+    if (ok) {
+      console.log(
+        `[crm-bridge] Inbound ${params.platform}/${params.senderId} \u2192 person ${personId}`
+      );
+    }
+  } catch (err) {
+    console.error("[crm-bridge] Inbound push failed:", err instanceof Error ? err.message : err);
+  }
+}
+async function pushGatewayEventToCRM(params) {
+  if (!config) return;
+  try {
+    let personId = await findPersonByContact(params.platform, params.senderId);
+    if (!personId) {
+      personId = await createPerson(
+        params.platform,
+        params.senderId,
+        params.senderName
+      );
+    }
+    if (!personId) {
+      console.error("[crm-bridge] Failed to find or create person for", params.senderId);
+      return;
+    }
+    const channelLabel = params.platform.charAt(0).toUpperCase() + params.platform.slice(1);
+    const categoryLabel = params.dataCategory.replace(/_/g, " ");
+    const input = {
+      name: `${channelLabel} ${categoryLabel} \u2014 ${params.senderName || params.senderId}`,
+      happensAt: params.timestamp,
+      properties: {
+        channel: params.platform,
+        dataCategory: params.dataCategory,
+        senderId: params.senderId,
+        senderName: params.senderName || null,
+        accountId: params.accountId || null,
+        direction: "inbound",
+        ...params.eventData
+      },
+      targetPersonId: personId
+    };
+    const query = `
+      mutation CreateTimelineActivity($input: TimelineActivityCreateInput!) {
+        createTimelineActivity(data: $input) {
+          id
+        }
+      }
+    `;
+    const res = await gqlRequest(
+      query,
+      { input }
+    );
+    if (res.errors && res.errors.length > 0) {
+      console.error(
+        "[crm-bridge] pushGatewayEvent error:",
+        res.errors[0].message
+      );
+      return;
+    }
+    console.log(
+      `[crm-bridge] Event ${params.dataCategory} ${params.platform}/${params.senderId} \u2192 person ${personId}`
+    );
+  } catch (err) {
+    console.error("[crm-bridge] Event push failed:", err instanceof Error ? err.message : err);
+  }
+}
+
+export {
+  initCRMBridge,
+  isCRMBridgeEnabled,
+  findPersonByContact,
+  createPerson,
+  pushConversationToCRM,
+  pushInboundMessageToCRM,
+  pushGatewayEventToCRM
+};

package/dist/chunk-GGTUUI7J.js

@@ -0,0 +1,6 @@
+import {
+  init_session_key
+} from "./chunk-HP43GLZ6.js";
+
+// src/adapters/claude/session-key.ts
+init_session_key();

package/dist/chunk-GU56L7OY.js

@@ -0,0 +1,223 @@
+// src/lib/tool-gates.ts
+var TOOL_GATES = {
+  core: [],
+  // all agents — recall, store, ask_team, commit, search, session, consolidate, cardinality, behavior, identity, decisions
+  tasks: [],
+  // all agents — create, list, get, update, close, checkpoint, resume
+  comms: [],
+  // all agents — send_message, acknowledge
+  reminders: [],
+  // all agents — create, list, complete, reminder
+  "graph-read": [],
+  // all agents — query_relationships, get_entity_neighbors, get_hot_entities, get_graph_stats, find_similar_trajectories, code_context
+  "graph-write": ["COO", "CTO"],
+  // merge_entities, export_graph
+  wiki: ["COO", "Wiki Agent"],
+  // read/list curated wiki pages
+  crm: ["COO", "CRM Agent"],
+  // CRM read/list/get and legacy add/list/get person
+  "raw-data": ["COO", "CTO", "Gateway Agent", "CRM Agent", "Wiki Agent"],
+  // capped read-only raw landing-pad access
+  documents: ["COO", "CTO", "Wiki Agent"],
+  // ingest, list, purge, set_importance, rerank
+  gateway: ["COO", "Gateway Agent"],
+  // send_whatsapp, query_conversations, query_company_brain, company_actions
+  admin: ["COO"],
+  // deploy, backup, daemon health, auto-wake, worker gate, memory audit, consolidation, cloud sync, agent config, list employees, agent spend, sessions, session kills
+  licensing: ["COO"],
+  // get/create/list/activate license
+  orchestration: ["COO"]
+  // triggers, load_skill, starter_pack, export/import orchestration, global procedures
+};
+var TOOL_CATEGORIES = {
+  // core
+  registerMemory: "core",
+  registerRecallMyMemory: "core",
+  registerAskTeamMemory: "core",
+  registerGetSessionContext: "core",
+  registerGetMemoryById: "core",
+  registerStoreMemory: "core",
+  registerCommitMemory: "core",
+  registerSearchEverything: "core",
+  registerConsolidateMemories: "core",
+  registerGetMemoryCardinality: "core",
+  registerStoreBehavior: "core",
+  registerListBehaviors: "core",
+  registerDeactivateBehavior: "core",
+  registerBehavior: "core",
+  registerStoreDecision: "core",
+  registerGetDecision: "core",
+  registerCreateBugReport: "core",
+  registerSupportTools: "core",
+  registerCliParityTools: "admin",
+  registerGetSessionEvents: "core",
+  registerGetLastAssistantResponse: "core",
+  registerCodeContext: "graph-read",
+  // consolidated tools
+  registerDecision: "core",
+  registerSession: "core",
+  registerSupportConsolidated: "core",
+  registerDiagnostics: "admin",
+  registerListBugReports: "admin",
+  registerGetBugReport: "admin",
+  registerTriageBugReport: "admin",
+  registerIdentity: "core",
+  registerGetIdentity: "core",
+  registerUpdateIdentity: "core",
+  // tasks
+  registerTask: "tasks",
+  registerCreateTask: "tasks",
+  registerListTasks: "tasks",
+  registerUpdateTask: "tasks",
+  registerCloseTask: "tasks",
+  registerGetTask: "tasks",
+  registerCheckpointTask: "tasks",
+  registerResumeEmployee: "tasks",
+  // comms
+  registerMessage: "comms",
+  registerSendMessage: "comms",
+  registerAcknowledgeMessages: "comms",
+  // reminders
+  registerCreateReminder: "reminders",
+  registerListReminders: "reminders",
+  registerCompleteReminder: "reminders",
+  registerReminder: "reminders",
+  // graph-read
+  registerGraph: "graph-read",
+  registerQueryRelationships: "graph-read",
+  registerGetEntityNeighbors: "graph-read",
+  registerGetHotEntities: "graph-read",
+  registerGetGraphStats: "graph-read",
+  registerFindSimilarTrajectories: "graph-read",
+  // graph-write
+  registerMergeEntities: "graph-write",
+  registerExportGraph: "graph-write",
+  // wiki
+  registerWiki: "wiki",
+  registerCreateWikiPage: "wiki",
+  registerListWikiPages: "wiki",
+  registerGetWikiPage: "wiki",
+  // crm
+  registerCrm: "crm",
+  registerRawData: "raw-data",
+  registerAddPerson: "crm",
+  registerListPeople: "crm",
+  registerGetPerson: "crm",
+  // documents
+  registerDocument: "documents",
+  registerIngestDocument: "documents",
+  registerListDocuments: "documents",
+  registerPurgeDocument: "documents",
+  registerSetDocumentImportance: "documents",
+  registerRerankDocuments: "documents",
+  // gateway
+  registerGateway: "gateway",
+  registerSendWhatsapp: "gateway",
+  registerQueryConversations: "gateway",
+  registerQueryCompanyBrain: "gateway",
+  registerCompanyActions: "gateway",
+  // admin
+  registerConfig: "admin",
+  registerDeployClient: "admin",
+  registerBackupVps: "admin",
+  registerGetDaemonHealth: "admin",
+  registerMcpPing: "core",
+  registerGetAutoWakeStatus: "admin",
+  registerGetWorkerGate: "admin",
+  registerRunMemoryAudit: "admin",
+  registerRunConsolidation: "admin",
+  registerCloudSync: "admin",
+  registerOrchestrationPhase: "admin",
+  registerSetAgentConfig: "admin",
+  registerListEmployees: "admin",
+  registerGetAgentSpend: "admin",
+  registerListAgentSessions: "admin",
+  registerGetSessionKills: "admin",
+  // licensing
+  registerGetLicenseStatus: "licensing",
+  registerCreateLicense: "licensing",
+  registerListLicenses: "licensing",
+  registerActivateLicense: "licensing",
+  // orchestration
+  registerCreateTrigger: "orchestration",
+  registerListTriggers: "orchestration",
+  registerApplyStarterPack: "orchestration",
+  registerLoadSkill: "orchestration",
+  registerExportOrchestration: "orchestration",
+  registerImportOrchestration: "orchestration",
+  registerCompanyProcedure: "orchestration",
+  registerGlobalProcedure: "orchestration",
+  registerStoreGlobalProcedure: "orchestration",
+  registerListGlobalProcedures: "orchestration",
+  registerDeactivateGlobalProcedure: "orchestration"
+};
+var PLAN_TIERS = {
+  free: 0,
+  pro: 1,
+  team: 2,
+  agency: 3,
+  enterprise: 4
+};
+var PLAN_GATES = {
+  core: "free",
+  tasks: "free",
+  comms: "free",
+  reminders: "free",
+  "graph-read": "free",
+  licensing: "free",
+  // always allow checking/managing own license
+  "graph-write": "pro",
+  wiki: "pro",
+  crm: "pro",
+  "raw-data": "pro",
+  documents: "pro",
+  gateway: "pro",
+  admin: "pro",
+  orchestration: "pro"
+};
+function isToolAllowedForPlan(registerFnName, plan) {
+  const category = TOOL_CATEGORIES[registerFnName];
+  if (!category) return true;
+  const requiredPlan = PLAN_GATES[category] ?? "free";
+  return PLAN_TIERS[plan] >= PLAN_TIERS[requiredPlan];
+}
+var CHIEF_OF_STAFF_READ_TOOLS = /* @__PURE__ */ new Set([
+  "registerRecallMyMemory",
+  "registerAskTeamMemory",
+  "registerGetMemoryById",
+  "registerGetSessionContext",
+  "registerGetSessionEvents",
+  "registerGetLastAssistantResponse",
+  "registerSearchEverything",
+  "registerGetDecision",
+  "registerGetIdentity",
+  "registerMcpPing",
+  "registerListTasks",
+  "registerGetTask",
+  "registerListReminders",
+  "registerQueryConversations",
+  "registerQueryCompanyBrain"
+]);
+function isChiefOfStaffRole(role) {
+  const normalized = (role ?? "").trim().toLowerCase();
+  return normalized === "chief of staff" || normalized === "executive assistant";
+}
+function isToolAllowed(registerFnName) {
+  const role = process.env.AGENT_ROLE;
+  if (!role) return true;
+  if (isChiefOfStaffRole(role)) {
+    return CHIEF_OF_STAFF_READ_TOOLS.has(registerFnName);
+  }
+  const category = TOOL_CATEGORIES[registerFnName];
+  if (!category) return true;
+  const allowedRoles = TOOL_GATES[category];
+  if (!allowedRoles || allowedRoles.length === 0) return true;
+  return allowedRoles.includes(role);
+}
+
+export {
+  TOOL_GATES,
+  TOOL_CATEGORIES,
+  isToolAllowedForPlan,
+  isToolAllowed
+};

package/dist/chunk-HF25XPZE.js

@@ -0,0 +1,83 @@
+// src/runtime/permission-presets.ts
+var CTO_PRESET = {
+  defaultMode: "allow",
+  rules: []
+};
+var COO_PRESET = {
+  defaultMode: "deny",
+  rules: [
+    { tool: "Read", decision: "allow" },
+    { tool: "Glob", decision: "allow" },
+    { tool: "Grep", decision: "allow" },
+    { tool: "mcp__exe-os__*", decision: "allow" },
+    { tool: "mcp__exe-mem__*", decision: "allow" }
+  ]
+};
+var CMO_PRESET = {
+  defaultMode: "deny",
+  rules: [
+    { tool: "Read", decision: "allow" },
+    { tool: "Glob", decision: "allow" },
+    { tool: "Grep", decision: "allow" },
+    { tool: "Write", pattern: "exe/output/*", decision: "allow" },
+    { tool: "mcp__exe-os__*", decision: "allow" },
+    { tool: "mcp__exe-mem__*", decision: "allow" }
+  ]
+};
+var PRINCIPAL_ENGINEER_PRESET = {
+  defaultMode: "allow",
+  rules: [
+    { tool: "Bash", pattern: "rm -rf *", decision: "deny" },
+    { tool: "Bash", pattern: "sudo *", decision: "deny" }
+  ]
+};
+var CONTENT_SPECIALIST_PRESET = {
+  ...CMO_PRESET
+};
+var PERMISSION_PRESETS = {
+  CTO: CTO_PRESET,
+  COO: COO_PRESET,
+  CMO: CMO_PRESET,
+  "Principal Engineer": PRINCIPAL_ENGINEER_PRESET,
+  "Content Production Specialist": CONTENT_SPECIALIST_PRESET
+};
+function matchToolPattern(toolName, pattern) {
+  if (pattern === "*") return true;
+  if (!pattern.includes("*")) return toolName === pattern;
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(toolName);
+}
+function matchInputPattern(input, pattern) {
+  if (!pattern.includes("*")) return input === pattern;
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(input);
+}
+function evaluatePermission(config, toolName, toolInput) {
+  for (const rule of config.rules) {
+    if (!matchToolPattern(toolName, rule.tool)) continue;
+    if (rule.pattern) {
+      if (toolInput && matchInputPattern(toolInput, rule.pattern)) {
+        return { decision: rule.decision, rule };
+      }
+      continue;
+    }
+    return { decision: rule.decision, rule };
+  }
+  return { decision: config.defaultMode };
+}
+function getPresetByRole(role) {
+  return PERMISSION_PRESETS[role];
+}
+
+export {
+  CTO_PRESET,
+  COO_PRESET,
+  CMO_PRESET,
+  PRINCIPAL_ENGINEER_PRESET,
+  CONTENT_SPECIALIST_PRESET,
+  PERMISSION_PRESETS,
+  matchToolPattern,
+  matchInputPattern,
+  evaluatePermission,
+  getPresetByRole
+};

package/dist/chunk-HOKOOBDL.js

@@ -0,0 +1,52 @@
+// src/lib/crypto.ts
+import crypto from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+var SYNC_HKDF_INFO = "exe-mem-sync-v2";
+var _syncKey = null;
+function initSyncCrypto(masterKey) {
+  if (masterKey.length !== 32) {
+    throw new Error(`Master key must be 32 bytes, got ${masterKey.length}`);
+  }
+  _syncKey = Buffer.from(
+    crypto.hkdfSync("sha256", masterKey, "", SYNC_HKDF_INFO, 32)
+  );
+}
+function isSyncCryptoInitialized() {
+  return _syncKey !== null;
+}
+function requireSyncKey() {
+  if (!_syncKey) {
+    throw new Error("Sync crypto not initialized. Call initSyncCrypto(masterKey) first.");
+  }
+  return _syncKey;
+}
+function encryptSyncBlob(data) {
+  const key = requireSyncKey();
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, encrypted, tag]).toString("base64");
+}
+function decryptSyncBlob(ciphertext) {
+  const key = requireSyncKey();
+  const combined = Buffer.from(ciphertext, "base64");
+  if (combined.length < IV_LENGTH + TAG_LENGTH) {
+    throw new Error("Sync blob too short to contain IV + tag");
+  }
+  const iv = combined.subarray(0, IV_LENGTH);
+  const tag = combined.subarray(combined.length - TAG_LENGTH);
+  const encrypted = combined.subarray(IV_LENGTH, combined.length - TAG_LENGTH);
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
+
+export {
+  initSyncCrypto,
+  isSyncCryptoInitialized,
+  encryptSyncBlob,
+  decryptSyncBlob
+};

package/dist/chunk-HP43GLZ6.js

@@ -0,0 +1,89 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/session-key.ts
+import { execSync } from "child_process";
+function normalizeCommand(command) {
+  const trimmed = command.trim().toLowerCase();
+  const parts = trimmed.split(/[\\/]/);
+  return parts[parts.length - 1] ?? trimmed;
+}
+function detectRuntimeFromCommand(command) {
+  const normalized = normalizeCommand(command);
+  for (const [runtime, commands] of Object.entries(RUNTIME_COMMANDS)) {
+    if (commands.includes(normalized)) {
+      return runtime;
+    }
+  }
+  return null;
+}
+function resolveRuntimeProcess() {
+  let pid = process.ppid;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const info = execSync(`ps -p ${pid} -o ppid=,comm=`, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+      const [, ppid, cmd] = match;
+      const runtime = detectRuntimeFromCommand(cmd ?? "");
+      if (runtime) {
+        return { pid: String(pid), runtime };
+      }
+      pid = parseInt(ppid, 10);
+      if (pid <= 1) break;
+    } catch {
+      break;
+    }
+  }
+  return null;
+}
+function getSessionRuntime() {
+  if (process.env.EXE_RUNTIME) {
+    const envRuntime = process.env.EXE_RUNTIME.toLowerCase();
+    if (envRuntime === "claude" || envRuntime === "codex" || envRuntime === "opencode") {
+      return envRuntime;
+    }
+  }
+  if (_cachedRuntime) return _cachedRuntime;
+  const resolved = resolveRuntimeProcess();
+  _cachedRuntime = resolved?.runtime ?? null;
+  return _cachedRuntime;
+}
+function getSessionKey() {
+  if (_cached) return _cached;
+  if (process.env.EXE_SESSION_KEY) {
+    _cached = process.env.EXE_SESSION_KEY;
+    return _cached;
+  }
+  const resolved = resolveRuntimeProcess();
+  if (resolved) {
+    _cachedRuntime = resolved.runtime;
+    _cached = resolved.pid;
+    return _cached;
+  }
+  _cached = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
+  return _cached;
+}
+var _cached, _cachedRuntime, RUNTIME_COMMANDS;
+var init_session_key = __esm({
+  "src/lib/session-key.ts"() {
+    "use strict";
+    _cached = null;
+    _cachedRuntime = null;
+    RUNTIME_COMMANDS = {
+      claude: ["claude", "claude.exe", "claude-native"],
+      codex: ["codex"],
+      opencode: ["opencode"]
+    };
+  }
+});
+
+export {
+  getSessionRuntime,
+  getSessionKey,
+  init_session_key
+};