@sesamespace/hivemind 0.8.5 → 0.8.7

package/dist/{chunk-Q5ZO5WXM.js → chunk-KYNTNQXV.js}

@@ -1,8 +1,5 @@
-import {
-  SesameClient
-} from "./chunk-GPI4RU7N.js";
-
 // packages/runtime/src/llm-client.ts
+import { execSync } from "child_process";
 function convertMessagesForAnthropic(messages) {
   let system = "";
   const converted = [];
@@ -75,6 +72,24 @@ function parseAnthropicResponse(data) {
     } : void 0
   };
 }
+function getClaudeCodeOAuthToken() {
+  try {
+    const raw = execSync(
+      'security find-generic-password -s "Claude Code-credentials" -w',
+      { encoding: "utf-8", timeout: 5e3 }
+    ).trim();
+    const data = JSON.parse(raw);
+    const oauth = data?.claudeAiOauth;
+    if (!oauth?.accessToken) return null;
+    if (oauth.expiresAt && Date.now() > oauth.expiresAt) {
+      console.warn("[llm] Claude Code OAuth token expired. Run: claude auth login");
+      return null;
+    }
+    return oauth.accessToken;
+  } catch {
+    return null;
+  }
+}
 var LLMClient = class {
   baseUrl;
   model;
@@ -82,6 +97,7 @@ var LLMClient = class {
   temperature;
   apiKey;
   provider;
+  isOAuth;
   constructor(config) {
     this.baseUrl = config.base_url;
     this.model = config.model;
@@ -89,6 +105,22 @@ var LLMClient = class {
     this.temperature = config.temperature;
     this.apiKey = config.api_key ?? "";
     this.provider = config.provider ?? "openai";
+    this.isOAuth = false;
+    if (this.provider === "anthropic" && !this.apiKey) {
+      const token = getClaudeCodeOAuthToken();
+      if (token) {
+        this.apiKey = token;
+        this.isOAuth = true;
+        if (!this.baseUrl || this.baseUrl.includes("openrouter")) {
+          this.baseUrl = "https://api.anthropic.com";
+        }
+        console.log("[llm] Auth: Claude Max OAuth (from macOS Keychain)");
+      } else {
+        console.warn("[llm] Auth: No API key found for Anthropic provider");
+      }
+    } else if (this.provider === "anthropic") {
+      console.log("[llm] Auth: Anthropic API key (from config/env)");
+    }
   }
   /**
    * Simple chat completion (no tools). Backwards compatible.
@@ -181,13 +213,19 @@ var LLMClient = class {
         console.log(`[llm] Retry ${attempt}/${MAX_RETRIES} after ${delayMs}ms...`);
         await new Promise((r) => setTimeout(r, delayMs));
       }
+      const headers = {
+        "Content-Type": "application/json",
+        "anthropic-version": "2023-06-01"
+      };
+      if (this.isOAuth) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+        headers["anthropic-beta"] = "oauth-2025-04-20";
+      } else {
+        headers["x-api-key"] = this.apiKey;
+      }
       const resp = await fetch(`${this.baseUrl}/v1/messages`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.apiKey,
-          "anthropic-version": "2023-06-01"
-        },
+        headers,
         body: JSON.stringify(body)
       });
       if (!resp.ok) {
@@ -2472,6 +2510,16 @@ function loadConfig(path) {
       parsed.llm.base_url = "https://api.anthropic.com";
     }
   }
+  if (parsed.llm.provider === "anthropic" && !parsed.llm.api_key) {
+    const oauthToken = getClaudeCodeOAuthToken();
+    if (oauthToken) {
+      parsed.llm.api_key = oauthToken;
+      if (!process.env.LLM_BASE_URL && parsed.llm.base_url.includes("openrouter")) {
+        parsed.llm.base_url = "https://api.anthropic.com";
+      }
+      console.log("[config] Auth: Claude Max OAuth (from macOS Keychain)");
+    }
+  }
   if (process.env.LLM_PROVIDER) {
     parsed.llm.provider = process.env.LLM_PROVIDER;
   }
@@ -2519,6 +2567,626 @@ function loadConfig(path) {
   return parsed;
 }
 
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/client.js
+import WebSocket from "ws";
+
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/auth.js
+import { sign } from "crypto";
+function createAuthSignature(handle, privateKeyBase64url) {
+  const timestamp = Date.now();
+  const message = `AUTH:${handle}:${timestamp}`;
+  const privateKeyDer = Buffer.from(privateKeyBase64url, "base64url");
+  const privateKey = {
+    key: privateKeyDer,
+    format: "der",
+    type: "pkcs8"
+  };
+  const sig = sign(null, Buffer.from(message), privateKey);
+  return {
+    signature: sig.toString("base64url"),
+    timestamp
+  };
+}
+
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/client.js
+var SesameClient = class {
+  config;
+  ws = null;
+  eventHandlers = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  cursors = /* @__PURE__ */ new Map();
+  authenticated = false;
+  constructor(config) {
+    this.config = {
+      autoReconnect: true,
+      maxReconnectAttempts: 10,
+      ...config
+    };
+  }
+  // ── HTTP Methods ──
+  async fetch(path, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers ?? {}
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    } else if (this.config.token) {
+      headers["Authorization"] = `Bearer ${this.config.token}`;
+    } else if (this.config.agent) {
+      const { signature, timestamp } = createAuthSignature(this.config.agent.handle, this.config.agent.privateKey);
+      headers["Authorization"] = `Signature ${this.config.agent.handle}.${signature}.${timestamp}`;
+    }
+    const response = await globalThis.fetch(`${this.config.apiUrl}${path}`, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      throw new SesameApiError(response.status, error.error ?? "Request failed");
+    }
+    return response.json();
+  }
+  get(path) {
+    return this.fetch(path);
+  }
+  post(path, body) {
+    return this.fetch(path, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  patch(path, body) {
+    return this.fetch(path, {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    });
+  }
+  del(path) {
+    return this.fetch(path, { method: "DELETE" });
+  }
+  // ── Auth ──
+  async login(email, password) {
+    const result = await this.post("/api/v1/auth/login", { email, password });
+    this.config.token = result.accessToken;
+    return result;
+  }
+  // ── Channels ──
+  async listChannels() {
+    const result = await this.get("/api/v1/channels");
+    const channels = result.data ?? result.channels ?? result;
+    return { channels: Array.isArray(channels) ? channels : [] };
+  }
+  async getChannel(id) {
+    const result = await this.get(`/api/v1/channels/${id}`);
+    const channel = result.data ?? result.channel ?? result;
+    return { channel };
+  }
+  async createChannel(data) {
+    const result = await this.post("/api/v1/channels", data);
+    const channel = result.data ?? result.channel ?? result;
+    return { channel };
+  }
+  async getOrCreateDM(principalId) {
+    const result = await this.post("/api/v1/channels/dm", { principalId });
+    const channel = result.data ?? result.channel ?? result;
+    return { channel };
+  }
+  async getUnread() {
+    return this.get("/api/v1/channels/unread");
+  }
+  // ── Messages ──
+  async sendMessage(channelId, options) {
+    const result = await this.post(`/api/v1/channels/${channelId}/messages`, options);
+    const message = this.normalizeMessage(result.data ?? result.message ?? result);
+    if (message.seq) {
+      this.cursors.set(channelId, message.seq);
+    }
+    return { message };
+  }
+  async getMessages(channelId, options) {
+    const params = new URLSearchParams();
+    if (options?.cursor)
+      params.set("cursor", options.cursor.toString());
+    if (options?.limit)
+      params.set("limit", options.limit.toString());
+    if (options?.direction)
+      params.set("direction", options.direction);
+    if (options?.threadRootId)
+      params.set("threadRootId", options.threadRootId);
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/channels/${channelId}/messages${qs ? `?${qs}` : ""}`);
+    const messages = (result.data ?? result.messages ?? []).map((m) => this.normalizeMessage(m));
+    if (messages.length > 0) {
+      const maxSeq = Math.max(...messages.map((m) => m.seq));
+      const current = this.cursors.get(channelId) ?? 0;
+      if (maxSeq > current)
+        this.cursors.set(channelId, maxSeq);
+    }
+    return {
+      messages,
+      cursor: result.pagination?.cursor ? Number(result.pagination.cursor) : 0,
+      hasMore: result.pagination?.hasMore ?? false
+    };
+  }
+  async editMessage(channelId, messageId, content) {
+    const result = await this.patch(`/api/v1/channels/${channelId}/messages/${messageId}`, { content });
+    const message = this.normalizeMessage(result.data ?? result.message ?? result);
+    return { message };
+  }
+  async deleteMessage(channelId, messageId) {
+    await this.del(`/api/v1/channels/${channelId}/messages/${messageId}`);
+  }
+  async markRead(channelId, seq) {
+    await this.post(`/api/v1/channels/${channelId}/messages/read`, { seq });
+  }
+  async addReaction(channelId, messageId, emoji) {
+    await this.post(`/api/v1/channels/${channelId}/messages/${messageId}/reactions`, { emoji });
+  }
+  async removeReaction(channelId, messageId, emoji) {
+    await this.del(`/api/v1/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
+  }
+  // ── Vault ──
+  async listVaults() {
+    return this.get("/api/v1/vault/vaults");
+  }
+  async listVaultItems(vaultId) {
+    const qs = vaultId ? `?vaultId=${vaultId}` : "";
+    return this.get(`/api/v1/vault/items${qs}`);
+  }
+  async getVaultItem(id) {
+    return this.get(`/api/v1/vault/items/${id}`);
+  }
+  async createVaultItem(options) {
+    return this.post("/api/v1/vault/items", options);
+  }
+  async revealItem(id, fields) {
+    return this.post(`/api/v1/vault/items/${id}/reveal`, fields ? { fields } : void 0);
+  }
+  async shareItem(itemId, principalId, options) {
+    await this.post(`/api/v1/vault/items/${itemId}/share`, {
+      principalId,
+      ...options
+    });
+  }
+  async revokeShare(itemId, principalId) {
+    await this.del(`/api/v1/vault/items/${itemId}/share/${principalId}`);
+  }
+  async getWallet() {
+    return this.get("/api/v1/vault/wallet");
+  }
+  // ── Leases ──
+  async requestLease(options) {
+    return this.post("/api/v1/vault/leases/request", options);
+  }
+  async approveLease(leaseId, options) {
+    return this.post(`/api/v1/vault/leases/${leaseId}/approve`, options ?? {});
+  }
+  async denyLease(leaseId) {
+    return this.post(`/api/v1/vault/leases/${leaseId}/deny`, {});
+  }
+  async useSecret(leaseId) {
+    return this.post(`/api/v1/vault/leases/${leaseId}/use`, {});
+  }
+  async revokeLease(leaseId) {
+    await this.del(`/api/v1/vault/leases/${leaseId}`);
+  }
+  // ── HTTP helper: PUT ──
+  put(path, body) {
+    return this.fetch(path, {
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  // ── Agents ──
+  async listAgents() {
+    return this.get("/api/v1/agents");
+  }
+  async provisionAgent(data) {
+    return this.post("/api/v1/agents", data);
+  }
+  async generateApiKey(agentId, label) {
+    const res = await this.post(`/api/v1/agents/${agentId}/api-keys`, { label });
+    return res.data ?? res;
+  }
+  // ── Capabilities ──
+  async registerCapabilities(capabilities) {
+    const agentId = this.getAgentId();
+    const result = await this.put(`/api/v1/agents/${agentId}/capabilities`, { capabilities });
+    return { capabilities: result.data ?? result };
+  }
+  async addCapability(capability) {
+    const agentId = this.getAgentId();
+    const result = await this.post(`/api/v1/agents/${agentId}/capabilities`, capability);
+    return { capability: result.data ?? result };
+  }
+  async getCapabilities(agentId) {
+    const id = agentId ?? this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${id}/capabilities`);
+    return { capabilities: result.data ?? result };
+  }
+  async removeCapability(capabilityId) {
+    const agentId = this.getAgentId();
+    await this.del(`/api/v1/agents/${agentId}/capabilities/${capabilityId}`);
+  }
+  // ── Discovery ──
+  async discoverAgents(query = {}) {
+    const params = new URLSearchParams();
+    if (query.namespace)
+      params.set("namespace", query.namespace);
+    if (query.name)
+      params.set("name", query.name);
+    if (query.capability) {
+      const caps = Array.isArray(query.capability) ? query.capability : [query.capability];
+      for (const cap of caps) {
+        params.append("capability", cap);
+      }
+    }
+    if (query.active !== void 0)
+      params.set("active", String(query.active));
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/agents/discover${qs ? `?${qs}` : ""}`);
+    return { agents: result.data ?? result };
+  }
+  // ── Manifest & Context ──
+  async getManifest() {
+    if (!this._principalId) {
+      const me = await this.get("/api/v1/auth/me");
+      this.setPrincipalId(me.data?.id ?? me.id);
+    }
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/manifest`);
+    return result.data ?? result;
+  }
+  async getChannelContext(channelId, options) {
+    const agentId = this.getAgentId();
+    const params = new URLSearchParams();
+    if (options?.strategy)
+      params.set("strategy", options.strategy);
+    if (options?.window)
+      params.set("window", String(options.window));
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/agents/${agentId}/channels/${channelId}/context${qs ? `?${qs}` : ""}`);
+    return result.data ?? result;
+  }
+  // ── Channel Config ──
+  async setChannelConfig(channelId, config) {
+    const agentId = this.getAgentId();
+    const result = await this.put(`/api/v1/agents/${agentId}/channels/${channelId}/config`, config);
+    return result.data ?? result;
+  }
+  async getChannelConfig(channelId) {
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/channels/${channelId}/config`);
+    return result.data ?? result;
+  }
+  async deleteChannelConfig(channelId) {
+    const agentId = this.getAgentId();
+    await this.del(`/api/v1/agents/${agentId}/channels/${channelId}/config`);
+  }
+  // ── Collaboration ──
+  async createCollaborationChannel(options) {
+    const result = await this.createChannel({
+      kind: "topic",
+      name: options.name,
+      description: options.description,
+      memberIds: options.memberIds
+    });
+    const channel = result.data ?? result.channel ?? result;
+    const channelId = channel.id;
+    if (options.context) {
+      await this.put(`/api/v1/channels/${channelId}/context`, { context: options.context });
+    }
+    if (options.visibility) {
+      await this.patch(`/api/v1/channels/${channelId}`, { visibility: options.visibility });
+    }
+    if (options.coordinationMode) {
+      await this.put(`/api/v1/channels/${channelId}/coordination`, {
+        mode: options.coordinationMode
+      });
+    }
+    return { channel };
+  }
+  // ── Tasks ──
+  async createTask(channelId, options) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks`, options);
+    return { task: result.data ?? result };
+  }
+  async listTasks(channelId, filters) {
+    const params = new URLSearchParams();
+    if (filters?.status)
+      params.set("status", filters.status);
+    if (filters?.priority)
+      params.set("priority", filters.priority);
+    if (filters?.assigneeId)
+      params.set("assigneeId", filters.assigneeId);
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/channels/${channelId}/tasks${qs ? `?${qs}` : ""}`);
+    return { tasks: result.data ?? result };
+  }
+  async updateTask(channelId, taskId, updates) {
+    const result = await this.patch(`/api/v1/channels/${channelId}/tasks/${taskId}`, updates);
+    return { task: result.data ?? result };
+  }
+  async claimTask(channelId, taskId) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks/${taskId}/claim`);
+    return { task: result.data ?? result };
+  }
+  async addTaskAssignee(channelId, taskId, principalId, role) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks/${taskId}/assignees`, { principalId, role });
+    return { task: result.data ?? result };
+  }
+  async removeTaskAssignee(channelId, taskId, principalId) {
+    const result = await this.del(`/api/v1/channels/${channelId}/tasks/${taskId}/assignees/${principalId}`);
+    return { task: result.data ?? result };
+  }
+  async createTaskChannel(channelId, taskId, options) {
+    const result = await this.post(`/api/v1/channels/${channelId}/tasks/${taskId}/channel`, options ?? {});
+    return result.data ?? result;
+  }
+  // ── Webhooks ──
+  async createWebhook(options) {
+    const agentId = this.getAgentId();
+    const result = await this.post(`/api/v1/agents/${agentId}/webhooks`, options);
+    return { webhook: result.data ?? result };
+  }
+  async listWebhooks() {
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/webhooks`);
+    return { webhooks: result.data ?? result };
+  }
+  async updateWebhook(webhookId, updates) {
+    const agentId = this.getAgentId();
+    const result = await this.patch(`/api/v1/agents/${agentId}/webhooks/${webhookId}`, updates);
+    return { webhook: result.data ?? result };
+  }
+  async deleteWebhook(webhookId) {
+    const agentId = this.getAgentId();
+    await this.del(`/api/v1/agents/${agentId}/webhooks/${webhookId}`);
+  }
+  async rotateWebhookSecret(webhookId) {
+    const agentId = this.getAgentId();
+    const result = await this.post(`/api/v1/agents/${agentId}/webhooks/${webhookId}/rotate-secret`);
+    return result.data ?? result;
+  }
+  async listWebhookDeliveries(webhookId, options) {
+    const agentId = this.getAgentId();
+    const params = new URLSearchParams();
+    if (options?.limit)
+      params.set("limit", String(options.limit));
+    if (options?.status)
+      params.set("status", options.status);
+    const qs = params.toString();
+    const result = await this.get(`/api/v1/agents/${agentId}/webhooks/${webhookId}/deliveries${qs ? `?${qs}` : ""}`);
+    return { deliveries: result.data ?? result };
+  }
+  // ── Profile ──
+  async setReadReceiptEmoji(emoji) {
+    const agentId = this.getAgentId();
+    const result = await this.put(`/api/v1/agents/${agentId}/read-receipt-emoji`, { emoji });
+    return { emoji: result.data?.emoji ?? emoji };
+  }
+  async getReadReceiptEmoji() {
+    const agentId = this.getAgentId();
+    const result = await this.get(`/api/v1/agents/${agentId}/read-receipt-emoji`);
+    return { emoji: result.data?.emoji ?? "\u{1F440}" };
+  }
+  // ── Internal helpers ──
+  normalizeMessage(msg) {
+    return {
+      ...msg,
+      content: msg.content ?? msg.plaintext ?? null
+    };
+  }
+  getAgentId() {
+    const principal = this._principalId;
+    if (principal)
+      return principal;
+    throw new SesameApiError(400, "Agent ID not resolved. Call boot() or setPrincipalId(id) first.");
+  }
+  /**
+   * Set the current agent's principal ID (resolved after auth).
+   */
+  setPrincipalId(id) {
+    this._principalId = id;
+  }
+  /**
+   * Bootstrap the agent: resolves identity via /auth/me and loads manifest.
+   */
+  async boot() {
+    const me = await this.get("/api/v1/auth/me");
+    const principal = me.data ?? me;
+    this.setPrincipalId(principal.id);
+    const manifest = await this.getManifest();
+    return manifest;
+  }
+  // ── WebSocket ──
+  /**
+   * Connect to the real-time WebSocket gateway.
+   */
+  connect() {
+    return new Promise((resolve20, reject) => {
+      try {
+        this.ws = new WebSocket(`${this.config.wsUrl}/v1/connect`);
+        this.ws.on("open", () => {
+          this.reconnectAttempts = 0;
+          this.sendAuth();
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const event = JSON.parse(data.toString());
+            if (event.type === "authenticated") {
+              this.authenticated = true;
+              this.startHeartbeat(event.heartbeatIntervalMs ?? 3e4);
+              this.sendReplay();
+              resolve20();
+              return;
+            }
+            if (event.type === "pong")
+              return;
+            if (event.type === "error") {
+              console.error("WS error:", event.message);
+              return;
+            }
+            if (event.type === "message" && event.data) {
+              event.data = this.normalizeMessage(event.data);
+              const seq = event.data.seq;
+              if (seq) {
+                const channelId = event.data.channelId;
+                const current = this.cursors.get(channelId) ?? 0;
+                if (seq > current)
+                  this.cursors.set(channelId, seq);
+              }
+            }
+            this.emit(event);
+          } catch {
+          }
+        });
+        this.ws.on("close", () => {
+          this.authenticated = false;
+          this.stopHeartbeat();
+          if (this.config.autoReconnect) {
+            this.scheduleReconnect();
+          }
+        });
+        this.ws.on("error", (err) => {
+          if (!this.authenticated) {
+            reject(err);
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket gateway.
+   */
+  disconnect() {
+    this.config.autoReconnect = false;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Subscribe to WebSocket events.
+   */
+  on(eventType, handler) {
+    if (!this.eventHandlers.has(eventType)) {
+      this.eventHandlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(eventType).add(handler);
+    return () => {
+      this.eventHandlers.get(eventType)?.delete(handler);
+    };
+  }
+  /**
+   * Subscribe to all events.
+   */
+  onAny(handler) {
+    return this.on("*", handler);
+  }
+  emit(event) {
+    this.eventHandlers.get(event.type)?.forEach((h) => h(event));
+    this.eventHandlers.get("*")?.forEach((h) => h(event));
+  }
+  sendAuth() {
+    if (!this.ws)
+      return;
+    if (this.config.apiKey) {
+      this.ws.send(JSON.stringify({ type: "auth", apiKey: this.config.apiKey }));
+    } else if (this.config.token) {
+      this.ws.send(JSON.stringify({ type: "auth", token: this.config.token }));
+    } else if (this.config.agent) {
+      const { signature, timestamp } = createAuthSignature(this.config.agent.handle, this.config.agent.privateKey);
+      this.ws.send(JSON.stringify({
+        type: "auth",
+        signature: {
+          handle: this.config.agent.handle,
+          sig: signature,
+          timestamp
+        }
+      }));
+    }
+  }
+  sendReplay() {
+    if (!this.ws || this.cursors.size === 0)
+      return;
+    const cursors = {};
+    this.cursors.forEach((seq, channelId) => {
+      cursors[channelId] = seq;
+    });
+    this.ws.send(JSON.stringify({ type: "replay", cursors }));
+  }
+  startHeartbeat(intervalMs) {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, intervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      console.error("Max reconnect attempts reached");
+      return;
+    }
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {
+        this.scheduleReconnect();
+      });
+    }, delay);
+  }
+  /**
+   * Send a typing indicator for a channel.
+   */
+  sendTyping(channelId) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "typing", channelId }));
+    }
+  }
+  /**
+   * Send a message via WebSocket (alternative to HTTP).
+   */
+  sendWsMessage(channelId, content, options) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({
+        type: "send",
+        channelId,
+        content,
+        ...options
+      }));
+    }
+  }
+};
+var SesameApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SesameApiError";
+  }
+};
+
+// node_modules/.pnpm/@sesamespace+sdk@0.1.6/node_modules/@sesamespace/sdk/dist/verify-webhook.js
+import { createHmac, timingSafeEqual } from "crypto";
+
 // packages/runtime/src/sesame.ts
 import { readFileSync as readFileSync5 } from "fs";
 import { resolve as resolve4, dirname as dirname3 } from "path";
