@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-QGGH7LOU.js

@@ -0,0 +1,93 @@
+// src/lib/daemon-protocol.ts
+function serializeValue(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (v instanceof Uint8Array) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (ArrayBuffer.isView(v)) {
+    return { __blob: Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("base64") };
+  }
+  if (v instanceof ArrayBuffer) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (typeof v === "string" || typeof v === "number") return v;
+  return String(v);
+}
+function deserializeValue(v) {
+  if (v === null) return null;
+  if (typeof v === "object" && v !== null && "__blob" in v) {
+    const buf = Buffer.from(v.__blob, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  return v;
+}
+function serializeArgs(args) {
+  return args.map(serializeValue);
+}
+function deserializeArgs(args) {
+  return args.map(deserializeValue);
+}
+function serializeResultSet(rs) {
+  const rows = [];
+  for (const row of rs.rows) {
+    const obj = {};
+    for (let i = 0; i < rs.columns.length; i++) {
+      const col = rs.columns[i];
+      if (col !== void 0) {
+        obj[col] = serializeValue(row[i]);
+      }
+    }
+    rows.push(obj);
+  }
+  return {
+    columns: [...rs.columns],
+    columnTypes: [...rs.columnTypes ?? []],
+    rows,
+    rowsAffected: typeof rs.rowsAffected === "bigint" ? Number(rs.rowsAffected) : rs.rowsAffected ?? 0,
+    lastInsertRowid: rs.lastInsertRowid != null ? typeof rs.lastInsertRowid === "bigint" ? Number(rs.lastInsertRowid) : rs.lastInsertRowid : null
+  };
+}
+function deserializeResultSet(srs) {
+  const rows = srs.rows.map((obj) => {
+    const values = srs.columns.map(
+      (col) => deserializeValue(obj[col] ?? null)
+    );
+    const row = values;
+    for (let i = 0; i < srs.columns.length; i++) {
+      const col = srs.columns[i];
+      if (col !== void 0) {
+        row[col] = values[i] ?? null;
+      }
+    }
+    Object.defineProperty(row, "length", {
+      value: values.length,
+      enumerable: false
+    });
+    return row;
+  });
+  return {
+    columns: srs.columns,
+    columnTypes: srs.columnTypes ?? [],
+    rows,
+    rowsAffected: srs.rowsAffected,
+    lastInsertRowid: srs.lastInsertRowid != null ? BigInt(srs.lastInsertRowid) : void 0,
+    toJSON: () => ({
+      columns: srs.columns,
+      columnTypes: srs.columnTypes ?? [],
+      rows: srs.rows,
+      rowsAffected: srs.rowsAffected,
+      lastInsertRowid: srs.lastInsertRowid
+    })
+  };
+}
+
+export {
+  serializeValue,
+  deserializeValue,
+  serializeArgs,
+  deserializeArgs,
+  serializeResultSet,
+  deserializeResultSet
+};

package/dist/chunk-QHIGMP2M.js

@@ -0,0 +1,237 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-TNTFEWU5.js";
+
+// src/lib/db-backup.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
+import { copyFile, mkdir, unlink } from "fs/promises";
+import { execFileSync } from "child_process";
+import path from "path";
+var BACKUP_DIR = path.join(EXE_AI_DIR, "backups");
+var DEFAULT_KEEP_DAYS = 3;
+var DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
+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);
+  try {
+    execFileSync("sqlite3", [dbPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
+      timeout: 3e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    process.stderr.write(`[db-backup] WAL checkpoint skipped (sqlite3 CLI unavailable or encrypted DB)
+`);
+  }
+  copyFileSync(dbPath, backupPath);
+  try {
+    const result = execFileSync("sqlite3", [backupPath, "PRAGMA quick_check;"], {
+      encoding: "utf8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (result !== "ok") {
+      process.stderr.write(`[db-backup] WARNING: backup failed quick_check (${reason}): ${result}
+`);
+      try {
+        unlinkSync(backupPath);
+      } catch {
+      }
+      return null;
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[db-backup] Backup validation skipped: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  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;
+}
+async function createBackupAsync(reason = "manual") {
+  const dbPath = findActiveDb();
+  if (!dbPath) return null;
+  await mkdir(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);
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    await client.execute("PRAGMA wal_checkpoint(TRUNCATE)");
+  } catch {
+    try {
+      const { execFile: execFileCb } = await import("child_process");
+      const { promisify } = await import("util");
+      const execFileAsync = promisify(execFileCb);
+      await execFileAsync("sqlite3", [dbPath, "PRAGMA wal_checkpoint(TRUNCATE);"], { timeout: 3e4 });
+    } catch {
+      process.stderr.write(`[db-backup] WAL checkpoint skipped \u2014 proceeding with copy (backup may include stale WAL)
+`);
+    }
+  }
+  await copyFile(dbPath, backupPath);
+  try {
+    const { execFile } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFile);
+    const { stdout } = await execFileAsync("sqlite3", [backupPath, "PRAGMA quick_check;"], {
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    const result = String(stdout ?? "").trim();
+    if (result !== "ok") {
+      process.stderr.write(`[db-backup] WARNING: backup failed quick_check (${reason}): ${result}
+`);
+      try {
+        await unlink(backupPath);
+      } catch {
+      }
+      return null;
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[db-backup] Backup validation skipped: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  const walPath = dbPath + "-wal";
+  if (existsSync(walPath)) {
+    try {
+      await copyFile(walPath, backupPath + "-wal");
+    } catch {
+    }
+  }
+  const shmPath = dbPath + "-shm";
+  if (existsSync(shmPath)) {
+    try {
+      await copyFile(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 restoreBackup(backupPath) {
+  const dbPath = findActiveDb();
+  if (!dbPath) {
+    const target = path.join(EXE_AI_DIR, DB_NAMES[0]);
+    const source2 = backupPath ?? getLatestBackup();
+    if (!source2 || !existsSync(source2)) return null;
+    copyFileSync(source2, target);
+    return { restored: path.basename(source2), preRestoreBackup: null };
+  }
+  const source = backupPath ?? getLatestBackup();
+  if (!source || !existsSync(source)) return null;
+  if (path.resolve(source) === path.resolve(dbPath)) return null;
+  const preRestoreBackup = createBackup("pre-restore");
+  copyFileSync(source, dbPath);
+  const walPath = source + "-wal";
+  const shmPath = source + "-shm";
+  if (existsSync(walPath)) {
+    try {
+      copyFileSync(walPath, dbPath + "-wal");
+    } catch {
+    }
+  } else {
+    try {
+      unlinkSync(dbPath + "-wal");
+    } catch {
+    }
+  }
+  if (existsSync(shmPath)) {
+    try {
+      copyFileSync(shmPath, dbPath + "-shm");
+    } catch {
+    }
+  } else {
+    try {
+      unlinkSync(dbPath + "-shm");
+    } catch {
+    }
+  }
+  return { restored: path.basename(source), preRestoreBackup };
+}
+function getBackupDir() {
+  return BACKUP_DIR;
+}
+
+export {
+  findActiveDb,
+  createBackup,
+  createBackupAsync,
+  rotateBackups,
+  listBackups,
+  hasBackupToday,
+  getLatestBackup,
+  restoreBackup,
+  getBackupDir
+};

package/dist/chunk-QI4IXJN7.js

@@ -0,0 +1,132 @@
+// src/lib/intercom-queue.ts
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, appendFileSync } from "fs";
+import path from "path";
+import os from "os";
+var QUEUE_PATH = path.join(os.homedir(), ".exe-os", "intercom-queue.json");
+var MAX_RETRIES = 10;
+var TTL_MS = 60 * 60 * 1e3;
+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);
+}
+var _draining = false;
+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;
+}
+var INTERCOM_LOG = path.join(os.homedir(), ".exe-os", "intercom.log");
+function logQueue(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [queue] ${msg}
+`;
+  process.stderr.write(`[intercom-queue] ${msg}
+`);
+  try {
+    appendFileSync(INTERCOM_LOG, line);
+  } catch {
+  }
+}
+
+export {
+  readQueue,
+  queueIntercom,
+  drainQueue,
+  drainForSession,
+  clearQueueForAgent,
+  _resetDrainGuard
+};

package/dist/chunk-R2E4TV5V.js

@@ -0,0 +1,56 @@
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/reminders.ts
+import crypto from "crypto";
+async function createReminder(text, dueDate) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    sql: `INSERT INTO reminders (id, text, created_at, due_date) VALUES (?, ?, ?, ?)`,
+    args: [id, text, now, dueDate ?? null]
+  });
+  return { id, text, createdAt: now, dueDate: dueDate ?? null, completedAt: null };
+}
+async function listReminders(includeCompleted = false) {
+  const client = getClient();
+  const sql = includeCompleted ? `SELECT id, text, created_at, due_date, completed_at FROM reminders ORDER BY due_date ASC NULLS LAST LIMIT 500` : `SELECT id, text, created_at, due_date, completed_at FROM reminders WHERE completed_at IS NULL ORDER BY due_date ASC NULLS LAST LIMIT 500`;
+  const result = await client.execute(sql);
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    text: String(row.text),
+    createdAt: String(row.created_at),
+    dueDate: row.due_date ? String(row.due_date) : null,
+    completedAt: row.completed_at ? String(row.completed_at) : null
+  }));
+}
+async function completeReminder(idOrText) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let result = await client.execute({
+    sql: `SELECT id, text FROM reminders WHERE id = ? AND completed_at IS NULL`,
+    args: [idOrText]
+  });
+  if (result.rows.length === 0) {
+    result = await client.execute({
+      sql: `SELECT id, text FROM reminders WHERE completed_at IS NULL AND text LIKE '%' || ? || '%' LIMIT 1`,
+      args: [idOrText]
+    });
+  }
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  const id = String(row.id);
+  await client.execute({
+    sql: `UPDATE reminders SET completed_at = ? WHERE id = ?`,
+    args: [now, id]
+  });
+  return { id, text: String(row.text), createdAt: "", dueDate: null, completedAt: now };
+}
+
+export {
+  createReminder,
+  listReminders,
+  completeReminder
+};

package/dist/chunk-R4WMF32C.js

@@ -0,0 +1,81 @@
+import {
+  checkPathSafety
+} from "./chunk-NGVOA6ZQ.js";
+
+// src/runtime/tools/file-edit.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var inputSchema = z.object({
+  file_path: z.string(),
+  old_string: z.string(),
+  new_string: z.string(),
+  replace_all: z.boolean().optional()
+});
+var FileEditTool = {
+  name: "file_edit",
+  description: "Edit a file by replacing a string",
+  inputSchema,
+  isReadOnly: false,
+  async checkPermissions(input) {
+    const safety = checkPathSafety(input.file_path);
+    if (!safety.safe) {
+      return {
+        behavior: "deny",
+        reason: safety.reason ?? "Edit blocked by safety check",
+        bypassImmune: true
+      };
+    }
+    return { behavior: "allow" };
+  },
+  async call(input, context) {
+    const filePath = path.isAbsolute(input.file_path) ? input.file_path : path.resolve(context.cwd, input.file_path);
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch {
+      return { content: `File not found: ${filePath}`, isError: true };
+    }
+    const occurrences = countOccurrences(content, input.old_string);
+    if (occurrences === 0) {
+      return {
+        content: `old_string not found in ${filePath}`,
+        isError: true
+      };
+    }
+    if (occurrences > 1 && !input.replace_all) {
+      return {
+        content: `old_string appears ${occurrences} times in ${filePath}. Use replace_all: true to replace all, or provide more context to make it unique.`,
+        isError: true
+      };
+    }
+    let newContent;
+    if (input.replace_all) {
+      newContent = content.split(input.old_string).join(input.new_string);
+    } else {
+      const idx = content.indexOf(input.old_string);
+      newContent = content.slice(0, idx) + input.new_string + content.slice(idx + input.old_string.length);
+    }
+    await fs.writeFile(filePath, newContent, "utf-8");
+    const replaced = input.replace_all ? occurrences : 1;
+    return {
+      content: `Replaced ${replaced} occurrence(s) in ${filePath}`,
+      sideEffects: { filesModified: [filePath] }
+    };
+  }
+};
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    const idx = haystack.indexOf(needle, pos);
+    if (idx === -1) break;
+    count++;
+    pos = idx + needle.length;
+  }
+  return count;
+}
+
+export {
+  FileEditTool
+};

package/dist/chunk-R5U7XKVJ.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __require,
+  __export
+};