@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-NDYSNVI5.js

@@ -0,0 +1,122 @@
+import {
+  EXE_AI_DIR,
+  init_config
+} from "./chunk-KVPG5UT6.js";
+import {
+  __esm,
+  __export
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/db-backup.ts
+var db_backup_exports = {};
+__export(db_backup_exports, {
+  createBackup: () => createBackup,
+  findActiveDb: () => findActiveDb,
+  getBackupDir: () => getBackupDir,
+  getLatestBackup: () => getLatestBackup,
+  hasBackupToday: () => hasBackupToday,
+  listBackups: () => listBackups,
+  rotateBackups: () => rotateBackups
+});
+import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
+import path from "path";
+function findActiveDb() {
+  for (const name of DB_NAMES) {
+    const p = path.join(EXE_AI_DIR, name);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+function createBackup(reason = "manual") {
+  const dbPath = findActiveDb();
+  if (!dbPath) return null;
+  mkdirSync(BACKUP_DIR, { recursive: true });
+  const dbName = path.basename(dbPath, ".db");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupName = `${dbName}-${reason}-${timestamp}.db`;
+  const backupPath = path.join(BACKUP_DIR, backupName);
+  copyFileSync(dbPath, backupPath);
+  const walPath = dbPath + "-wal";
+  if (existsSync(walPath)) {
+    try {
+      copyFileSync(walPath, backupPath + "-wal");
+    } catch {
+    }
+  }
+  const shmPath = dbPath + "-shm";
+  if (existsSync(shmPath)) {
+    try {
+      copyFileSync(shmPath, backupPath + "-shm");
+    } catch {
+    }
+  }
+  return backupPath;
+}
+function rotateBackups(keepDays = DEFAULT_KEEP_DAYS) {
+  if (!existsSync(BACKUP_DIR)) return 0;
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1e3;
+  let deleted = 0;
+  try {
+    const files = readdirSync(BACKUP_DIR);
+    for (const file of files) {
+      if (!file.endsWith(".db") && !file.endsWith(".db-wal") && !file.endsWith(".db-shm")) continue;
+      const filePath = path.join(BACKUP_DIR, file);
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtimeMs < cutoff) {
+          unlinkSync(filePath);
+          deleted++;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return deleted;
+}
+function listBackups() {
+  if (!existsSync(BACKUP_DIR)) return [];
+  try {
+    const files = readdirSync(BACKUP_DIR).filter((f) => f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm"));
+    return files.map((name) => {
+      const p = path.join(BACKUP_DIR, name);
+      const stat = statSync(p);
+      return { path: p, name, size: stat.size, date: stat.mtime };
+    }).sort((a, b) => b.date.getTime() - a.date.getTime());
+  } catch {
+    return [];
+  }
+}
+function hasBackupToday(reason) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const backups = listBackups();
+  return backups.some((b) => b.name.includes(reason) && b.name.includes(today.replace(/-/g, "-")));
+}
+function getLatestBackup() {
+  const backups = listBackups();
+  return backups.length > 0 ? backups[0].path : null;
+}
+function getBackupDir() {
+  return BACKUP_DIR;
+}
+var BACKUP_DIR, DEFAULT_KEEP_DAYS, DB_NAMES;
+var init_db_backup = __esm({
+  "src/lib/db-backup.ts"() {
+    init_config();
+    BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
+    DEFAULT_KEEP_DAYS = 3;
+    DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
+  }
+});
+
+export {
+  findActiveDb,
+  createBackup,
+  rotateBackups,
+  listBackups,
+  hasBackupToday,
+  getLatestBackup,
+  getBackupDir,
+  db_backup_exports,
+  init_db_backup
+};

package/dist/chunk-NEAHEC5G.js

@@ -0,0 +1,155 @@
+import {
+  __esm,
+  __export,
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/intercom-queue.ts
+var intercom_queue_exports = {};
+__export(intercom_queue_exports, {
+  _resetDrainGuard: () => _resetDrainGuard,
+  clearQueueForAgent: () => clearQueueForAgent,
+  drainForSession: () => drainForSession,
+  drainQueue: () => drainQueue,
+  queueIntercom: () => queueIntercom,
+  readQueue: () => readQueue
+});
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+function ensureDir() {
+  const dir = path.dirname(QUEUE_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function readQueue() {
+  try {
+    if (!existsSync(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync(QUEUE_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeQueue(queue) {
+  ensureDir();
+  const tmp = `${QUEUE_PATH}.tmp`;
+  writeFileSync(tmp, JSON.stringify(queue, null, 2), { mode: 384 });
+  renameSync(tmp, QUEUE_PATH);
+}
+function queueIntercom(targetSession, reason) {
+  const queue = readQueue();
+  const existing = queue.find((q) => q.targetSession === targetSession);
+  if (existing) {
+    existing.attempts++;
+    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    existing.reason = reason;
+  } else {
+    queue.push({
+      targetSession,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0,
+      reason
+    });
+  }
+  writeQueue(queue);
+}
+function drainQueue(isSessionBusy, sendKeys) {
+  if (_draining) {
+    logQueue("SKIP_DRAIN \u2014 previous drain still running (possible tmux hang)");
+    return { drained: 0, failed: 0 };
+  }
+  const queue = readQueue();
+  if (queue.length === 0) return { drained: 0, failed: 0 };
+  _draining = true;
+  const remaining = [];
+  let drained = 0;
+  let failed = 0;
+  try {
+    for (const item of queue) {
+      const age = Date.now() - new Date(item.queuedAt).getTime();
+      if (age > TTL_MS) {
+        logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      try {
+        if (!isSessionBusy(item.targetSession)) {
+          const success = sendKeys(item.targetSession);
+          if (success) {
+            logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
+            drained++;
+            continue;
+          }
+        }
+      } catch {
+      }
+      item.attempts++;
+      if (item.attempts >= MAX_RETRIES) {
+        logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES} retries exhausted, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      remaining.push(item);
+    }
+    writeQueue(remaining);
+  } finally {
+    _draining = false;
+  }
+  return { drained, failed };
+}
+function drainForSession(targetSession, sendKeys) {
+  const queue = readQueue();
+  const match = queue.findIndex((q) => q.targetSession === targetSession);
+  if (match < 0) return false;
+  const success = sendKeys(targetSession);
+  if (success) {
+    queue.splice(match, 1);
+    writeQueue(queue);
+    logQueue(`DRAINED \u2192 ${targetSession} (prompt-submit trigger)`);
+    return true;
+  }
+  return false;
+}
+function clearQueueForAgent(agentName) {
+  const queue = readQueue();
+  const before = queue.length;
+  const filtered = queue.filter((q) => !q.targetSession.startsWith(`${agentName}-`));
+  if (filtered.length < before) {
+    writeQueue(filtered);
+    logQueue(`CLEARED ${before - filtered.length} stale item(s) for ${agentName}`);
+  }
+}
+function _resetDrainGuard() {
+  _draining = false;
+}
+function logQueue(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [queue] ${msg}
+`;
+  process.stderr.write(`[intercom-queue] ${msg}
+`);
+  try {
+    const { appendFileSync } = __require("fs");
+    appendFileSync(INTERCOM_LOG, line);
+  } catch {
+  }
+}
+var QUEUE_PATH, MAX_RETRIES, TTL_MS, _draining, INTERCOM_LOG;
+var init_intercom_queue = __esm({
+  "src/lib/intercom-queue.ts"() {
+    QUEUE_PATH = path.join(os.homedir(), ".exe-os", "intercom-queue.json");
+    MAX_RETRIES = 5;
+    TTL_MS = 60 * 60 * 1e3;
+    _draining = false;
+    INTERCOM_LOG = path.join(os.homedir(), ".exe-os", "intercom.log");
+  }
+});
+
+export {
+  readQueue,
+  queueIntercom,
+  drainQueue,
+  drainForSession,
+  clearQueueForAgent,
+  _resetDrainGuard,
+  intercom_queue_exports,
+  init_intercom_queue
+};

package/dist/chunk-NGVOA6ZQ.js

@@ -0,0 +1,84 @@
+// src/runtime/safety-checks.ts
+import path from "path";
+import os from "os";
+var HOME = os.homedir();
+var BYPASS_IMMUNE_PATTERNS = [
+  {
+    pattern: /\/\.git\/hooks\//,
+    reason: "Git hooks can execute arbitrary code"
+  },
+  {
+    pattern: /\/\.git\/config$/,
+    reason: "Git config can set hooks and command execution"
+  },
+  {
+    pattern: (p) => p.startsWith(path.join(HOME, ".claude")),
+    reason: "Claude configuration files are protected"
+  },
+  {
+    pattern: (p) => p.startsWith(path.join(HOME, ".exe-os")),
+    reason: "exe-os configuration files are protected"
+  },
+  {
+    pattern: /\/\.env($|\.)/,
+    reason: "Environment files may contain secrets"
+  },
+  {
+    pattern: /\/(credentials|secrets|tokens)\.(json|yaml|yml|toml|ini|conf)$/i,
+    reason: "Credential files are protected"
+  },
+  {
+    pattern: /(\.pem|\.key|\.p12|\.pfx|\.jks|id_rsa|id_ed25519)$/,
+    reason: "Private key files are protected"
+  },
+  {
+    pattern: (p) => {
+      const name = path.basename(p);
+      return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
+    },
+    reason: "Shell configuration files can execute arbitrary code on login"
+  },
+  {
+    pattern: (p) => p.startsWith("/etc/"),
+    reason: "System configuration directory is protected"
+  },
+  {
+    pattern: (p) => p.startsWith("/usr/") && !p.startsWith("/usr/local/"),
+    reason: "System binary directory is protected"
+  },
+  {
+    pattern: (p) => p === "/" || p === HOME,
+    reason: "Root and home directory direct modification is protected"
+  }
+];
+function checkPathSafety(filePath) {
+  const resolved = path.resolve(filePath);
+  for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
+    const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
+    if (matches) {
+      return { safe: false, reason, bypassImmune: true };
+    }
+  }
+  return { safe: true, bypassImmune: true };
+}
+function containsPathTraversal(filePath) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(filePath);
+}
+function checkReadPathSafety(filePath) {
+  const resolved = path.resolve(filePath);
+  const credPatterns = BYPASS_IMMUNE_PATTERNS.filter(
+    (p) => typeof p.pattern !== "function" && (p.reason.includes("secrets") || p.reason.includes("Private key") || p.reason.includes("Credential"))
+  );
+  for (const { pattern, reason } of credPatterns) {
+    if (typeof pattern !== "function" && pattern.test(resolved)) {
+      return { safe: false, reason, bypassImmune: true };
+    }
+  }
+  return { safe: true, bypassImmune: true };
+}
+
+export {
+  checkPathSafety,
+  containsPathTraversal,
+  checkReadPathSafety
+};

package/dist/chunk-NHK5KW6Y.js

@@ -0,0 +1,193 @@
+// src/lib/memory-write-governor.ts
+import { createHash } from "crypto";
+var HIGH_VALUE_SUPERSESSION_TYPES = /* @__PURE__ */ new Set([
+  "decision",
+  "adr",
+  "behavior",
+  "procedure"
+]);
+var NOISE_DROP_PATTERNS = [
+  /^\s*\[📋\s+\d+\s+reviews?\s+pending\b/im,
+  /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\s*$/im,
+  /^\s*The UserPromptSubmit hook checks the DB for new tasks/im,
+  /^\s*Intercom is a speedup, not delivery/im,
+  /^\s*Context bar reads as USAGE not remaining/im
+];
+var SKIP_EMBED_PATTERNS = [
+  /tmux capture-pane\b/i,
+  /docker ps\b/i,
+  /docker images\b/i,
+  /git status\b/i,
+  /grep .*node_modules/i,
+  /npm (install|ci)\b[\s\S]*(added \d+ packages|audited \d+ packages)/i
+];
+function normalizeMemoryText(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").replace(/\n{4,}/g, "\n\n\n").trim();
+}
+function classifyMemoryType(input) {
+  if (input.memory_type && input.memory_type.trim()) return input.memory_type.trim();
+  const tool = input.tool_name.toLowerCase();
+  const text = input.raw_text.toLowerCase();
+  if (tool.includes("store_decision") || tool.includes("decision")) return "decision";
+  if (tool.includes("commit") || text.includes("adr-") || text.includes("architectural decision")) return "adr";
+  if (tool.includes("store_behavior") || tool.includes("behavior")) return "behavior";
+  if (tool.includes("global_procedure") || text.includes("organization-wide procedures")) return "procedure";
+  if (tool.includes("checkpoint") || text.startsWith("context checkpoint")) return "checkpoint";
+  if (tool.includes("sessionsummary") || tool.includes("session-summary")) return "summary";
+  if (tool.includes("sessionend") || text.startsWith("session ended")) return "summary";
+  if (tool.includes("send_whatsapp") || tool.includes("conversation")) return "conversation";
+  if (tool === "store_memory" || tool === "manual") return "observation";
+  return "raw";
+}
+function shouldDropMemory(text) {
+  const normalized = normalizeMemoryText(text);
+  if (normalized.length < 10) return { drop: true, reason: "too_short" };
+  if (NOISE_DROP_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { drop: true, reason: "known_boilerplate_noise" };
+  }
+  return { drop: false };
+}
+function shouldSkipEmbedding(input) {
+  const type = classifyMemoryType(input);
+  if (HIGH_VALUE_SUPERSESSION_TYPES.has(type)) return false;
+  if (type === "raw" && input.raw_text.length > 2e4) return true;
+  if (SKIP_EMBED_PATTERNS.some((pattern) => pattern.test(input.raw_text))) return true;
+  return false;
+}
+function hashMemoryContent(text) {
+  return createHash("sha256").update(normalizeMemoryText(text)).digest("hex");
+}
+function scopedDedupArgs(input) {
+  return [input.contentHash, input.agentId, input.projectName, input.memoryType];
+}
+function governMemoryRecord(record) {
+  const normalized = normalizeMemoryText(record.raw_text);
+  const memoryType = classifyMemoryType({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: record.memory_type
+  });
+  const drop = shouldDropMemory(normalized);
+  const skipEmbedding = shouldSkipEmbedding({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: memoryType
+  });
+  return {
+    record: {
+      ...record,
+      raw_text: normalized,
+      memory_type: memoryType,
+      vector: skipEmbedding ? null : record.vector
+    },
+    contentHash: hashMemoryContent(normalized),
+    shouldDrop: drop.drop,
+    dropReason: drop.reason,
+    skipEmbedding,
+    hygiene: {
+      dedup: true,
+      supersession: HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)
+    }
+  };
+}
+async function findScopedDuplicate(input) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const args = scopedDedupArgs(input);
+  let sql = `SELECT id FROM memories
+             WHERE content_hash = ?
+               AND agent_id = ?
+               AND project_name = ?
+               AND COALESCE(memory_type, 'raw') = ?
+               AND COALESCE(status, 'active') != 'deleted'`;
+  if (input.excludeId) {
+    sql += " AND id != ?";
+    args.push(input.excludeId);
+  }
+  sql += " ORDER BY timestamp DESC LIMIT 1";
+  const result = await client.execute({ sql, args });
+  return result.rows[0]?.id ? String(result.rows[0].id) : null;
+}
+async function runPostWriteMemoryHygiene(memoryId) {
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const current = await client.execute({
+      sql: `SELECT id, agent_id, project_name, memory_type, content_hash, supersedes_id,
+                   importance, timestamp
+            FROM memories
+            WHERE id = ?
+            LIMIT 1`,
+      args: [memoryId]
+    });
+    const row = current.rows[0];
+    if (!row) return;
+    const memoryType = String(row.memory_type ?? "raw");
+    const contentHash = row.content_hash ? String(row.content_hash) : null;
+    const agentId = String(row.agent_id);
+    const projectName = String(row.project_name);
+    if (contentHash) {
+      await client.execute({
+        sql: `UPDATE memories
+              SET status = 'deleted',
+                  outcome = COALESCE(outcome, 'superseded')
+              WHERE id != ?
+                AND content_hash = ?
+                AND agent_id = ?
+                AND project_name = ?
+                AND COALESCE(memory_type, 'raw') = ?
+                AND COALESCE(status, 'active') = 'active'`,
+        args: [memoryId, contentHash, agentId, projectName, memoryType]
+      });
+    }
+    const supersedesId = row.supersedes_id ? String(row.supersedes_id) : null;
+    if (supersedesId && HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)) {
+      const old = await client.execute({
+        sql: `SELECT importance FROM memories WHERE id = ? LIMIT 1`,
+        args: [supersedesId]
+      });
+      const oldImportance = Number(old.rows[0]?.importance ?? 0);
+      const newImportance = Number(row.importance ?? 0);
+      await client.batch([
+        {
+          sql: `UPDATE memories
+                SET status = 'archived',
+                    outcome = COALESCE(outcome, 'superseded')
+                WHERE id = ?`,
+          args: [supersedesId]
+        },
+        {
+          sql: `UPDATE memories
+                SET importance = MAX(COALESCE(importance, 5), ?),
+                    parent_memory_id = COALESCE(parent_memory_id, ?)
+                WHERE id = ?`,
+          args: [Math.max(oldImportance, newImportance), supersedesId, memoryId]
+        }
+      ], "write");
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[memory-governor] post-write hygiene failed for ${memoryId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function schedulePostWriteMemoryHygiene(memoryIds) {
+  if (process.env.EXE_SKIP_MEMORY_HYGIENE === "1") return;
+  if (memoryIds.length === 0) return;
+  const run = () => {
+    void Promise.all(memoryIds.map((id) => runPostWriteMemoryHygiene(id)));
+  };
+  if (typeof setImmediate === "function") setImmediate(run);
+  else setTimeout(run, 0);
+}
+
+export {
+  governMemoryRecord,
+  findScopedDuplicate,
+  schedulePostWriteMemoryHygiene
+};