@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-MLXJ5EZG.js

@@ -0,0 +1,90 @@
+// src/lib/dispatch-ack.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "fs";
+import path from "path";
+import os from "os";
+var ACK_DIR = path.join(os.homedir(), ".exe-os", "dispatch-acks");
+function ensureAckDir() {
+  if (!existsSync(ACK_DIR)) mkdirSync(ACK_DIR, { recursive: true });
+}
+function writeDispatchPending(taskId, assignedTo, sessionName) {
+  ensureAckDir();
+  const signal = {
+    taskId,
+    assignedTo,
+    dispatchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionName
+  };
+  writeFileSync(path.join(ACK_DIR, `${taskId}.pending`), JSON.stringify(signal), "utf-8");
+}
+function writeDispatchAck(taskId, agentId) {
+  ensureAckDir();
+  const pendingPath = path.join(ACK_DIR, `${taskId}.pending`);
+  const ackPath = path.join(ACK_DIR, `${taskId}.ack`);
+  let signal;
+  try {
+    signal = JSON.parse(readFileSync(pendingPath, "utf-8"));
+  } catch {
+    signal = { taskId, assignedTo: agentId, dispatchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  signal.ackedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(ackPath, JSON.stringify(signal), "utf-8");
+  try {
+    unlinkSync(pendingPath);
+  } catch {
+  }
+}
+function checkDispatchStatus(taskId) {
+  ensureAckDir();
+  const ackPath = path.join(ACK_DIR, `${taskId}.ack`);
+  const pendingPath = path.join(ACK_DIR, `${taskId}.pending`);
+  if (existsSync(ackPath)) {
+    try {
+      const signal = JSON.parse(readFileSync(ackPath, "utf-8"));
+      return { status: "acked", signal };
+    } catch {
+      return { status: "acked" };
+    }
+  }
+  if (existsSync(pendingPath)) {
+    try {
+      const signal = JSON.parse(readFileSync(pendingPath, "utf-8"));
+      return { status: "pending", signal };
+    } catch {
+      return { status: "pending" };
+    }
+  }
+  return { status: "unknown" };
+}
+function cleanStaleDispatchAcks(maxAgeMs = 60 * 60 * 1e3) {
+  ensureAckDir();
+  const now = Date.now();
+  let cleaned = 0;
+  try {
+    for (const file of readdirSync(ACK_DIR)) {
+      const fullPath = path.join(ACK_DIR, file);
+      try {
+        const signal = JSON.parse(readFileSync(fullPath, "utf-8"));
+        const ts = signal.ackedAt ?? signal.dispatchedAt;
+        if (now - new Date(ts).getTime() > maxAgeMs) {
+          unlinkSync(fullPath);
+          cleaned++;
+        }
+      } catch {
+        try {
+          unlinkSync(fullPath);
+          cleaned++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+
+export {
+  writeDispatchPending,
+  writeDispatchAck,
+  checkDispatchStatus,
+  cleanStaleDispatchAcks
+};

package/dist/chunk-MP2AFCGL.js

@@ -0,0 +1,53 @@
+// src/lib/state-bus.ts
+var StateBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  globalHandlers = /* @__PURE__ */ new Set();
+  /** Emit an event to all subscribers */
+  emit(event) {
+    const typeHandlers = this.handlers.get(event.type);
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        try {
+          handler(event);
+        } catch {
+        }
+      }
+    }
+    for (const handler of this.globalHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to a specific event type */
+  on(type, handler) {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(type).add(handler);
+  }
+  /** Subscribe to ALL events */
+  onAny(handler) {
+    this.globalHandlers.add(handler);
+  }
+  /** Unsubscribe from a specific event type */
+  off(type, handler) {
+    this.handlers.get(type)?.delete(handler);
+  }
+  /** Unsubscribe from ALL events */
+  offAny(handler) {
+    this.globalHandlers.delete(handler);
+  }
+  /** Remove all listeners */
+  clear() {
+    this.handlers.clear();
+    this.globalHandlers.clear();
+  }
+};
+var orgBus = new StateBus();
+
+export {
+  StateBus,
+  orgBus
+};

package/dist/chunk-MSCB4ACU.js

@@ -0,0 +1,356 @@
+import {
+  extractMemoryGraph
+} from "./chunk-36DAY227.js";
+import {
+  flushBatch,
+  writeMemory
+} from "./chunk-HTCBLSIB.js";
+import {
+  extractKeywords
+} from "./chunk-CHCA3ZM2.js";
+import {
+  getActiveAgent
+} from "./chunk-DLXTKVBO.js";
+
+// src/mcp/tools/import-conversations.ts
+import { z } from "zod";
+import crypto from "crypto";
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+
+// src/lib/conversation-parser.ts
+function detectFormat(content, filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".md") || lower.endsWith(".markdown")) return "markdown";
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) return "markdown";
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      const first = parsed[0];
+      if (first && typeof first === "object") {
+        if ("mapping" in first && typeof first.mapping === "object") return "chatgpt";
+        if ("chat_messages" in first) return "claude";
+        if ("uuid" in first && "name" in first) return "claude";
+      }
+    }
+    return "generic";
+  } catch {
+    return "markdown";
+  }
+}
+function extractChatGPTContent(node) {
+  const parts = node.message?.content?.parts;
+  if (!Array.isArray(parts)) return "";
+  return parts.filter((p) => typeof p === "string").join("\n").trim();
+}
+function parseChatGPT(content, sourceFile = "conversations.json") {
+  const data = JSON.parse(content);
+  if (!Array.isArray(data)) return [];
+  return data.map((conv) => {
+    const title = conv.title ?? "Untitled";
+    const messages = [];
+    if (conv.mapping) {
+      const nodes = Object.values(conv.mapping).filter((n) => n.message?.content?.parts && extractChatGPTContent(n).length > 0).sort((a, b) => (a.message?.create_time ?? 0) - (b.message?.create_time ?? 0));
+      for (const node of nodes) {
+        const role = node.message?.author?.role ?? "unknown";
+        const text = extractChatGPTContent(node);
+        if (!text) continue;
+        const createTime = node.message?.create_time;
+        messages.push({
+          role,
+          content: text,
+          timestamp: createTime ? new Date(createTime * 1e3).toISOString() : void 0
+        });
+      }
+    }
+    return { title, messages, sourceFile };
+  }).filter((c) => c.messages.length > 0);
+}
+function parseClaude(content, sourceFile = "conversations.json") {
+  const data = JSON.parse(content);
+  if (!Array.isArray(data)) return [];
+  return data.map((conv) => {
+    const title = conv.name ?? conv.uuid ?? "Untitled";
+    const messages = [];
+    if (conv.chat_messages) {
+      for (const msg of conv.chat_messages) {
+        let text = msg.text ?? "";
+        if (!text && Array.isArray(msg.content)) {
+          text = msg.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+        }
+        if (!text.trim()) continue;
+        messages.push({
+          role: msg.sender ?? "unknown",
+          content: text.trim(),
+          timestamp: msg.created_at
+        });
+      }
+    }
+    return { title, messages, sourceFile };
+  }).filter((c) => c.messages.length > 0);
+}
+function parseGeneric(content, sourceFile = "conversations.json") {
+  const trimmed = content.trimStart();
+  try {
+    const data = JSON.parse(trimmed);
+    if (Array.isArray(data)) {
+      if (data.length > 0 && typeof data[0] === "object" && ("role" in data[0] || "content" in data[0])) {
+        const messages = data.map((msg) => ({
+          role: msg.role ?? "unknown",
+          content: (msg.content ?? msg.text ?? "").trim(),
+          timestamp: msg.timestamp ?? msg.created_at
+        })).filter((m) => m.content.length > 0);
+        if (messages.length > 0) {
+          return [{ title: sourceFile, messages, sourceFile }];
+        }
+      }
+    }
+  } catch {
+  }
+  return parseMarkdown(content, sourceFile);
+}
+function parseMarkdown(content, sourceFile = "conversation.md") {
+  const lines = content.split("\n");
+  const conversations = [];
+  let currentTitle = sourceFile;
+  let currentMessages = [];
+  let currentRole = "user";
+  let currentContent = [];
+  function flushMessage() {
+    const text = currentContent.join("\n").trim();
+    if (text) {
+      currentMessages.push({ role: currentRole, content: text });
+    }
+    currentContent = [];
+  }
+  function flushConversation() {
+    flushMessage();
+    if (currentMessages.length > 0) {
+      conversations.push({ title: currentTitle, messages: [...currentMessages], sourceFile });
+    }
+    currentMessages = [];
+  }
+  for (const line of lines) {
+    const h1Match = line.match(/^# (.+)$/);
+    if (h1Match) {
+      flushConversation();
+      currentTitle = h1Match[1];
+      continue;
+    }
+    const roleMatch = line.match(/^(?:##\s+|\*\*)(user|assistant|human|system|ai|claude|gpt)(?:\*\*)?:?\s*/i);
+    if (roleMatch) {
+      flushMessage();
+      const raw = roleMatch[1].toLowerCase();
+      currentRole = raw === "human" || raw === "user" ? "user" : raw === "assistant" || raw === "ai" || raw === "claude" || raw === "gpt" ? "assistant" : raw;
+      continue;
+    }
+    currentContent.push(line);
+  }
+  flushConversation();
+  return conversations;
+}
+function conversationsToMemories(convos, format = "generic") {
+  const memories = [];
+  for (const convo of convos) {
+    for (const msg of convo.messages) {
+      if (msg.content.length < 10) continue;
+      memories.push({
+        text: msg.content,
+        kind: "conversation",
+        metadata: {
+          source_type: "import",
+          source_format: format,
+          source_path: convo.sourceFile,
+          conversation_title: convo.title,
+          role: msg.role,
+          original_timestamp: msg.timestamp
+        }
+      });
+    }
+  }
+  return memories;
+}
+
+// src/mcp/tools/import-conversations.ts
+var DEFAULT_CAP = 5e4;
+var YIELD_INTERVAL = 50;
+async function readInputFiles(inputPath) {
+  const files = [];
+  const info = await stat(inputPath);
+  if (info.isDirectory()) {
+    const entries = await readdir(inputPath);
+    for (const entry of entries) {
+      const fullPath = path.join(inputPath, entry);
+      const entryStat = await stat(fullPath);
+      if (entryStat.isFile() && (entry.endsWith(".json") || entry.endsWith(".md") || entry.endsWith(".txt"))) {
+        files.push({ path: fullPath, content: await readFile(fullPath, "utf-8") });
+      }
+    }
+  } else {
+    files.push({ path: inputPath, content: await readFile(inputPath, "utf-8") });
+  }
+  return files;
+}
+function parseFile(content, filePath, requestedFormat) {
+  const format = requestedFormat && requestedFormat !== "auto" ? requestedFormat : detectFormat(content, filePath);
+  let conversations;
+  switch (format) {
+    case "chatgpt":
+      conversations = parseChatGPT(content, filePath);
+      break;
+    case "claude":
+      conversations = parseClaude(content, filePath);
+      break;
+    case "markdown":
+      conversations = parseMarkdown(content, filePath);
+      break;
+    case "generic":
+    default:
+      conversations = parseGeneric(content, filePath);
+      break;
+  }
+  return { format, conversations };
+}
+function registerImportConversations(server) {
+  server.registerTool(
+    "import_conversations",
+    {
+      title: "Import Conversations",
+      description: "Import ChatGPT, Claude, or generic conversation exports into memory. Parses, extracts keywords + graph entities, stores with proper metadata. Deduplicates via content_hash. Supports JSON, markdown, and directory input.",
+      inputSchema: {
+        path: z.string().describe("File or directory path to import"),
+        format: z.enum(["chatgpt", "claude", "generic", "markdown", "auto"]).default("auto").describe("Source format (default: auto-detect)"),
+        project_name: z.string().optional().describe("Project name for imported memories"),
+        dry_run: z.boolean().default(false).describe("Parse and report counts without storing"),
+        force: z.boolean().default(false).describe("Override 50K memory cap"),
+        agent_id: z.string().optional().describe("Agent to attribute memories to (default: current agent)")
+      }
+    },
+    async ({ path: inputPath, format: requestedFormat, project_name, dry_run, force, agent_id: overrideAgentId }) => {
+      const { agentId: currentAgentId, agentRole } = getActiveAgent();
+      const agentId = overrideAgentId ?? currentAgentId;
+      const projectName = project_name ?? "imported";
+      let files;
+      try {
+        files = await readInputFiles(inputPath);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error reading ${inputPath}: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
+      if (files.length === 0) {
+        return {
+          content: [{ type: "text", text: `No importable files found at ${inputPath}` }],
+          isError: true
+        };
+      }
+      const allMemories = [];
+      let conversationCount = 0;
+      const formatCounts = {};
+      for (const file of files) {
+        const { format, conversations } = parseFile(file.content, file.path, requestedFormat);
+        formatCounts[format] = (formatCounts[format] ?? 0) + conversations.length;
+        conversationCount += conversations.length;
+        const memories = conversationsToMemories(conversations, format);
+        allMemories.push(...memories);
+      }
+      if (allMemories.length > DEFAULT_CAP && !force) {
+        return {
+          content: [{
+            type: "text",
+            text: `Import would create ${allMemories.length} memories (cap: ${DEFAULT_CAP}). Use force=true to override. Files: ${files.length}, Conversations: ${conversationCount}`
+          }],
+          isError: true
+        };
+      }
+      if (dry_run) {
+        const formatSummary2 = Object.entries(formatCounts).map(([f, c]) => `${f}: ${c}`).join(", ");
+        return {
+          content: [{
+            type: "text",
+            text: `[DRY RUN] Would import:
+  Files: ${files.length}
+  Conversations: ${conversationCount} (${formatSummary2})
+  Memories: ${allMemories.length}
+  Agent: ${agentId}
+  Project: ${projectName}`
+          }]
+        };
+      }
+      let stored = 0;
+      let skipped = 0;
+      let errors = 0;
+      for (let i = 0; i < allMemories.length; i++) {
+        const memory = allMemories[i];
+        try {
+          const keywords = extractKeywords(memory.text);
+          const keywordsStr = keywords.length > 0 ? keywords.join(" ") : null;
+          let entities = null;
+          try {
+            const graph = extractMemoryGraph(memory.text, agentId, projectName, "import_conversations");
+            if (graph.entities.length > 0) {
+              entities = JSON.stringify(graph.entities.map((e) => e.name));
+            }
+          } catch {
+          }
+          const id = crypto.randomUUID();
+          await writeMemory({
+            id,
+            agent_id: agentId,
+            agent_role: agentRole,
+            session_id: process.env.SESSION_ID ?? "import",
+            timestamp: memory.metadata.original_timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+            tool_name: "import_conversations",
+            project_name: projectName,
+            has_error: false,
+            raw_text: memory.text,
+            vector: null,
+            // Backfill later
+            source_path: memory.metadata.source_path,
+            source_type: "import",
+            memory_type: "conversation",
+            tier: 3,
+            // Passive ingestion
+            importance: memory.metadata.role === "assistant" ? 5 : 4,
+            intent: "observation",
+            domain: projectName,
+            referenced_entities: entities,
+            keywords: keywordsStr,
+            valid_from: memory.metadata.original_timestamp ?? void 0
+          });
+          stored++;
+        } catch {
+          skipped++;
+        }
+        if ((i + 1) % YIELD_INTERVAL === 0) {
+          await flushBatch();
+          await new Promise((r) => setTimeout(r, 0));
+          if ((i + 1) % (YIELD_INTERVAL * 10) === 0) {
+            console.log(`[import] ${i + 1}/${allMemories.length} memories processed, ${stored} stored`);
+          }
+        }
+      }
+      await flushBatch();
+      const formatSummary = Object.entries(formatCounts).map(([f, c]) => `${f}: ${c}`).join(", ");
+      return {
+        content: [{
+          type: "text",
+          text: `Import complete.
+  Files: ${files.length}
+  Conversations: ${conversationCount} (${formatSummary})
+  Memories stored: ${stored}
+  Duplicates skipped: ${skipped}
+  Errors: ${errors}
+  Agent: ${agentId}
+  Project: ${projectName}`
+        }]
+      };
+    }
+  );
+}
+
+export {
+  registerImportConversations
+};

package/dist/chunk-MVW62NIZ.js

@@ -0,0 +1,20 @@
+import {
+  TmuxTransport
+} from "./chunk-OYNKIAVW.js";
+
+// src/lib/transport.ts
+var _transport = null;
+function getTransport() {
+  if (!_transport) {
+    _transport = new TmuxTransport();
+  }
+  return _transport;
+}
+function setTransport(t) {
+  _transport = t;
+}
+
+export {
+  getTransport,
+  setTransport
+};

package/dist/chunk-MZIGUUDQ.js

@@ -0,0 +1,42 @@
+// src/lib/update-check.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+function getLocalVersion(packageRoot) {
+  const pkgPath = path.join(packageRoot, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return pkg.version;
+}
+function getRemoteVersion() {
+  try {
+    const output = execSync("npm view @askexenow/exe-os version", {
+      encoding: "utf-8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+function checkForUpdate(packageRoot) {
+  const localVersion = getLocalVersion(packageRoot);
+  const remoteVersion = getRemoteVersion();
+  if (!remoteVersion) {
+    return {
+      updateAvailable: false,
+      localVersion,
+      error: "Could not reach npm registry or package not published yet"
+    };
+  }
+  if (remoteVersion === localVersion) {
+    return { updateAvailable: false, localVersion, remoteVersion };
+  }
+  return { updateAvailable: true, localVersion, remoteVersion };
+}
+
+export {
+  getLocalVersion,
+  getRemoteVersion,
+  checkForUpdate
+};

package/dist/chunk-N5RRQOAC.js

@@ -0,0 +1,134 @@
+// src/gateway/adapters/discord.ts
+var DiscordAdapter = class {
+  platform = "discord";
+  client = null;
+  messageHandler = null;
+  connected = false;
+  async connect(config) {
+    const { Client, GatewayIntentBits } = await import("discord.js");
+    const token = config.credentials.bot_token ?? config.credentials.token;
+    if (!token) {
+      throw new Error("Discord requires bot_token in credentials");
+    }
+    const discordClient = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages
+      ]
+    });
+    this.client = discordClient;
+    discordClient.on("ready", () => {
+      this.connected = true;
+      console.log(`[discord] Connected as ${this.client?.user?.tag}`);
+    });
+    discordClient.on("messageCreate", async (msg) => {
+      const m = msg;
+      if (!this.messageHandler) return;
+      if (m.author.bot) return;
+      const isGroup = m.guild !== null;
+      const media = this.extractMedia(m);
+      const normalized = {
+        messageId: m.id,
+        platform: "discord",
+        senderId: m.author.id,
+        senderName: m.author.username,
+        channelId: m.channelId,
+        chatType: isGroup ? "group" : "direct",
+        text: m.content ?? "",
+        timestamp: m.createdAt.toISOString(),
+        threadId: m.thread?.id ?? (m.channel.isThread?.() ? m.channelId : void 0),
+        replyTo: m.reference ? {
+          messageId: m.reference.messageId ?? "",
+          text: "",
+          senderId: ""
+        } : void 0,
+        media,
+        raw: m
+      };
+      try {
+        await this.messageHandler(normalized);
+      } catch (err) {
+        console.error("[discord] Message handler error:", err);
+      }
+    });
+    await discordClient.login(token);
+  }
+  async disconnect() {
+    await this.client?.destroy();
+    this.client = null;
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async sendText(channelId, text, options) {
+    if (!this.client || !this.connected) throw new Error("Discord not connected");
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel || !channel.send) {
+      throw new Error(`Discord channel ${channelId} not found or not text-based`);
+    }
+    await channel.send({
+      content: text,
+      ...options?.replyToMessageId ? { reply: { messageReference: options.replyToMessageId } } : {}
+    });
+  }
+  async sendTyping(channelId) {
+    if (!this.client || !this.connected) return;
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (channel?.sendTyping) {
+        await channel.sendTyping();
+      }
+    } catch {
+    }
+  }
+  async healthCheck() {
+    if (!this.client) return { connected: false };
+    return {
+      connected: this.connected,
+      latencyMs: (this.client.ws?.ping ?? -1) >= 0 ? this.client.ws.ping : void 0
+    };
+  }
+  /** Inject a raw Discord message payload from webhook server */
+  async injectMessage(rawPayload) {
+    if (!this.messageHandler) return;
+    const msg = rawPayload;
+    if (!msg.id || msg.author?.bot) return;
+    const isGroup = !!msg.guild_id;
+    const normalized = {
+      messageId: msg.id,
+      platform: "discord",
+      senderId: msg.author?.id ?? "",
+      senderName: msg.author?.username,
+      channelId: msg.channel_id ?? "",
+      chatType: isGroup ? "group" : "direct",
+      text: msg.content ?? "",
+      timestamp: msg.timestamp ? new Date(msg.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      raw: rawPayload
+    };
+    try {
+      await this.messageHandler(normalized);
+    } catch (err) {
+      console.error("[discord] injectMessage handler error:", err);
+    }
+  }
+  extractMedia(msg) {
+    if (!msg.attachments?.size) return void 0;
+    const media = [];
+    for (const [, att] of msg.attachments) {
+      const ct = att.contentType ?? "";
+      let type = "document";
+      if (ct.startsWith("image/")) type = "image";
+      else if (ct.startsWith("video/")) type = "video";
+      else if (ct.startsWith("audio/")) type = "audio";
+      media.push({ type, url: att.url, fileName: att.name ?? void 0 });
+    }
+    return media.length > 0 ? media : void 0;
+  }
+};
+
+export {
+  DiscordAdapter
+};