@askexenow/exe-os 0.9.288 → 0.9.290

package/dist/chunk-TO5ZXGDF.js

@@ -0,0 +1,190 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-5P3HOBZX.js";
+
+// src/lib/memory-queue.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  unlinkSync,
+  existsSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+import crypto from "crypto";
+var QUEUE_PATH = path.join(EXE_AI_DIR, "memory-queue.jsonl");
+var PROCESSING_PATH = QUEUE_PATH + ".processing";
+var PROCESSING_PREFIX = path.basename(PROCESSING_PATH);
+var TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_STALE_LEASE_MS = 5 * 60 * 1e3;
+function enqueueMemory(entry) {
+  mkdirSync(path.dirname(QUEUE_PATH), { recursive: true });
+  appendFileSync(QUEUE_PATH, JSON.stringify(entry) + "\n");
+}
+function claimQueue(options = {}) {
+  const staleLeaseMs = options.staleLeaseMs ?? DEFAULT_STALE_LEASE_MS;
+  const staleLease = claimStaleLease(staleLeaseMs);
+  if (staleLease) return staleLease;
+  if (!existsSync(QUEUE_PATH)) return null;
+  try {
+    const stat = statSync(QUEUE_PATH);
+    if (stat.size === 0) {
+      try {
+        unlinkSync(QUEUE_PATH);
+      } catch {
+      }
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const leasePath = newLeasePath();
+  try {
+    renameSync(QUEUE_PATH, leasePath);
+  } catch {
+    return null;
+  }
+  const entries = parseQueueFile(leasePath);
+  if (entries.length === 0) {
+    try {
+      unlinkSync(leasePath);
+    } catch {
+    }
+    return null;
+  }
+  return { leasePath, entries };
+}
+function ackQueue(leasePath) {
+  assertQueueLeasePath(leasePath);
+  try {
+    unlinkSync(leasePath);
+  } catch {
+  }
+}
+function retryQueueEntries(leasePath, entries) {
+  assertQueueLeasePath(leasePath);
+  if (entries.length === 0) {
+    ackQueue(leasePath);
+    return;
+  }
+  writeFileSync(leasePath, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+}
+function drainQueue() {
+  const entries = [];
+  while (true) {
+    const lease = claimQueue({ staleLeaseMs: 0 });
+    if (!lease) break;
+    entries.push(...lease.entries);
+    ackQueue(lease.leasePath);
+  }
+  return entries;
+}
+function queueDepth() {
+  const queueFiles = [QUEUE_PATH, ...listLeasePaths()];
+  let count = 0;
+  for (const filePath of queueFiles) {
+    if (!existsSync(filePath)) continue;
+    try {
+      const content = readFileSync(filePath, "utf8");
+      count += content.split("\n").filter((line) => line.trim().length > 0).length;
+    } catch {
+    }
+  }
+  return count;
+}
+function newLeasePath() {
+  const unique = `${process.pid}.${Date.now()}.${crypto.randomBytes(6).toString("hex")}`;
+  return `${PROCESSING_PATH}.${unique}`;
+}
+function listLeasePaths() {
+  const dir = path.dirname(QUEUE_PATH);
+  const files = [];
+  try {
+    for (const name of readdirSync(dir)) {
+      if (name === PROCESSING_PREFIX || name.startsWith(`${PROCESSING_PREFIX}.`)) {
+        files.push(path.join(dir, name));
+      }
+    }
+  } catch {
+  }
+  return files.sort();
+}
+function claimStaleLease(staleLeaseMs) {
+  const now = Date.now();
+  for (const existingLeasePath of listLeasePaths()) {
+    let stat;
+    try {
+      stat = statSync(existingLeasePath);
+    } catch {
+      continue;
+    }
+    const ageMs = Math.max(0, now - stat.mtimeMs);
+    if (ageMs < staleLeaseMs) continue;
+    let leasePath = existingLeasePath;
+    if (path.basename(existingLeasePath) === PROCESSING_PREFIX) {
+      leasePath = newLeasePath();
+      try {
+        renameSync(existingLeasePath, leasePath);
+      } catch {
+        continue;
+      }
+    }
+    const entries = parseQueueFile(leasePath);
+    if (entries.length === 0) {
+      try {
+        unlinkSync(leasePath);
+      } catch {
+      }
+      continue;
+    }
+    return { leasePath, entries };
+  }
+  return null;
+}
+function assertQueueLeasePath(leasePath) {
+  const resolved = path.resolve(leasePath);
+  const dir = path.resolve(path.dirname(QUEUE_PATH));
+  const base = path.basename(resolved);
+  if (path.dirname(resolved) !== dir || base !== PROCESSING_PREFIX && !base.startsWith(`${PROCESSING_PREFIX}.`)) {
+    throw new Error(`Refusing to operate on non-memory-queue lease path: ${leasePath}`);
+  }
+}
+function parseQueueFile(filePath) {
+  const now = Date.now();
+  const entries = [];
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return entries;
+  }
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.timestamp) {
+        const age = now - new Date(entry.timestamp).getTime();
+        if (age > TTL_MS) continue;
+      }
+      entries.push(entry);
+    } catch {
+      process.stderr.write(`[memory-queue] Skipping corrupt line: ${trimmed.slice(0, 80)}
+`);
+    }
+  }
+  return entries;
+}
+
+export {
+  enqueueMemory,
+  claimQueue,
+  ackQueue,
+  retryQueueEntries,
+  drainQueue,
+  queueDepth
+};

