@ekkos/cli 0.2.7 → 0.2.8

package/dist/utils/state.d.ts

@@ -1,7 +1,16 @@
 export declare const EKKOS_DIR: string;
 export declare const STATE_FILE: string;
+export declare const ACTIVE_SESSIONS_FILE: string;
 export declare const AUTO_CLEAR_FLAG: string;
 export declare const CONFIG_FILE: string;
+export interface ActiveSession {
+    sessionId: string;
+    sessionName: string;
+    pid: number;
+    startedAt: string;
+    projectPath: string;
+    lastHeartbeat: string;
+}
 export interface EkkosState {
     sessionName: string;
     sessionId: string;
@@ -20,7 +29,7 @@ export interface EkkosConfig {
  */
 export declare function uuidToWords(uuid: string): string;
 /**
- * Ensure .ekkos directory exists
+ * Ensure .ekkos directory exists and has required files
  */
 export declare function ensureEkkosDir(): void;
 /**
@@ -64,3 +73,32 @@ export declare function getMostRecentSession(): {
     sessionId: string;
     lastActive: string;
 } | null;
+/**
+ * Get all active sessions (filters out stale ones with dead PIDs)
+ */
+export declare function getActiveSessions(): ActiveSession[];
+/**
+ * Register a new active session (for swarm tracking)
+ */
+export declare function registerActiveSession(sessionId: string, sessionName: string, projectPath: string): ActiveSession;
+/**
+ * Update heartbeat for current process's session
+ */
+export declare function heartbeatActiveSession(): void;
+/**
+ * Unregister current process's session (on clean exit)
+ */
+export declare function unregisterActiveSession(): void;
+/**
+ * Get the active session for current PID (if any)
+ */
+export declare function getCurrentProcessSession(): ActiveSession | null;
+/**
+ * Get active session by session name
+ */
+export declare function getActiveSessionByName(sessionName: string): ActiveSession | null;
+/**
+ * Update the session for the current PID (when session name is detected)
+ * This does NOT write to the global state.json - only to active-sessions.json
+ */
+export declare function updateCurrentProcessSession(sessionId: string, sessionName: string): void;

package/dist/utils/state.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_FILE = exports.AUTO_CLEAR_FLAG = exports.STATE_FILE = exports.EKKOS_DIR = void 0;
+exports.CONFIG_FILE = exports.AUTO_CLEAR_FLAG = exports.ACTIVE_SESSIONS_FILE = exports.STATE_FILE = exports.EKKOS_DIR = void 0;
 exports.uuidToWords = uuidToWords;
 exports.ensureEkkosDir = ensureEkkosDir;
 exports.getState = getState;
@@ -47,12 +47,20 @@ exports.getAuthToken = getAuthToken;
 exports.clearAutoClearFlag = clearAutoClearFlag;
 exports.parseAutoClearFlag = parseAutoClearFlag;
 exports.getMostRecentSession = getMostRecentSession;
+exports.getActiveSessions = getActiveSessions;
+exports.registerActiveSession = registerActiveSession;
+exports.heartbeatActiveSession = heartbeatActiveSession;
+exports.unregisterActiveSession = unregisterActiveSession;
+exports.getCurrentProcessSession = getCurrentProcessSession;
+exports.getActiveSessionByName = getActiveSessionByName;
+exports.updateCurrentProcessSession = updateCurrentProcessSession;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 // State file paths
 exports.EKKOS_DIR = path.join(os.homedir(), '.ekkos');
 exports.STATE_FILE = path.join(exports.EKKOS_DIR, 'state.json');
+exports.ACTIVE_SESSIONS_FILE = path.join(exports.EKKOS_DIR, 'active-sessions.json');
 exports.AUTO_CLEAR_FLAG = path.join(exports.EKKOS_DIR, 'auto-clear.flag');
 exports.CONFIG_FILE = path.join(exports.EKKOS_DIR, 'config.json');
 // SINGLE SOURCE OF TRUTH: Import word lists from shared JSON
@@ -81,12 +89,27 @@ function uuidToWords(uuid) {
     return `${ADJECTIVES[adjIdx]}-${NOUNS[nounIdx]}-${VERBS[verbIdx]}`;
 }
 /**
- * Ensure .ekkos directory exists
+ * Ensure .ekkos directory exists and has required files
  */
 function ensureEkkosDir() {
     if (!fs.existsSync(exports.EKKOS_DIR)) {
         fs.mkdirSync(exports.EKKOS_DIR, { recursive: true });
     }
+    // Copy session-words.json to ~/.ekkos/ if not present
+    // This is the SINGLE SOURCE OF TRUTH for session name generation
+    // Used by: CLI, hooks, Time Machine, extension
+    const destWords = path.join(exports.EKKOS_DIR, 'session-words.json');
+    if (!fs.existsSync(destWords)) {
+        try {
+            const srcWords = path.join(__dirname, 'session-words.json');
+            if (fs.existsSync(srcWords)) {
+                fs.copyFileSync(srcWords, destWords);
+            }
+        }
+        catch {
+            // Ignore - file will be created manually or by another component
+        }
+    }
 }
 /**
  * Get current session state
@@ -220,3 +243,130 @@ function getMostRecentSession() {
         return null;
     }
 }
+// ═══════════════════════════════════════════════════════════════════════════
+// MULTI-SESSION/SWARM SUPPORT
+// Track multiple concurrent Claude Code sessions without state collision
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Get all active sessions (filters out stale ones with dead PIDs)
+ */
+function getActiveSessions() {
+    ensureEkkosDir();
+    try {
+        if (!fs.existsSync(exports.ACTIVE_SESSIONS_FILE)) {
+            return [];
+        }
+        const content = fs.readFileSync(exports.ACTIVE_SESSIONS_FILE, 'utf-8');
+        const sessions = JSON.parse(content);
+        // Filter out sessions with dead PIDs
+        const alive = sessions.filter(s => isProcessAlive(s.pid));
+        // If we filtered any out, update the file
+        if (alive.length !== sessions.length) {
+            fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(alive, null, 2));
+        }
+        return alive;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Register a new active session (for swarm tracking)
+ */
+function registerActiveSession(sessionId, sessionName, projectPath) {
+    ensureEkkosDir();
+    const sessions = getActiveSessions();
+    const now = new Date().toISOString();
+    const pid = process.pid;
+    // Remove any existing entry for this PID (process restart)
+    const filtered = sessions.filter(s => s.pid !== pid);
+    const newSession = {
+        sessionId,
+        sessionName,
+        pid,
+        startedAt: now,
+        projectPath,
+        lastHeartbeat: now
+    };
+    filtered.push(newSession);
+    fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(filtered, null, 2));
+    return newSession;
+}
+/**
+ * Update heartbeat for current process's session
+ */
+function heartbeatActiveSession() {
+    try {
+        const sessions = getActiveSessions();
+        const pid = process.pid;
+        const idx = sessions.findIndex(s => s.pid === pid);
+        if (idx !== -1) {
+            sessions[idx].lastHeartbeat = new Date().toISOString();
+            fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(sessions, null, 2));
+        }
+    }
+    catch {
+        // Ignore heartbeat errors
+    }
+}
+/**
+ * Unregister current process's session (on clean exit)
+ */
+function unregisterActiveSession() {
+    try {
+        const sessions = getActiveSessions();
+        const pid = process.pid;
+        const filtered = sessions.filter(s => s.pid !== pid);
+        fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(filtered, null, 2));
+    }
+    catch {
+        // Ignore unregister errors on exit
+    }
+}
+/**
+ * Get the active session for current PID (if any)
+ */
+function getCurrentProcessSession() {
+    const sessions = getActiveSessions();
+    return sessions.find(s => s.pid === process.pid) || null;
+}
+/**
+ * Get active session by session name
+ */
+function getActiveSessionByName(sessionName) {
+    const sessions = getActiveSessions();
+    return sessions.find(s => s.sessionName === sessionName) || null;
+}
+/**
+ * Check if a process is still alive
+ */
+function isProcessAlive(pid) {
+    try {
+        // Sending signal 0 doesn't kill the process, just checks if it exists
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Update the session for the current PID (when session name is detected)
+ * This does NOT write to the global state.json - only to active-sessions.json
+ */
+function updateCurrentProcessSession(sessionId, sessionName) {
+    try {
+        const sessions = getActiveSessions();
+        const pid = process.pid;
+        const idx = sessions.findIndex(s => s.pid === pid);
+        if (idx !== -1) {
+            sessions[idx].sessionId = sessionId;
+            sessions[idx].sessionName = sessionName;
+            sessions[idx].lastHeartbeat = new Date().toISOString();
+            fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(sessions, null, 2));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekkos/cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {