@askexenow/exe-os 0.9.113 → 0.9.115

package/dist/hooks/codex-stop-task-finalizer.js

@@ -154,6 +154,17 @@ function normalizeOrchestration(raw) {
   const userOrg = raw.orchestration ?? {};
   raw.orchestration = { ...defaultOrg, ...userOrg };
 }
+function normalizeCloudEndpoint(raw) {
+  const cloud = raw.cloud;
+  if (!cloud?.endpoint) return;
+  const ep = String(cloud.endpoint);
+  if (ep === "https://askexe.com/cloud" || ep === "https://askexe.com/cloud/") {
+    cloud.endpoint = "https://cloud.askexe.com";
+    process.stderr.write(
+      "[config] Auto-migrated cloud endpoint: askexe.com/cloud \u2192 cloud.askexe.com\n"
+    );
+  }
+}
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await ensurePrivateDir(dir);
@@ -179,6 +190,7 @@ async function loadConfig() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
+    normalizeCloudEndpoint(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os.homedir());
@@ -207,6 +219,7 @@ function loadConfigSync() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
+    normalizeCloudEndpoint(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os.homedir());
@@ -367,6 +380,7 @@ __export(agent_config_exports, {
   clearAgentRuntime: () => clearAgentRuntime,
   getAgentRuntime: () => getAgentRuntime,
   loadAgentConfig: () => loadAgentConfig,
+  normalizeCcModelName: () => normalizeCcModelName,
   saveAgentConfig: () => saveAgentConfig,
   setAgentMcps: () => setAgentMcps,
   setAgentRuntime: () => setAgentRuntime
@@ -395,6 +409,13 @@ function getAgentRuntime(agentId) {
   if (orgDefault) return orgDefault;
   return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
 }
+function normalizeCcModelName(model) {
+  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+  if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
+    ccModel += "[1m]";
+  }
+  return ccModel;
+}
 function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
   const knownModels = KNOWN_RUNTIMES[runtime];
   if (!knownModels) {
@@ -3741,7 +3762,7 @@ var init_database = __esm({
 });
 
 // src/lib/keychain.ts
-import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2, rename, copyFile } from "fs/promises";
 import { existsSync as existsSync8, statSync as statSync3 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import path7 from "path";
@@ -3776,12 +3797,14 @@ function linuxSecretAvailable() {
 function isRootOnlyTrustedServerKeyFile(keyPath) {
   if (process.platform !== "linux") return false;
   try {
-    const uid = typeof os5.userInfo().uid === "number" ? os5.userInfo().uid : -1;
     const st = statSync3(keyPath);
     if (!st.isFile() || (st.mode & 63) !== 0) return false;
+    const uid = typeof os5.userInfo().uid === "number" ? os5.userInfo().uid : -1;
     if (uid === 0) return true;
     const exeOsDir = process.env.EXE_OS_DIR;
-    return Boolean(exeOsDir && path7.resolve(keyPath).startsWith(path7.resolve(exeOsDir) + path7.sep));
+    if (exeOsDir && path7.resolve(keyPath).startsWith(path7.resolve(exeOsDir) + path7.sep)) return true;
+    if (!linuxSecretAvailable()) return true;
+    return false;
   } catch {
     return false;
   }
@@ -3931,15 +3954,25 @@ async function writeMachineBoundFileFallback(b64) {
   await mkdir3(dir, { recursive: true });
   const keyPath = getKeyPath();
   const machineKey = deriveMachineKey();
-  if (machineKey) {
-    const encrypted = encryptWithMachineKey(b64, machineKey);
-    await writeFile3(keyPath, encrypted + "\n", "utf-8");
-    await chmod2(keyPath, 384);
-    return "encrypted";
+  const content = machineKey ? encryptWithMachineKey(b64, machineKey) + "\n" : b64 + "\n";
+  const result = machineKey ? "encrypted" : "plaintext";
+  const tmpPath = keyPath + ".tmp";
+  try {
+    if (existsSync8(keyPath)) {
+      await copyFile(keyPath, keyPath + ".bak").catch(() => {
+      });
+    }
+    await writeFile3(tmpPath, content, "utf-8");
+    await chmod2(tmpPath, 384);
+    await rename(tmpPath, keyPath);
+  } catch (err) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+    throw err;
   }
-  await writeFile3(keyPath, b64 + "\n", "utf-8");
-  await chmod2(keyPath, 384);
-  return "plaintext";
+  return result;
 }
 async function getMasterKey() {
   let nativeValue = macKeychainGet() ?? linuxSecretGet();
@@ -4006,7 +4039,7 @@ async function getMasterKey() {
       b64Value = content;
     }
     const key = Buffer.from(b64Value, "base64");
-    if (!content.startsWith(ENCRYPTED_PREFIX) && isRootOnlyTrustedServerKeyFile(keyPath)) {
+    if (isRootOnlyTrustedServerKeyFile(keyPath)) {
       return key;
     }
     const migrated = macKeychainSet(b64Value) || linuxSecretSet(b64Value);
@@ -6468,6 +6501,7 @@ var init_provider_table = __esm({
 // src/lib/intercom-queue.ts
 var intercom_queue_exports = {};
 __export(intercom_queue_exports, {
+  _resetDrainGuard: () => _resetDrainGuard,
   clearQueueForAgent: () => clearQueueForAgent,
   drainForSession: () => drainForSession,
   drainQueue: () => drainQueue,
@@ -6513,38 +6547,47 @@ function queueIntercom(targetSession, 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;
-  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;
+  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 {
       }
-    } catch {
-    }
-    item.attempts++;
-    if (item.attempts >= MAX_RETRIES2) {
-      logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES2} retries exhausted, reason: ${item.reason})`);
-      failed++;
-      continue;
+      item.attempts++;
+      if (item.attempts >= MAX_RETRIES2) {
+        logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES2} retries exhausted, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      remaining.push(item);
     }
-    remaining.push(item);
+    writeQueue(remaining);
+  } finally {
+    _draining = false;
   }
-  writeQueue(remaining);
   return { drained, failed };
 }
 function drainForSession(targetSession, sendKeys) {
@@ -6569,6 +6612,9 @@ function clearQueueForAgent(agentName) {
     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}
 `;
@@ -6580,13 +6626,14 @@ function logQueue(msg) {
   } catch {
   }
 }
-var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
+var QUEUE_PATH, MAX_RETRIES2, TTL_MS, _draining, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
     QUEUE_PATH = path10.join(os7.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
+    _draining = false;
     INTERCOM_LOG = path10.join(os7.homedir(), ".exe-os", "intercom.log");
   }
 });
@@ -7104,6 +7151,21 @@ function isRootSession(name) {
 function extractRootExe(name) {
   if (!name) return null;
   if (!name.includes("-")) return name;
+  try {
+    const roster = (init_employees(), __toCommonJS(employees_exports)).loadEmployeesSync();
+    if (roster.length > 0) {
+      const sortedNames = roster.map((e) => e.name).sort((a, b) => b.length - a.length);
+      for (const agentName of sortedNames) {
+        const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+        const match = name.match(regex);
+        if (match) {
+          return extractRootExe(match[1]);
+        }
+      }
+    }
+  } catch {
+  }
   const parts = name.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
@@ -7122,6 +7184,10 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 function getParentExe(sessionKey) {
   try {
     const data = JSON.parse(readFileSync9(path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    if (data.registeredAt) {
+      const age = Date.now() - new Date(data.registeredAt).getTime();
+      if (age > PARENT_EXE_CACHE_TTL_MS) return null;
+    }
     return data.parentExe || null;
   } catch {
     return null;
@@ -7393,7 +7459,7 @@ function notifyParentExe(sessionKey) {
   }
   return true;
 }
-var SPAWN_LOCK_DIR, SESSION_CACHE, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var SPAWN_LOCK_DIR, SESSION_CACHE, PARENT_EXE_CACHE_TTL_MS, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
 var init_tmux_routing = __esm({
   "src/lib/tmux-routing.ts"() {
     "use strict";
@@ -7411,6 +7477,7 @@ var init_tmux_routing = __esm({
     init_agent_symlinks();
     SPAWN_LOCK_DIR = path14.join(os10.homedir(), ".exe-os", "spawn-locks");
     SESSION_CACHE = path14.join(os10.homedir(), ".exe-os", "session-cache");
+    PARENT_EXE_CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
     INTERCOM_LOG2 = path14.join(os10.homedir(), ".exe-os", "intercom.log");
@@ -7454,6 +7521,17 @@ var init_task_scope = __esm({
 });
 
 // src/lib/notifications.ts
+var notifications_exports = {};
+__export(notifications_exports, {
+  cleanupOldNotifications: () => cleanupOldNotifications,
+  formatNotifications: () => formatNotifications,
+  markAsRead: () => markAsRead,
+  markAsReadByTaskFile: () => markAsReadByTaskFile,
+  markDoneTaskNotificationsAsRead: () => markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications: () => migrateJsonNotifications,
+  readUnreadNotifications: () => readUnreadNotifications,
+  writeNotification: () => writeNotification
+});
 import crypto2 from "crypto";
 import path15 from "path";
 import os11 from "os";
@@ -7490,6 +7568,52 @@ async function writeNotification(notification) {
 `);
   }
 }
+async function readUnreadNotifications(agentFilter, sessionScope) {
+  try {
+    const client = getClient();
+    const conditions = ["read = 0"];
+    const args = [];
+    const scope = strictSessionScopeFilter(sessionScope);
+    if (agentFilter) {
+      conditions.push("agent_id = ?");
+      args.push(agentFilter);
+    }
+    const result = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, event, project, summary, task_file, session_scope, created_at
+            FROM notifications
+            WHERE ${conditions.join(" AND ")}${scope.sql}
+            ORDER BY created_at ASC`,
+      args: [...args, ...scope.args]
+    });
+    return result.rows.map((r) => ({
+      id: String(r.id),
+      agentId: String(r.agent_id),
+      agentRole: String(r.agent_role),
+      event: String(r.event),
+      project: String(r.project),
+      summary: String(r.summary),
+      taskFile: r.task_file ? String(r.task_file) : void 0,
+      sessionScope: r.session_scope == null ? null : String(r.session_scope),
+      timestamp: String(r.created_at),
+      read: false
+    }));
+  } catch {
+    return [];
+  }
+}
+async function markAsRead(ids, sessionScope) {
+  if (ids.length === 0) return;
+  try {
+    const client = getClient();
+    const placeholders = ids.map(() => "?").join(", ");
+    const scope = strictSessionScopeFilter(sessionScope);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1 WHERE id IN (${placeholders})${scope.sql}`,
+      args: [...ids, ...scope.args]
+    });
+  } catch {
+  }
+}
 async function markAsReadByTaskFile(taskFile, sessionScope) {
   try {
     const client = getClient();
@@ -7502,11 +7626,144 @@ async function markAsReadByTaskFile(taskFile, sessionScope) {
   } catch {
   }
 }
+async function cleanupOldNotifications(daysOld = CLEANUP_DAYS, sessionScope) {
+  try {
+    const client = getClient();
+    const cutoff = new Date(
+      Date.now() - daysOld * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result = await client.execute({
+      sql: `DELETE FROM notifications WHERE created_at < ?${scope.sql}`,
+      args: [cutoff, ...scope.args]
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+async function markDoneTaskNotificationsAsRead(sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result = await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE read = 0
+              AND task_file IS NOT NULL
+              ${scope.sql}
+              AND task_file IN (
+                SELECT task_file FROM tasks WHERE status = 'done'${scope.sql}
+              )`,
+      args: [...scope.args, ...scope.args]
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+function formatNotifications(notifications) {
+  if (notifications.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const n of notifications) {
+    const key = `${n.agentId}|${n.agentRole}`;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(n);
+  }
+  const lines = [];
+  lines.push(`## Notifications (${notifications.length} unread)
+`);
+  for (const [key, items] of grouped) {
+    const [agentId, agentRole] = key.split("|");
+    lines.push(`**${agentId}** (${agentRole}):`);
+    for (const item of items) {
+      const ago = formatTimeAgo(item.timestamp);
+      const icon = eventIcon(item.event);
+      lines.push(`- ${icon} ${item.summary} (${item.project}) \u2014 ${ago}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function migrateJsonNotifications() {
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path15.join(os11.homedir(), ".exe-os");
+  const notifDir = path15.join(base, "notifications");
+  if (!existsSync15(notifDir)) return 0;
+  let migrated = 0;
+  try {
+    const files = readdirSync3(notifDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return 0;
+    const client = getClient();
+    for (const file of files) {
+      try {
+        const filePath = path15.join(notifDir, file);
+        const data = JSON.parse(readFileSync10(filePath, "utf8"));
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            crypto2.randomUUID(),
+            data.agentId ?? "unknown",
+            data.agentRole ?? "unknown",
+            data.event ?? "session_summary",
+            data.project ?? "unknown",
+            data.summary ?? "",
+            data.taskFile ?? null,
+            null,
+            data.read ? 1 : 0,
+            data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+          ]
+        });
+        unlinkSync4(filePath);
+        migrated++;
+      } catch {
+      }
+    }
+    try {
+      const remaining = readdirSync3(notifDir);
+      if (remaining.length === 0) {
+        rmdirSync(notifDir);
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return migrated;
+}
+function eventIcon(event) {
+  switch (event) {
+    case "task_complete":
+      return "Completed:";
+    case "task_needs_fix":
+      return "Needs fix:";
+    case "session_summary":
+      return "Session:";
+    case "error_spike":
+      return "Errors:";
+    case "orphan_task":
+      return "Orphan:";
+    case "subtasks_complete":
+      return "Subtasks done:";
+    case "capacity_relaunch":
+      return "Relaunched:";
+  }
+}
+function formatTimeAgo(timestamp) {
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+var CLEANUP_DAYS;
 var init_notifications = __esm({
   "src/lib/notifications.ts"() {
     "use strict";
     init_database();
     init_task_scope();
+    CLEANUP_DAYS = 7;
   }
 });
 
@@ -8557,6 +8814,20 @@ async function updateTask(input) {
       notifyTaskDone();
     }
     await markTaskNotificationsRead(taskFile);
+    if (input.status === "needs_review" && !isCoordinator) {
+      try {
+        const { writeNotification: writeNotification2 } = await Promise.resolve().then(() => (init_notifications(), notifications_exports));
+        await writeNotification2({
+          agentId: String(row.assigned_to),
+          agentRole: String(row.assigned_to),
+          event: "task_complete",
+          project: String(row.project_name),
+          summary: `"${String(row.title)}" is ready for review`,
+          taskFile
+        });
+      } catch {
+      }
+    }
     if (input.status === "done" || input.status === "closed") {
       try {
         await cascadeUnblock(taskId, input.baseDir, now);