package/dist/chunk-TQZABASE.js

@@ -0,0 +1,97 @@
+import {
+  loadEmployeesSync
+} from "./chunk-DBQ6I6K2.js";
+
+// src/adapters/mcp-http-config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var DEFAULT_MCP_HTTP_PORT = "48739";
+function resolveDefaultAgentId() {
+  if (process.env.AGENT_ID && process.env.AGENT_ID !== "default") return process.env.AGENT_ID;
+  try {
+    const coo = loadEmployeesSync().find((e) => e.role === "COO");
+    if (coo) return coo.name;
+  } catch {
+  }
+  return "exe";
+}
+var DEFAULT_MCP_HTTP_AGENT_ID = resolveDefaultAgentId();
+var DEFAULT_MCP_HTTP_AGENT_ROLE = "COO";
+function mcpHttpPort() {
+  const raw = process.env.EXE_MCP_PORT?.trim();
+  if (!raw) return DEFAULT_MCP_HTTP_PORT;
+  if (!/^\d+$/.test(raw)) return DEFAULT_MCP_HTTP_PORT;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return DEFAULT_MCP_HTTP_PORT;
+  return raw;
+}
+function mcpHttpUrl() {
+  return `http://127.0.0.1:${mcpHttpPort()}/mcp`;
+}
+function readOrCreateDaemonToken(homeDir = os.homedir()) {
+  const exeDir = path.join(homeDir, ".exe-os");
+  const tokenPath = path.join(exeDir, "exed.token");
+  if (existsSync(tokenPath)) {
+    try {
+      const token2 = readFileSync(tokenPath, "utf-8").trim();
+      if (/^[a-f0-9]{64}$/i.test(token2)) return token2;
+    } catch {
+    }
+  }
+  const token = randomBytes(32).toString("hex");
+  mkdirSync(exeDir, { recursive: true });
+  writeFileSync(tokenPath, `${token}
+`, "utf-8");
+  try {
+    chmodSync(tokenPath, 384);
+  } catch {
+  }
+  return token;
+}
+function buildMcpHttpHeaders(homeDir = os.homedir(), opts = {}) {
+  const agentId = opts.useShellPlaceholders ? "${AGENT_ID:-exe}" : opts.agentId ?? DEFAULT_MCP_HTTP_AGENT_ID;
+  const agentRole = opts.useShellPlaceholders ? "${AGENT_ROLE:-COO}" : opts.agentRole ?? DEFAULT_MCP_HTTP_AGENT_ROLE;
+  let sessionName = process.env.EXE_SESSION_NAME ?? "";
+  if (!sessionName && !opts.useShellPlaceholders) {
+    try {
+      const sock = process.env.EXE_TMUX_SOCKET;
+      const tmuxArgs = sock ? ["-L", sock, "display-message", "-p", "#{session_name}"] : ["display-message", "-p", "#{session_name}"];
+      const tmuxSession = execFileSync("tmux", tmuxArgs, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      if (tmuxSession) sessionName = tmuxSession;
+    } catch {
+    }
+  }
+  const headers = {
+    Authorization: `Bearer ${readOrCreateDaemonToken(homeDir)}`,
+    "X-Agent-Id": agentId,
+    "X-Agent-Role": agentRole
+  };
+  if (sessionName && !opts.useShellPlaceholders) headers["X-Exe-Session"] = sessionName;
+  return headers;
+}
+function buildClaudeHttpMcpEntry(homeDir = os.homedir()) {
+  const entry = {
+    type: "http",
+    url: mcpHttpUrl(),
+    headers: buildMcpHttpHeaders(homeDir, { useShellPlaceholders: true })
+  };
+  delete entry.headers["X-Exe-Session"];
+  return entry;
+}
+
+export {
+  DEFAULT_MCP_HTTP_PORT,
+  DEFAULT_MCP_HTTP_AGENT_ID,
+  DEFAULT_MCP_HTTP_AGENT_ROLE,
+  mcpHttpPort,
+  mcpHttpUrl,
+  readOrCreateDaemonToken,
+  buildMcpHttpHeaders,
+  buildClaudeHttpMcpEntry
+};