@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/browser-session-store-RF45DSJR.js

@@ -0,0 +1,232 @@
+import {
+  enforcePrivateFileSync,
+  ensurePrivateDirSync
+} from "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/browser-session-store.ts
+import crypto from "crypto";
+import path from "path";
+import os from "os";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  readdirSync,
+  statSync
+} from "fs";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+var HKDF_INFO = "exe-browser-cookies-v1";
+var DEFAULT_TTL_MS = 30 * 60 * 1e3;
+var _jarCache = /* @__PURE__ */ new Map();
+var _cookieKey = null;
+function initCookieCrypto(masterKey) {
+  if (masterKey.length !== 32) {
+    throw new Error(`Master key must be 32 bytes, got ${masterKey.length}`);
+  }
+  _cookieKey = Buffer.from(
+    crypto.hkdfSync("sha256", masterKey, "", HKDF_INFO, 32)
+  );
+}
+function isCookieCryptoInitialized() {
+  return _cookieKey !== null;
+}
+function encrypt(data) {
+  if (!_cookieKey) {
+    return "plain:" + Buffer.from(data, "utf-8").toString("base64");
+  }
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, _cookieKey, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(Buffer.from(data, "utf-8")),
+    cipher.final()
+  ]);
+  const tag = cipher.getAuthTag();
+  return "enc:" + Buffer.concat([iv, encrypted, tag]).toString("base64");
+}
+function decrypt(ciphertext) {
+  if (ciphertext.startsWith("plain:")) {
+    return Buffer.from(ciphertext.slice(6), "base64").toString("utf-8");
+  }
+  if (!ciphertext.startsWith("enc:")) {
+    throw new Error("Unknown cookie store format");
+  }
+  if (!_cookieKey) {
+    throw new Error("Cookie crypto not initialized but encrypted data found");
+  }
+  const combined = Buffer.from(ciphertext.slice(4), "base64");
+  if (combined.length < IV_LENGTH + TAG_LENGTH) {
+    throw new Error("Cookie data too short");
+  }
+  const iv = combined.subarray(0, IV_LENGTH);
+  const tag = combined.subarray(combined.length - TAG_LENGTH);
+  const encrypted = combined.subarray(IV_LENGTH, combined.length - TAG_LENGTH);
+  const decipher = crypto.createDecipheriv(ALGORITHM, _cookieKey, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([
+    decipher.update(encrypted),
+    decipher.final()
+  ]).toString("utf-8");
+}
+function getStoreDir() {
+  const base = process.env.EXE_OS_DIR ?? path.join(os.homedir(), ".exe-os");
+  return path.join(base, "browser-sessions");
+}
+function getJarPath(agentId, sessionKey) {
+  const safe = (s) => s.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path.join(getStoreDir(), `${safe(agentId)}-${safe(sessionKey)}.cookies.enc`);
+}
+function jarCacheKey(agentId, sessionKey) {
+  return `${agentId}:${sessionKey}`;
+}
+function getTtlMs() {
+  const envTtl = process.env.EXE_BROWSER_SESSION_TTL;
+  if (envTtl) {
+    const parsed = parseInt(envTtl, 10);
+    if (!isNaN(parsed) && parsed > 0) return parsed * 1e3;
+  }
+  return DEFAULT_TTL_MS;
+}
+function loadCookieJar(agentId, sessionKey) {
+  const cacheKey = jarCacheKey(agentId, sessionKey);
+  const cached = _jarCache.get(cacheKey);
+  if (cached) {
+    const ttl = getTtlMs();
+    if (Date.now() - cached.lastAccessed > ttl) {
+      clearCookieJar(agentId, sessionKey);
+      return null;
+    }
+    return cached;
+  }
+  const jarPath = getJarPath(agentId, sessionKey);
+  if (!existsSync(jarPath)) return null;
+  try {
+    const raw = readFileSync(jarPath, "utf-8");
+    const jar = JSON.parse(decrypt(raw));
+    const ttl = getTtlMs();
+    if (Date.now() - jar.lastAccessed > ttl) {
+      clearCookieJar(agentId, sessionKey);
+      return null;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    jar.cookies = jar.cookies.filter((c) => !c.expires || c.expires > now);
+    _jarCache.set(cacheKey, jar);
+    return jar;
+  } catch {
+    try {
+      unlinkSync(jarPath);
+    } catch {
+    }
+    return null;
+  }
+}
+function saveCookieJar(agentId, sessionKey, cookies) {
+  const cacheKey = jarCacheKey(agentId, sessionKey);
+  const existing = loadCookieJar(agentId, sessionKey);
+  const now = Date.now();
+  const cookieMap = /* @__PURE__ */ new Map();
+  if (existing) {
+    for (const c of existing.cookies) {
+      cookieMap.set(`${c.domain}:${c.path}:${c.name}`, c);
+    }
+  }
+  for (const c of cookies) {
+    cookieMap.set(`${c.domain}:${c.path}:${c.name}`, c);
+  }
+  const nowSec = Math.floor(now / 1e3);
+  const merged = [...cookieMap.values()].filter(
+    (c) => !c.expires || c.expires > nowSec
+  );
+  const jar = {
+    agentId,
+    sessionKey,
+    cookies: merged,
+    lastAccessed: now,
+    createdAt: existing?.createdAt ?? now
+  };
+  const storeDir = getStoreDir();
+  ensurePrivateDirSync(storeDir);
+  const jarPath = getJarPath(agentId, sessionKey);
+  const encrypted = encrypt(JSON.stringify(jar));
+  writeFileSync(jarPath, encrypted, "utf-8");
+  enforcePrivateFileSync(jarPath);
+  _jarCache.set(cacheKey, jar);
+}
+function getCookiesForUrl(agentId, sessionKey, url) {
+  const jar = loadCookieJar(agentId, sessionKey);
+  if (!jar || jar.cookies.length === 0) return [];
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return [];
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  return jar.cookies.filter((c) => {
+    if (c.expires && c.expires <= now) return false;
+    const cookieDomain = c.domain.startsWith(".") ? c.domain.slice(1) : c.domain;
+    return hostname === cookieDomain || hostname.endsWith("." + cookieDomain);
+  });
+}
+function clearCookieJar(agentId, sessionKey) {
+  const cacheKey = jarCacheKey(agentId, sessionKey);
+  _jarCache.delete(cacheKey);
+  const jarPath = getJarPath(agentId, sessionKey);
+  try {
+    if (existsSync(jarPath)) unlinkSync(jarPath);
+  } catch {
+  }
+}
+function cleanupExpiredJars() {
+  const storeDir = getStoreDir();
+  if (!existsSync(storeDir)) return 0;
+  const ttl = getTtlMs();
+  const now = Date.now();
+  let cleaned = 0;
+  try {
+    const files = readdirSync(storeDir).filter((f) => f.endsWith(".cookies.enc"));
+    for (const file of files) {
+      const filePath = path.join(storeDir, file);
+      try {
+        const stat = statSync(filePath);
+        if (now - stat.mtimeMs > ttl) {
+          unlinkSync(filePath);
+          cleaned++;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+function touchCookieJar(agentId, sessionKey) {
+  const cacheKey = jarCacheKey(agentId, sessionKey);
+  const cached = _jarCache.get(cacheKey);
+  if (cached) {
+    cached.lastAccessed = Date.now();
+    const jarPath = getJarPath(agentId, sessionKey);
+    try {
+      if (existsSync(jarPath)) {
+        const raw = readFileSync(jarPath, "utf-8");
+        const jar = JSON.parse(decrypt(raw));
+        jar.lastAccessed = Date.now();
+        writeFileSync(jarPath, encrypt(JSON.stringify(jar)), "utf-8");
+      }
+    } catch {
+    }
+  }
+}
+export {
+  cleanupExpiredJars,
+  clearCookieJar,
+  getCookiesForUrl,
+  initCookieCrypto,
+  isCookieCryptoInitialized,
+  loadCookieJar,
+  saveCookieJar,
+  touchCookieJar
+};

package/dist/capacity-monitor-HZPAFQZH.js

@@ -0,0 +1,48 @@
+import {
+  CTX_FLOOR_PERCENT,
+  _resetLastRelaunchCache,
+  _resetPendingCapacityKills,
+  confirmCapacityKill,
+  createOrRefreshResumeTask,
+  extractContextPercent,
+  isAtCapacity,
+  isWithinRelaunchCooldown,
+  pollCapacityDead
+} from "./chunk-M37HYGAG.js";
+import "./chunk-FIPU4BDF.js";
+import "./chunk-UBMGUX6T.js";
+import "./chunk-I2CDSGQW.js";
+import "./chunk-QI4IXJN7.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-G4LLKD4Z.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import "./chunk-CTFKTUYN.js";
+import "./chunk-GVP5U4WL.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-V3QAAU2U.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-RMPAMMYW.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-UJOSFVWG.js";
+import "./chunk-QHIGMP2M.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-D4IVTUNN.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  CTX_FLOOR_PERCENT,
+  _resetLastRelaunchCache,
+  _resetPendingCapacityKills,
+  confirmCapacityKill,
+  createOrRefreshResumeTask,
+  extractContextPercent,
+  isAtCapacity,
+  isWithinRelaunchCooldown,
+  pollCapacityDead
+};

package/dist/catchup-brief-CDG4KD5Y.js

@@ -0,0 +1,150 @@
+import {
+  lightweightSearch
+} from "./chunk-HFJNYSTQ.js";
+import "./chunk-HTCBLSIB.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-IW53DAYO.js";
+import "./chunk-F7LU65PQ.js";
+import {
+  sessionScopeFilter,
+  strictSessionScopeFilter
+} from "./chunk-UBMGUX6T.js";
+import "./chunk-I2CDSGQW.js";
+import "./chunk-QI4IXJN7.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-G4LLKD4Z.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import "./chunk-CTFKTUYN.js";
+import "./chunk-GVP5U4WL.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-V3QAAU2U.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-RMPAMMYW.js";
+import "./chunk-HYZV25LY.js";
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+import "./chunk-QHIGMP2M.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-7NNXBDOO.js";
+import "./chunk-D4IVTUNN.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/catchup-brief.ts
+import { execSync } from "child_process";
+var HEADER = "## Catchup Brief\nHere's what happened while you were offline:";
+var DEFAULT_LOOKBACK_MS = 60 * 60 * 1e3;
+var MAX_BRIEF_CHARS = 2e3;
+var MAX_CHECKPOINT_CHARS = 500;
+var MAX_MESSAGE_CHARS = 100;
+function clipText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  if (maxChars <= 1) return "\u2026";
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function clampSections(header, sections, maxChars) {
+  const bounded = [];
+  let remaining = Math.max(0, maxChars - header.length);
+  for (const section of sections) {
+    const separatorChars = 2;
+    if (remaining <= separatorChars) break;
+    remaining -= separatorChars;
+    if (section.length <= remaining) {
+      bounded.push(section);
+      remaining -= section.length;
+      continue;
+    }
+    const clipped = clipText(section, remaining);
+    if (clipped.trim().length > 0) bounded.push(clipped);
+    break;
+  }
+  return bounded;
+}
+async function buildCatchupBrief(agentId, projectName, cwd, sessionScope) {
+  const sections = [];
+  let lastTimestamp = new Date(Date.now() - DEFAULT_LOOKBACK_MS).toISOString();
+  try {
+    const checkpointMemories = await lightweightSearch(
+      "CONTEXT CHECKPOINT",
+      agentId,
+      { projectName, limit: 1 }
+    );
+    const checkpoint = checkpointMemories[0];
+    if (checkpoint?.timestamp) {
+      lastTimestamp = checkpoint.timestamp;
+    }
+    if (checkpoint?.raw_text) {
+      sections.push(
+        `### Last Checkpoint
+${clipText(checkpoint.raw_text, MAX_CHECKPOINT_CHARS)}`
+      );
+    }
+  } catch {
+  }
+  try {
+    const gitLog = execSync(
+      `git log --oneline --since=${JSON.stringify(lastTimestamp)} --format="%h %an: %s" | head -10`,
+      { cwd, timeout: 3e3, encoding: "utf-8" }
+    ).trim();
+    if (gitLog) {
+      sections.push(`### Git Activity Since You Left
+\`\`\`
+${gitLog}
+\`\`\``);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const taskScope = sessionScopeFilter(sessionScope);
+    const taskChanges = await client.execute({
+      sql: `SELECT title, status, priority FROM tasks
+            WHERE assigned_to = ? AND project_name = ?
+              AND updated_at > ? AND status IN ('open', 'in_progress')${taskScope.sql}
+            ORDER BY priority ASC, updated_at DESC LIMIT 5`,
+      args: [agentId, projectName, lastTimestamp, ...taskScope.args]
+    });
+    if (taskChanges.rows.length > 0) {
+      const taskLines = taskChanges.rows.map((row) => {
+        const record = row;
+        return `- [${String(record.priority).toUpperCase()}] ${String(record.title)} (${String(record.status)})`;
+      }).join("\n");
+      sections.push(`### Your Task Queue
+${taskLines}`);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const messageScope = strictSessionScopeFilter(sessionScope);
+    const messages = await client.execute({
+      sql: `SELECT from_agent, content, created_at FROM messages
+            WHERE target_agent = ? AND status = 'pending'${messageScope.sql}
+            ORDER BY created_at DESC LIMIT 3`,
+      args: [agentId, ...messageScope.args]
+    });
+    if (messages.rows.length > 0) {
+      const msgLines = messages.rows.map((row) => {
+        const record = row;
+        return `- From ${String(record.from_agent)}: ${clipText(String(record.content ?? ""), MAX_MESSAGE_CHARS)}`;
+      }).join("\n");
+      sections.push(`### Unread Messages
+${msgLines}`);
+    }
+  } catch {
+  }
+  return {
+    header: HEADER,
+    sections: clampSections(HEADER, sections, MAX_BRIEF_CHARS)
+  };
+}
+export {
+  buildCatchupBrief
+};