@askexenow/exe-os 0.8.26 → 0.8.27

package/dist/bin/exe-launch-agent.js

@@ -257,8 +257,8 @@ function shardExists(projectName) {
 }
 function listShards() {
   if (!existsSync3(SHARDS_DIR)) return [];
-  const { readdirSync: readdirSync3 } = __require("fs");
-  return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+  const { readdirSync: readdirSync4 } = __require("fs");
+  return readdirSync4(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
@@ -1129,10 +1129,189 @@ All memory, tasks, behaviors, documents, and wiki content belonging to {{company
   }
 });
 
+// src/lib/session-key.ts
+import { execSync as execSync3 } from "child_process";
+function getSessionKey() {
+  if (_cached) return _cached;
+  let pid = process.ppid;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const info = execSync3(`ps -p ${pid} -o ppid=,comm=`, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+      const [, ppid, cmd] = match;
+      if (cmd === "claude" || cmd.endsWith("/claude")) {
+        _cached = String(pid);
+        return _cached;
+      }
+      pid = parseInt(ppid, 10);
+      if (pid <= 1) break;
+    } catch {
+      break;
+    }
+  }
+  _cached = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
+  return _cached;
+}
+var _cached;
+var init_session_key = __esm({
+  "src/lib/session-key.ts"() {
+    "use strict";
+    _cached = null;
+  }
+});
+
+// src/adapters/claude/session-key.ts
+var init_session_key2 = __esm({
+  "src/adapters/claude/session-key.ts"() {
+    "use strict";
+    init_session_key();
+  }
+});
+
+// src/adapters/claude/active-agent.ts
+var active_agent_exports = {};
+__export(active_agent_exports, {
+  cleanupSessionMarkers: () => cleanupSessionMarkers,
+  clearActiveAgent: () => clearActiveAgent,
+  getActiveAgent: () => getActiveAgent,
+  getAllActiveAgents: () => getAllActiveAgents,
+  writeActiveAgent: () => writeActiveAgent
+});
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
+import { execSync as execSync4 } from "child_process";
+import path6 from "path";
+function getMarkerPath() {
+  return path6.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+}
+function writeActiveAgent(agentId, agentRole) {
+  try {
+    mkdirSync3(CACHE_DIR, { recursive: true });
+    writeFileSync2(
+      getMarkerPath(),
+      JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
+    );
+  } catch {
+  }
+}
+function clearActiveAgent() {
+  try {
+    unlinkSync2(getMarkerPath());
+  } catch {
+  }
+}
+function getActiveAgent() {
+  try {
+    const markerPath = getMarkerPath();
+    const raw = readFileSync2(markerPath, "utf8");
+    const data = JSON.parse(raw);
+    if (data.agentId) {
+      if (data.startedAt) {
+        const age = Date.now() - new Date(data.startedAt).getTime();
+        if (age > STALE_MS) {
+          try {
+            unlinkSync2(markerPath);
+          } catch {
+          }
+        } else {
+          return {
+            agentId: data.agentId,
+            agentRole: data.agentRole || "employee"
+          };
+        }
+      } else {
+        return {
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee"
+        };
+      }
+    }
+  } catch {
+  }
+  try {
+    const sessionName = execSync4(
+      "tmux display-message -p '#{session_name}' 2>/dev/null",
+      { encoding: "utf8", timeout: 2e3 }
+    ).trim();
+    const empMatch = sessionName.match(/^(\w+)-exe\d+$/);
+    if (empMatch && empMatch[1] !== "exe") {
+      return { agentId: empMatch[1], agentRole: "employee" };
+    }
+    if (/^exe\d+$/.test(sessionName)) {
+      return { agentId: "exe", agentRole: "COO" };
+    }
+  } catch {
+  }
+  return {
+    agentId: process.env.AGENT_ID || "default",
+    agentRole: process.env.AGENT_ROLE || "employee"
+  };
+}
+function getAllActiveAgents() {
+  try {
+    const files = readdirSync2(CACHE_DIR);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.startsWith("active-agent-") || !file.endsWith(".json")) continue;
+      const key = file.slice("active-agent-".length, -".json".length);
+      if (key === "undefined") continue;
+      try {
+        const raw = readFileSync2(path6.join(CACHE_DIR, file), "utf8");
+        const data = JSON.parse(raw);
+        if (!data.agentId) continue;
+        if (data.startedAt) {
+          const age = Date.now() - new Date(data.startedAt).getTime();
+          if (age > STALE_MS) {
+            try {
+              unlinkSync2(path6.join(CACHE_DIR, file));
+            } catch {
+            }
+            continue;
+          }
+        }
+        sessions.push({
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee",
+          startedAt: data.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+          sessionKey: key
+        });
+      } catch {
+      }
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function cleanupSessionMarkers() {
+  const key = getSessionKey();
+  try {
+    unlinkSync2(path6.join(CACHE_DIR, `active-agent-${key}.json`));
+  } catch {
+  }
+  try {
+    unlinkSync2(path6.join(CACHE_DIR, "active-agent-undefined.json"));
+  } catch {
+  }
+}
+var CACHE_DIR, STALE_MS;
+var init_active_agent = __esm({
+  "src/adapters/claude/active-agent.ts"() {
+    "use strict";
+    init_config();
+    init_session_key2();
+    CACHE_DIR = path6.join(EXE_AI_DIR, "session-cache");
+    STALE_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
 // src/bin/exe-launch-agent.ts
 import os3 from "os";
-import path6 from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
+import path7 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
 import { spawnSync } from "child_process";
 
 // src/lib/database.ts
@@ -2342,7 +2521,7 @@ function parseBasename(basename) {
   return { agent, provider };
 }
 function resolveAgent(argv) {
-  const invokedAs = path6.basename(argv[1] ?? "");
+  const invokedAs = path7.basename(argv[1] ?? "");
   if (invokedAs && invokedAs !== "exe-launch-agent" && !invokedAs.endsWith(".js")) {
     const { agent: agent2, provider } = parseBasename(invokedAs);
     return { agent: agent2, provider, passthrough: argv.slice(2) };
@@ -2368,20 +2547,20 @@ async function isKnownAgent(agent) {
   }
 }
 function identityPathFor(agent) {
-  return path6.join(os3.homedir(), ".exe-os", "identity", `${agent}.md`);
+  return path7.join(os3.homedir(), ".exe-os", "identity", `${agent}.md`);
 }
 function leanMcpConfigFor(agent) {
-  const p = path6.join(os3.homedir(), ".exe-os", "mcp-configs", `${agent}-lean.json`);
+  const p = path7.join(os3.homedir(), ".exe-os", "mcp-configs", `${agent}-lean.json`);
   return existsSync6(p) ? p : null;
 }
 function buildLaunchPlan(agent, behaviorsPath, passthrough, _hasAgentFlag, _provider) {
   const args = ["--dangerously-skip-permissions"];
   const idPath = identityPathFor(agent);
-  const ccAgentPath = path6.join(os3.homedir(), ".claude", "agents", `${agent}.md`);
+  const ccAgentPath = path7.join(os3.homedir(), ".claude", "agents", `${agent}.md`);
   const effectiveIdPath = existsSync6(idPath) ? idPath : existsSync6(ccAgentPath) ? ccAgentPath : null;
   if (effectiveIdPath) {
     try {
-      const identity = readFileSync2(effectiveIdPath, "utf-8");
+      const identity = readFileSync3(effectiveIdPath, "utf-8");
       args.push("--system-prompt", identity);
     } catch {
       args.push("--append-system-prompt-file", effectiveIdPath);
@@ -2497,8 +2676,8 @@ async function main() {
   _resetCcAgentSupportCache();
   const hasAgentFlag = claudeSupportsAgentFlag();
   if (hasAgentFlag) {
-    const ccAgentDir = path6.join(os3.homedir(), ".claude", "agents");
-    const ccAgentFile = path6.join(ccAgentDir, `${agent}.md`);
+    const ccAgentDir = path7.join(os3.homedir(), ".claude", "agents");
+    const ccAgentFile = path7.join(ccAgentDir, `${agent}.md`);
     if (!existsSync6(ccAgentFile)) {
       const exeIdentity = identityPathFor(agent);
       let sourceFile = null;
@@ -2506,19 +2685,19 @@ async function main() {
         sourceFile = exeIdentity;
       } else {
         try {
-          const identityDir = path6.dirname(exeIdentity);
-          const files = readdirSync2(identityDir);
+          const identityDir = path7.dirname(exeIdentity);
+          const files = readdirSync3(identityDir);
           const match = files.find((f) => f.toLowerCase() === `${agent.toLowerCase()}.md`);
-          if (match) sourceFile = path6.join(identityDir, match);
+          if (match) sourceFile = path7.join(identityDir, match);
         } catch {
         }
       }
       if (sourceFile) {
         try {
-          mkdirSync3(ccAgentDir, { recursive: true });
-          let content = readFileSync2(sourceFile, "utf-8");
+          mkdirSync4(ccAgentDir, { recursive: true });
+          let content = readFileSync3(sourceFile, "utf-8");
           content = content.replace(/\$\{agent_id\}/g, agent);
-          writeFileSync2(ccAgentFile, content, "utf-8");
+          writeFileSync3(ccAgentFile, content, "utf-8");
           process.stderr.write(
             `[exe-launch-agent] auto-provisioned ${ccAgentFile} from ${sourceFile}
 `
@@ -2529,6 +2708,27 @@ async function main() {
     }
   }
   const plan = buildLaunchPlan(agent, behaviorsPath, passthrough, hasAgentFlag, provider);
+  process.env.AGENT_ID = agent;
+  const empRole = (() => {
+    try {
+      const emps = __require("fs").readFileSync(
+        path7.join(os3.homedir(), ".exe-os", "exe-employees.json"),
+        "utf-8"
+      );
+      const found = JSON.parse(emps).find(
+        (e) => e.name.toLowerCase() === agent.toLowerCase()
+      );
+      return found?.role ?? "employee";
+    } catch {
+      return "employee";
+    }
+  })();
+  process.env.AGENT_ROLE = empRole;
+  try {
+    const { writeActiveAgent: writeActiveAgent2 } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
+    writeActiveAgent2(agent, empRole);
+  } catch {
+  }
   if (!process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING) {
     process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING = "1";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.8.26",
+  "version": "0.8.27",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "CC-BY-NC-4.0",
   "type": "module",