@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-ORCCI2VV.js

@@ -0,0 +1,140 @@
+// src/gateway/adapters/slack.ts
+import { randomUUID } from "crypto";
+var SlackAdapter = class {
+  platform = "slack";
+  webClient = null;
+  // WebClient — dynamic import
+  socketClient = null;
+  // SocketModeClient — dynamic import
+  messageHandler = null;
+  connected = false;
+  botUserId = "";
+  async connect(config) {
+    const { WebClient } = await import("@slack/web-api");
+    const { SocketModeClient } = await import("@slack/socket-mode");
+    const token = config.credentials.bot_token ?? config.credentials.token;
+    const appToken = config.credentials.app_token;
+    if (!token) {
+      throw new Error("Slack requires bot_token (xoxb-) in credentials");
+    }
+    if (!appToken) {
+      throw new Error("Slack requires app_token (xapp-) for Socket Mode in credentials");
+    }
+    this.webClient = new WebClient(token);
+    this.socketClient = new SocketModeClient({ appToken });
+    try {
+      const auth = await this.webClient.auth.test();
+      this.botUserId = auth.user_id ?? "";
+    } catch (err) {
+      throw new Error(
+        `Slack auth failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    this.socketClient.on("message", async ({ event, ack }) => {
+      await ack();
+      if (!this.messageHandler || !event) return;
+      if (event.user === this.botUserId) return;
+      if (event.subtype) return;
+      const isGroup = event.channel_type !== "im";
+      const normalized = {
+        messageId: event.client_msg_id ?? event.ts ?? randomUUID(),
+        platform: "slack",
+        senderId: event.user ?? "",
+        channelId: event.channel ?? "",
+        chatType: isGroup ? "group" : "direct",
+        text: event.text ?? "",
+        timestamp: event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        threadId: event.thread_ts ?? void 0,
+        replyTo: event.thread_ts && event.thread_ts !== event.ts ? {
+          messageId: event.thread_ts,
+          text: "",
+          senderId: ""
+        } : void 0,
+        media: this.extractMedia(event),
+        raw: event
+      };
+      try {
+        await this.messageHandler(normalized);
+      } catch (err) {
+        console.error("[slack] Message handler error:", err);
+      }
+    });
+    await this.socketClient.start();
+    this.connected = true;
+    console.log("[slack] Connected via Socket Mode");
+  }
+  async disconnect() {
+    await this.socketClient?.disconnect();
+    this.socketClient = null;
+    this.webClient = null;
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async sendText(channelId, text, options) {
+    if (!this.webClient || !this.connected) throw new Error("Slack not connected");
+    await this.webClient.chat.postMessage({
+      channel: channelId,
+      text,
+      thread_ts: options?.replyToMessageId
+    });
+  }
+  async sendTyping(_channelId) {
+  }
+  async healthCheck() {
+    if (!this.webClient) return { connected: false };
+    const start = Date.now();
+    try {
+      await this.webClient.auth.test();
+      return { connected: true, latencyMs: Date.now() - start };
+    } catch {
+      return { connected: false };
+    }
+  }
+  /** Inject a raw Slack event payload from webhook server */
+  async injectMessage(rawPayload) {
+    if (!this.messageHandler) return;
+    const event = rawPayload;
+    if (!event.text) return;
+    const isGroup = event.channel_type !== "im";
+    const normalized = {
+      messageId: event.ts ?? randomUUID(),
+      platform: "slack",
+      senderId: event.user ?? "",
+      senderName: event.user_profile?.display_name ?? event.user_profile?.real_name ?? void 0,
+      channelId: event.channel ?? "",
+      chatType: isGroup ? "group" : "direct",
+      text: event.text,
+      timestamp: event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      threadId: event.thread_ts ?? void 0,
+      media: this.extractMedia(event),
+      raw: rawPayload
+    };
+    try {
+      await this.messageHandler(normalized);
+    } catch (err) {
+      console.error("[slack] injectMessage handler error:", err);
+    }
+  }
+  extractMedia(event) {
+    const files = event.files;
+    if (!files || !Array.isArray(files) || files.length === 0) return void 0;
+    return files.map((f) => {
+      const mimetype = f.mimetype ?? "";
+      let type = "document";
+      if (mimetype.startsWith("image/")) type = "image";
+      else if (mimetype.startsWith("video/")) type = "video";
+      else if (mimetype.startsWith("audio/")) type = "audio";
+      return {
+        type,
+        url: f.url_private ?? void 0,
+        fileName: f.name ?? void 0
+      };
+    });
+  }
+};
+
+export {
+  SlackAdapter
+};

package/dist/chunk-OSMMWGJ2.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/pipeline-router.ts
+import crypto from "crypto";
+async function sinkConversationStore(msg, agentResponse, agentName) {
+  try {
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const mediaJson = msg.media ? JSON.stringify(msg.media) : null;
+    await client.execute({
+      sql: `INSERT INTO conversations
+            (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
+             recipient_id, channel_id, thread_id, reply_to_id,
+             content_text, content_media, agent_response, agent_name,
+             timestamp, ingested_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        msg.platform,
+        msg.messageId,
+        msg.senderId,
+        msg.senderName ?? null,
+        msg.senderPhone ?? null,
+        msg.senderEmail ?? null,
+        msg.accountId ?? null,
+        msg.channelId,
+        msg.threadId ?? `${msg.platform}:${msg.channelId}`,
+        msg.replyTo?.messageId ?? null,
+        msg.text ?? null,
+        mediaJson,
+        agentResponse ?? null,
+        agentName ?? null,
+        msg.timestamp,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] conversation-store error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkMemory(msg, agentResponse, agentName) {
+  try {
+    const { embed } = await import("./lib/embedder.js");
+    const { writeMemory, flushBatch } = await import("./lib/store.js");
+    const direction = agentResponse ? "conversation" : "inbound";
+    const rawText = [
+      `[${msg.platform}] ${direction} from ${msg.senderName ?? msg.senderId}`,
+      msg.text ? `Message: ${msg.text}` : null,
+      agentResponse ? `Agent (${agentName ?? "unknown"}): ${agentResponse}` : null
+    ].filter(Boolean).join("\n");
+    const vector = await embed(rawText);
+    await writeMemory({
+      id: crypto.randomUUID(),
+      agent_id: agentName ?? "gateway",
+      agent_role: "gateway",
+      session_id: `gateway-${msg.platform}`,
+      timestamp: msg.timestamp,
+      tool_name: `gateway-${msg.platform}`,
+      project_name: "exe-os",
+      has_error: false,
+      raw_text: rawText,
+      vector,
+      importance: 4,
+      confidence: 0.8
+    });
+    await flushBatch();
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] memory-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkCRM(msg, agentResponse, agentName) {
+  try {
+    const { isCRMBridgeEnabled, pushConversationToCRM, pushInboundMessageToCRM } = await import("./crm-bridge-NG5WJMGF.js");
+    if (!isCRMBridgeEnabled()) return false;
+    if (agentResponse) {
+      await pushConversationToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        agentResponse,
+        agentName: agentName ?? "unknown",
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    } else {
+      await pushInboundMessageToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] crm-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkWiki(msg, agentResponse) {
+  try {
+    const { createWikiClient } = await import("./wiki-client-KE622HKY.js");
+    const client = await createWikiClient();
+    if (!client) return false;
+    const content = msg.text ?? "";
+    if (content.length < 50) return false;
+    const { chatInWorkspace } = await import("./wiki-client-KE622HKY.js");
+    const ingestText = [
+      `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
+      content,
+      agentResponse ? `
+Agent response: ${agentResponse}` : ""
+    ].join("\n");
+    await chatInWorkspace(client, "conversations", ingestText, "chat");
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] wiki-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkEntityExtraction(msg, agentResponse, agentName) {
+  try {
+    const { extractFromConversation } = await import("./conversation-entity-extractor-TW4W57K4.js");
+    const { storeExtraction } = await import("./graph-rag-S5SBJW5J.js");
+    if ((msg.text?.length ?? 0) < 20) return false;
+    if (msg.isHistorical) return false;
+    const extraction = await extractFromConversation(msg, agentResponse, agentName);
+    if (extraction.entities.length === 0) return false;
+    const client = getClient();
+    const memoryId = `conv:${msg.messageId}`;
+    await storeExtraction(client, extraction, memoryId, msg.timestamp);
+    import("./conversation-wiki-populator-GNFRTS7X.js").then(
+      ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
+    ).catch((err) => {
+      process.stderr.write(
+        `[pipeline] wiki-population error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] entity-extraction-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function ingest(msg, agentResponse, agentName) {
+  const errors = [];
+  const [conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted] = await Promise.all([
+    sinkConversationStore(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`conversation: ${e}`);
+      return false;
+    }),
+    sinkMemory(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`memory: ${e}`);
+      return false;
+    }),
+    sinkCRM(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`crm: ${e}`);
+      return false;
+    }),
+    sinkWiki(msg, agentResponse).catch((e) => {
+      errors.push(`wiki: ${e}`);
+      return false;
+    }),
+    sinkEntityExtraction(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`entity-extraction: ${e}`);
+      return false;
+    })
+  ]);
+  if (errors.length > 0) {
+    process.stderr.write(
+      `[pipeline] ${errors.length} sink error(s): ${errors.join("; ")}
+`
+    );
+  }
+  return { conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted, errors };
+}
+
+export {
+  ingest
+};

package/dist/chunk-OYNKIAVW.js

@@ -0,0 +1,181 @@
+// src/lib/tmux-transport.ts
+import { execFileSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { randomBytes } from "crypto";
+import path from "path";
+import os from "os";
+var LONG_MESSAGE_THRESHOLD = 500;
+var TMUX_STATUS_CACHE_TTL_MS = Number(process.env.EXE_TMUX_STATUS_CACHE_TTL_MS || 2e3);
+var QUIET = {
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "pipe"],
+  timeout: 3e3
+};
+var TmuxTransport = class {
+  sessionsCache = { ts: 0, sessions: [] };
+  paneStatusCache = { ts: 0, bySession: /* @__PURE__ */ new Map(), byPaneId: /* @__PURE__ */ new Map() };
+  invalidateCaches() {
+    this.sessionsCache = { ts: 0, sessions: [] };
+    this.paneStatusCache = { ts: 0, bySession: /* @__PURE__ */ new Map(), byPaneId: /* @__PURE__ */ new Map() };
+  }
+  listSessionsCached() {
+    const now = Date.now();
+    if (now - this.sessionsCache.ts < TMUX_STATUS_CACHE_TTL_MS) return this.sessionsCache.sessions;
+    try {
+      const sessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], QUIET).trim().split("\n").filter(Boolean);
+      this.sessionsCache = { ts: now, sessions };
+      return sessions;
+    } catch {
+      this.sessionsCache = { ts: now, sessions: [] };
+      return [];
+    }
+  }
+  listPaneStatusCached() {
+    const now = Date.now();
+    if (now - this.paneStatusCache.ts < TMUX_STATUS_CACHE_TTL_MS) return this.paneStatusCache;
+    const bySession = /* @__PURE__ */ new Map();
+    const byPaneId = /* @__PURE__ */ new Map();
+    try {
+      const out = execFileSync(
+        "tmux",
+        ["list-panes", "-a", "-F", "#{session_name}	#{pane_id}	#{pane_dead}"],
+        QUIET
+      );
+      for (const line of out.trim().split("\n").filter(Boolean)) {
+        const [session, paneId, paneDead] = line.split("	");
+        if (!session) continue;
+        const dead = paneDead === "1" ? "1" : "0";
+        const panes = bySession.get(session) ?? [];
+        panes.push(dead);
+        bySession.set(session, panes);
+        if (paneId) byPaneId.set(paneId, dead);
+      }
+    } catch {
+    }
+    this.paneStatusCache = { ts: now, bySession, byPaneId };
+    return this.paneStatusCache;
+  }
+  getMySession() {
+    try {
+      return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  listSessions() {
+    return this.listSessionsCached();
+  }
+  isAlive(target) {
+    try {
+      const paneStatus = this.listPaneStatusCached();
+      if (target.startsWith("%")) {
+        const dead = paneStatus.byPaneId.get(target);
+        return dead !== void 0 && dead !== "1";
+      }
+      const sessions = this.listSessionsCached();
+      if (!sessions.includes(target)) return false;
+      const paneDeaths = paneStatus.bySession.get(target);
+      if (!paneDeaths || paneDeaths.length === 0) return true;
+      return paneDeaths.some((dead) => dead !== "1");
+    } catch {
+      return false;
+    }
+  }
+  sendKeys(target, keys) {
+    execFileSync("tmux", ["send-keys", "-t", target, keys], QUIET);
+    execFileSync("tmux", ["send-keys", "-t", target, "Enter"], QUIET);
+  }
+  /**
+   * Send text as literal characters, then submit with Enter as a separate call.
+   * Fixes Codex intercom bug: long text + Enter in one send-keys blast causes
+   * Codex to drop the Enter. Splitting them ensures the text renders before
+   * the submit keystroke arrives.
+   */
+  sendKeysLiteral(target, text) {
+    if (text.length >= LONG_MESSAGE_THRESHOLD) {
+      const tmpDir = path.join(os.tmpdir(), "exe-os-intercom");
+      mkdirSync(tmpDir, { recursive: true });
+      const tmpFile = path.join(tmpDir, `msg-${randomBytes(8).toString("hex")}.txt`);
+      try {
+        writeFileSync(tmpFile, text, "utf-8");
+        execFileSync("tmux", ["load-buffer", tmpFile], QUIET);
+        execFileSync("tmux", ["paste-buffer", "-p", "-t", target], QUIET);
+        execFileSync("tmux", ["send-keys", "-t", target, "Enter"], QUIET);
+      } finally {
+        try {
+          unlinkSync(tmpFile);
+        } catch {
+        }
+      }
+    } else {
+      execFileSync("tmux", ["send-keys", "-t", target, "-l", text], QUIET);
+      execFileSync("tmux", ["send-keys", "-t", target, "Enter"], QUIET);
+    }
+  }
+  capturePane(target, lines) {
+    const args = ["capture-pane", "-t", target, "-p"];
+    if (lines) args.push("-S", `-${lines}`);
+    return execFileSync("tmux", args, QUIET);
+  }
+  isPaneInCopyMode(target) {
+    try {
+      const result = execFileSync(
+        "tmux",
+        ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
+        QUIET
+      ).trim();
+      return result === "1";
+    } catch {
+      return false;
+    }
+  }
+  spawn(name, config) {
+    try {
+      const args = ["new-session", "-d", "-s", name, "-x", "200", "-y", "50"];
+      if (config.cwd) args.push("-c", config.cwd);
+      execFileSync("tmux", args);
+      execFileSync("tmux", ["send-keys", "-t", name, config.command, "Enter"]);
+      this.invalidateCaches();
+      return { sessionName: name };
+    } catch (e) {
+      return { sessionName: name, error: `spawn failed: ${e}` };
+    }
+  }
+  kill(target) {
+    const callerSession = this.getMySession();
+    if (callerSession && target.includes("-")) {
+      const targetScope = target.slice(target.lastIndexOf("-") + 1);
+      const callerScope = callerSession.includes("-") ? callerSession.slice(callerSession.lastIndexOf("-") + 1) : callerSession;
+      if (targetScope !== callerScope) {
+        process.stderr.write(
+          `[tmux-transport] BLOCKED kill: ${callerSession} tried to kill ${target} (scope ${targetScope} \u2260 ${callerScope}). Session isolation enforced.
+`
+        );
+        return;
+      }
+    }
+    try {
+      execFileSync("tmux", ["kill-session", "-t", target], QUIET);
+    } catch {
+    }
+    this.invalidateCaches();
+  }
+  pipeLog(target, logFile) {
+    try {
+      const resolved = path.resolve(logFile);
+      const logsDir = path.join(os.homedir(), ".exe-os", "session-logs");
+      if (!resolved.startsWith(logsDir)) {
+        process.stderr.write(`[tmux-transport] pipeLog rejected: path escapes session-logs dir: ${logFile}
+`);
+        return;
+      }
+      const safePath = logFile.replace(/'/g, "'\\''");
+      execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
+    } catch {
+    }
+  }
+};
+
+export {
+  TmuxTransport
+};

package/dist/chunk-PRKVT4KN.js

@@ -0,0 +1,90 @@
+import {
+  matchToolPattern
+} from "./chunk-HF25XPZE.js";
+
+// src/runtime/external-agent-mode.ts
+var HARD_BLOCKED_TOOLS = /* @__PURE__ */ new Set([
+  "Bash",
+  "Write",
+  "Edit",
+  "Glob",
+  "Grep",
+  "Read",
+  "Agent",
+  "NotebookEdit"
+]);
+var BLOCKED_TOOL_PATTERNS = [
+  /^mcp__.*git/i,
+  /^mcp__.*exec/i,
+  /^mcp__.*shell/i,
+  /^mcp__.*process/i,
+  /^mcp__.*file/i
+];
+function checkExternalAgentPermission(toolName, config) {
+  if (HARD_BLOCKED_TOOLS.has(toolName)) {
+    return `DENIED: "${toolName}" is hard-blocked for customer-facing agents`;
+  }
+  for (const pattern of BLOCKED_TOOL_PATTERNS) {
+    if (pattern.test(toolName)) {
+      return `DENIED: "${toolName}" matches blocked pattern for customer-facing agents`;
+    }
+  }
+  if (!config.allowedTools.includes(toolName)) {
+    return `DENIED: "${toolName}" is not in the external agent tool whitelist`;
+  }
+  return null;
+}
+
+// src/runtime/permissions.ts
+function checkPermission(toolName, permissions, externalAgentConfig) {
+  if (externalAgentConfig) {
+    const denyReason = checkExternalAgentPermission(toolName, externalAgentConfig);
+    if (denyReason) {
+      return { allowed: false, mode: "deny", reason: denyReason };
+    }
+  }
+  const mode = permissions.overrides[toolName] ?? permissions.defaultMode;
+  if (mode === "auto-approve") {
+    return { allowed: true, mode };
+  }
+  if (mode === "deny") {
+    return { allowed: false, mode, reason: `Tool "${toolName}" is denied by permission policy` };
+  }
+  return { allowed: false, mode, reason: `Tool "${toolName}" requires approval` };
+}
+var EMPLOYEE_PERMISSIONS = {
+  defaultMode: "auto-approve",
+  overrides: {}
+};
+function createRestrictedPermissions(allowedTools) {
+  const overrides = {};
+  for (const tool of allowedTools) {
+    overrides[tool] = "auto-approve";
+  }
+  return { defaultMode: "deny", overrides };
+}
+function createPermissionsFromPreset(preset, toolNames) {
+  const modeMap = {
+    allow: "auto-approve",
+    deny: "deny",
+    ask: "ask"
+  };
+  const defaultMode = modeMap[preset.defaultMode] ?? "deny";
+  const overrides = {};
+  for (const rule of preset.rules) {
+    if (rule.pattern) continue;
+    for (const name of toolNames) {
+      if (matchToolPattern(name, rule.tool)) {
+        overrides[name] = modeMap[rule.decision] ?? "deny";
+      }
+    }
+  }
+  return { defaultMode, overrides };
+}
+
+export {
+  checkPermission,
+  EMPLOYEE_PERMISSIONS,
+  createRestrictedPermissions,
+  createPermissionsFromPreset
+};