@@ -2688,7 +3356,7 @@ var SesameClient2 = class {
 };
 
 // packages/runtime/src/skills.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, watch as watch2, mkdirSync as mkdirSync3 } from "fs";
 import { resolve as resolve5 } from "path";
 function shellEscape(value) {
@@ -2757,7 +3425,7 @@ var SkillsEngine = class {
     const setupPath = resolve5(skillDir, "setup.sh");
     if (existsSync5(setupPath)) {
       try {
-        execSync("bash setup.sh", { cwd: skillDir, timeout: 3e4, stdio: "pipe" });
+        execSync2("bash setup.sh", { cwd: skillDir, timeout: 3e4, stdio: "pipe" });
         console.log(`[skills] Ran setup.sh for "${name}"`);
       } catch (err) {
         console.warn(`[skills] setup.sh failed for "${name}":`, err.message);
@@ -2782,7 +3450,7 @@ var SkillsEngine = class {
             async (params) => {
               const cmd = renderCommand(commandTemplate, params, skillDir, this.workspaceDir);
               try {
-                const output = execSync(cmd, {
+                const output = execSync2(cmd, {
                   cwd: skillDir,
                   timeout: 6e4,
                   encoding: "utf-8",
@@ -2821,7 +3489,7 @@ var SkillsEngine = class {
     const teardownPath = resolve5(skill.path, "teardown.sh");
     if (existsSync5(teardownPath)) {
       try {
-        execSync("bash teardown.sh", { cwd: skill.path, timeout: 3e4, stdio: "pipe" });
+        execSync2("bash teardown.sh", { cwd: skill.path, timeout: 3e4, stdio: "pipe" });
         console.log(`[skills] Ran teardown.sh for "${skill.name}"`);
       } catch (err) {
         console.warn(`[skills] teardown.sh failed for "${skill.name}":`, err.message);
@@ -3217,7 +3885,7 @@ var ToolRegistry = class {
 };
 
 // packages/runtime/src/tools/shell.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { resolve as resolve7 } from "path";
 var MAX_OUTPUT = 5e4;
 function registerShellTool(registry, workspaceDir) {
@@ -3247,7 +3915,7 @@ function registerShellTool(registry, workspaceDir) {
       const timeout = (params.timeout || 30) * 1e3;
       const cwd = params.workdir ? resolve7(workspaceDir, params.workdir) : workspaceDir;
       try {
-        const output = execSync2(command, {
+        const output = execSync3(command, {
           cwd,
           timeout,
           encoding: "utf-8",
@@ -4120,7 +4788,7 @@ function registerVisionTools(registry) {
 }
 
 // packages/runtime/src/tools/git.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import { resolve as resolve10, normalize } from "path";
 function resolveRepoPath(workspaceDir, repoPath) {
   if (!repoPath) return workspaceDir;
@@ -4133,7 +4801,7 @@ function resolveRepoPath(workspaceDir, repoPath) {
   return resolved;
 }
 function runGit(args, cwd) {
-  const output = execSync3(`git ${args}`, {
+  const output = execSync4(`git ${args}`, {
     cwd,
     timeout: 3e4,
     encoding: "utf-8",
@@ -4540,7 +5208,7 @@ function registerBrowserTools(registry, workspaceDir) {
 }
 
 // packages/runtime/src/tools/system.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import * as os from "os";
 var MAX_OUTPUT3 = 5e4;
 function truncate(output) {
@@ -4551,7 +5219,7 @@ function truncate(output) {
   return output;
 }
 function exec(cmd, timeoutS = 10) {
-  return execSync4(cmd, {
+  return execSync5(cmd, {
     encoding: "utf-8",
     timeout: timeoutS * 1e3,
     maxBuffer: 10 * 1024 * 1024,
@@ -5142,13 +5810,13 @@ ${lines.join("\n")}`;
 }
 
 // packages/runtime/src/tools/macos.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import { resolve as resolve14, normalize as normalize2 } from "path";
 import { mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
 var MAX_OUTPUT4 = 5e4;
 function shellExec(command, timeoutMs) {
-  return execSync5(command, {
+  return execSync6(command, {
     timeout: timeoutMs,
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024,
@@ -5259,7 +5927,7 @@ ${output || err.message}`;
     async (params) => {
       const content = params.content;
       try {
-        execSync5("pbcopy", {
+        execSync6("pbcopy", {
           input: content,
           timeout: 5e3,
           encoding: "utf-8",
@@ -5359,12 +6027,12 @@ function escapeAppleString(s) {
 }
 
 // packages/runtime/src/tools/data.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 import { resolve as resolve15, normalize as normalize3, extname as extname2 } from "path";
 import { mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
 var MAX_OUTPUT5 = 5e4;
 function shellExec2(command, cwd, timeoutMs) {
-  return execSync6(command, {
+  return execSync7(command, {
     cwd,
     timeout: timeoutMs,
     encoding: "utf-8",
@@ -5605,7 +6273,7 @@ function truncate2(text) {
 }
 
 // packages/runtime/src/tools/coding-agent.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import { resolve as resolve16 } from "path";
 var MAX_OUTPUT6 = 5e4;
 function registerCodingAgentTools(registry, workspaceDir) {
@@ -5635,14 +6303,14 @@ function registerCodingAgentTools(registry, workspaceDir) {
       const timeoutSeconds = params.timeout || 300;
       const cwd = params.workdir ? resolve16(workspaceDir, params.workdir) : workspaceDir;
       try {
-        execSync7("which claude", { stdio: "ignore" });
+        execSync8("which claude", { stdio: "ignore" });
       } catch {
         return "Error: 'claude' CLI not found. Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code";
       }
       const escapedTask = task.replace(/'/g, "'\\''");
       const command = `claude --dangerously-skip-permissions -p '${escapedTask}'`;
       try {
-        const output = execSync7(command, {
+        const output = execSync8(command, {
           cwd,
           timeout: timeoutSeconds * 1e3,
           encoding: "utf-8",
@@ -6656,6 +7324,7 @@ async function startWorker(config) {
 }
 
 export {
+  getClaudeCodeOAuthToken,
   LLMClient,
   MemoryClient,
   ContextManager,
@@ -6671,7 +7340,8 @@ export {
   EventsWatcher,
   defaultSentinelConfig,
   loadConfig,
-  SesameClient2 as SesameClient,
+  SesameClient,
+  SesameClient2,
   HEALTH_PATH,
   SkillsEngine,
   startPipeline,
@@ -6723,4 +7393,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-Q5ZO5WXM.js.map
+//# sourceMappingURL=chunk-KYNTNQXV.js.map