@ekkos/cli 0.2.18 → 1.0.0

package/dist/restore/RestoreOrchestrator.js

@@ -58,8 +58,10 @@ const types_js_1 = require("../cache/types.js");
 const stream_tailer_js_1 = require("../capture/stream-tailer.js");
 const paths_js_1 = require("../utils/paths.js");
 // API configuration
-const MEMORY_API_URL = process.env.EKKOS_API_URL || 'https://api.ekkos.dev';
+const MEMORY_API_URL = process.env.EKKOS_API_URL || 'https://mcp.ekkos.dev';
 const CONFIG_PATH = path.join(os.homedir(), '.ekkos', 'config.json');
+// Rehydration patterns
+const STUB_REGEX = /\[ekkOS:page-out:r2:\/\/([^/]+)\/([^/]+)\/([^/]+)\/([^\]?]+)(?:\?range=(\d+)-(\d+))?\]/g;
 /**
  * Load auth token from config
  */
@@ -122,45 +124,131 @@ class RestoreOrchestrator {
                 latency_ms: Date.now() - startTime,
             };
         }
+        let result;
         // Try Tier -1: Stream log (has mid-turn content, most recent data)
         const streamResult = await this.restoreFromStreamLog(instanceId, sessionId, sessionName || '', lastN);
         if (streamResult.success && streamResult.data) {
-            return {
-                ...streamResult,
-                latency_ms: Date.now() - startTime,
-            };
+            result = streamResult;
         }
-        // Try Tier 0: Local cache
-        const localResult = await this.restoreFromLocal(instanceId, sessionId, sessionName || '', lastN);
-        if (localResult.success && localResult.data) {
-            return {
-                ...localResult,
-                latency_ms: Date.now() - startTime,
-            };
-        }
-        // Try Tier 1: Redis
-        const redisResult = await this.restoreFromRedis(sessionName || sessionId, lastN, instanceId);
-        if (redisResult.success && redisResult.data) {
-            return {
-                ...redisResult,
-                latency_ms: Date.now() - startTime,
-            };
+        else {
+            // Try Tier 0: Local cache
+            const localResult = await this.restoreFromLocal(instanceId, sessionId, sessionName || '', lastN);
+            if (localResult.success && localResult.data) {
+                result = localResult;
+            }
+            else {
+                // Try Tier 1: Redis
+                const redisResult = await this.restoreFromRedis(sessionName || sessionId, lastN, instanceId);
+                if (redisResult.success && redisResult.data) {
+                    result = redisResult;
+                }
+                else {
+                    // Try Tier 2: Supabase
+                    const supabaseResult = await this.restoreFromSupabase(sessionId, lastN, instanceId);
+                    if (supabaseResult.success && supabaseResult.data) {
+                        result = supabaseResult;
+                    }
+                    else {
+                        // All tiers failed
+                        return {
+                            success: false,
+                            error: `All restore tiers failed. Local: ${localResult.error}, Redis: ${redisResult.error}, Supabase: ${supabaseResult.error}`,
+                            latency_ms: Date.now() - startTime,
+                        };
+                    }
+                }
+            }
         }
-        // Try Tier 2: Supabase
-        const supabaseResult = await this.restoreFromSupabase(sessionId, lastN, instanceId);
-        if (supabaseResult.success && supabaseResult.data) {
-            return {
-                ...supabaseResult,
-                latency_ms: Date.now() - startTime,
-            };
+        // Rehydrate stubs if any found in restored payload
+        if (result.success && result.data) {
+            await this.rehydratePayload(result.data);
         }
-        // All tiers failed
         return {
-            success: false,
-            error: `All restore tiers failed. Local: ${localResult.error}, Redis: ${redisResult.error}, Supabase: ${supabaseResult.error}`,
+            ...result,
             latency_ms: Date.now() - startTime,
         };
     }
+    /**
+     * Scan payload for [ekkOS:page-out:...] stubs and rehydrate from Proxy
+     */
+    async rehydratePayload(payload) {
+        const stubs = new Set();
+        // Scan all restored turns (both user queries and assistant responses)
+        // Stubs are injected as user messages, so check user_query too
+        for (const turn of payload.restored_turns) {
+            for (const text of [turn.user_query, turn.assistant_response]) {
+                if (!text)
+                    continue;
+                STUB_REGEX.lastIndex = 0;
+                const matches = text.match(STUB_REGEX);
+                if (matches) {
+                    for (const match of matches)
+                        stubs.add(match);
+                }
+            }
+        }
+        // Also scan latest (both user and assistant)
+        for (const text of [payload.latest.user_query, payload.latest.assistant_response]) {
+            if (!text)
+                continue;
+            STUB_REGEX.lastIndex = 0;
+            const matches = text.match(STUB_REGEX);
+            if (matches) {
+                for (const match of matches)
+                    stubs.add(match);
+            }
+        }
+        if (stubs.size === 0)
+            return;
+        console.log(`[Restore] Detected ${stubs.size} stubs, rehydrating...`);
+        try {
+            const url = `${MEMORY_API_URL}/api/v1/context/rehydrate`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ stubs: Array.from(stubs) }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!response.ok) {
+                console.warn(`[Restore] Rehydration API failed: ${response.status}`);
+                return;
+            }
+            const { rehydrated } = await response.json();
+            if (!rehydrated || !Array.isArray(rehydrated))
+                return;
+            // Create mapping of stub -> content
+            const stubMap = new Map();
+            for (const entry of rehydrated) {
+                const content = entry.messages.map((m) => {
+                    const role = m.role === 'user' ? 'U' : 'A';
+                    const text = typeof m.content === 'string'
+                        ? m.content
+                        : Array.isArray(m.content)
+                            ? m.content.map((b) => b.text || '').join('\n')
+                            : '';
+                    return `${role}: ${text}`;
+                }).join('\n\n');
+                stubMap.set(entry.stub, content);
+            }
+            // Replace stubs in turns
+            for (const turn of payload.restored_turns) {
+                for (const [stub, content] of stubMap.entries()) {
+                    turn.assistant_response = turn.assistant_response.replace(stub, `[REHYDRATED CONTENT]\n${content}`);
+                }
+            }
+            // Replace stubs in latest
+            for (const [stub, content] of stubMap.entries()) {
+                payload.latest.assistant_response = payload.latest.assistant_response.replace(stub, `[REHYDRATED CONTENT]\n${content}`);
+            }
+            console.log(`[Restore] Successfully rehydrated ${stubMap.size} stubs`);
+        }
+        catch (err) {
+            console.warn(`[Restore] Rehydration error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /**
      * Tier -1: Restore from stream log (has mid-turn content)
      * This is checked FIRST because stream logs have the most recent data,

package/dist/utils/log-rotate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rotate a log file if it exceeds the maximum size.
+ * Shifts existing backups up (e.g., .1 → .2, .2 → .3) and deletes the oldest if it exceeds maxBackups.
+ *
+ * @param logPath - Path to the log file
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ * @param maxBackups - Maximum number of backup files to keep (default: 3)
+ */
+export declare function rotateLogIfNeeded(logPath: string, maxBytes?: number, maxBackups?: number): void;
+/**
+ * Append a message to a log file, rotating it first if needed.
+ * Creates the directory if it doesn't exist.
+ *
+ * @param logPath - Path to the log file
+ * @param message - Message to append
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ */
+export declare function appendLog(logPath: string, message: string, maxBytes?: number): void;

package/dist/utils/log-rotate.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rotateLogIfNeeded = rotateLogIfNeeded;
+exports.appendLog = appendLog;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Rotate a log file if it exceeds the maximum size.
+ * Shifts existing backups up (e.g., .1 → .2, .2 → .3) and deletes the oldest if it exceeds maxBackups.
+ *
+ * @param logPath - Path to the log file
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ * @param maxBackups - Maximum number of backup files to keep (default: 3)
+ */
+function rotateLogIfNeeded(logPath, maxBytes = 5 * 1024 * 1024, maxBackups = 3) {
+    try {
+        // Check if log file exists and get its size
+        if (!fs_1.default.existsSync(logPath)) {
+            return;
+        }
+        const stats = fs_1.default.statSync(logPath);
+        if (stats.size < maxBytes) {
+            return; // No rotation needed
+        }
+        // Delete the oldest backup if it would exceed maxBackups
+        const oldestBackup = `${logPath}.${maxBackups}`;
+        if (fs_1.default.existsSync(oldestBackup)) {
+            fs_1.default.unlinkSync(oldestBackup);
+        }
+        // Shift existing backups up (e.g., .2 → .3, .1 → .2)
+        for (let i = maxBackups - 1; i >= 1; i--) {
+            const currentBackup = `${logPath}.${i}`;
+            const nextBackup = `${logPath}.${i + 1}`;
+            if (fs_1.default.existsSync(currentBackup)) {
+                fs_1.default.renameSync(currentBackup, nextBackup);
+            }
+        }
+        // Rotate the current log to .1
+        fs_1.default.renameSync(logPath, `${logPath}.1`);
+    }
+    catch (error) {
+        // Silently fail - logging utilities should never crash the caller
+        // In a production scenario, you might want to log this to stderr or a separate error log
+        // console.error('[log-rotate] Failed to rotate log:', error);
+    }
+}
+/**
+ * Append a message to a log file, rotating it first if needed.
+ * Creates the directory if it doesn't exist.
+ *
+ * @param logPath - Path to the log file
+ * @param message - Message to append
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ */
+function appendLog(logPath, message, maxBytes) {
+    try {
+        // Create directory if it doesn't exist
+        const dir = path_1.default.dirname(logPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // Rotate if needed
+        rotateLogIfNeeded(logPath, maxBytes);
+        // Append message
+        fs_1.default.appendFileSync(logPath, message + '\n', 'utf8');
+    }
+    catch (error) {
+        // Silently fail - logging utilities should never crash the caller
+        // console.error('[log-rotate] Failed to append log:', error);
+    }
+}

package/dist/utils/platform.d.ts

@@ -15,6 +15,8 @@ export declare const CLAUDE_AGENTS_DIR: string;
 export declare const CLAUDE_PLUGINS_DIR: string;
 export declare const CLAUDE_STATE_DIR: string;
 export declare const CLAUDE_MD: string;
+export declare const CLAUDE_RULES_DIR: string;
+export declare const CLAUDE_EKKOS_RULES: string;
 export declare const CURSOR_DIR: string;
 export declare const CURSOR_MCP: string;
 export declare const WINDSURF_DIR: string;

package/dist/utils/platform.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WINDSURF_MCP = exports.WINDSURF_DIR = exports.CURSOR_MCP = exports.CURSOR_DIR = exports.CLAUDE_MD = exports.CLAUDE_STATE_DIR = exports.CLAUDE_PLUGINS_DIR = exports.CLAUDE_AGENTS_DIR = exports.CLAUDE_SKILLS_DIR = exports.CLAUDE_HOOKS_DIR = exports.CLAUDE_SETTINGS = exports.CLAUDE_CONFIG = exports.CLAUDE_DIR = exports.EKKOS_CONFIG = exports.EKKOS_DIR = exports.HOME_DIR = exports.MCP_API_URL = exports.PLATFORM_URL = exports.isLinux = exports.isMac = exports.isWindows = void 0;
+exports.WINDSURF_MCP = exports.WINDSURF_DIR = exports.CURSOR_MCP = exports.CURSOR_DIR = exports.CLAUDE_EKKOS_RULES = exports.CLAUDE_RULES_DIR = exports.CLAUDE_MD = exports.CLAUDE_STATE_DIR = exports.CLAUDE_PLUGINS_DIR = exports.CLAUDE_AGENTS_DIR = exports.CLAUDE_SKILLS_DIR = exports.CLAUDE_HOOKS_DIR = exports.CLAUDE_SETTINGS = exports.CLAUDE_CONFIG = exports.CLAUDE_DIR = exports.EKKOS_CONFIG = exports.EKKOS_DIR = exports.HOME_DIR = exports.MCP_API_URL = exports.PLATFORM_URL = exports.isLinux = exports.isMac = exports.isWindows = void 0;
 exports.detectInstalledIDEs = detectInstalledIDEs;
 exports.detectCurrentIDE = detectCurrentIDE;
 const os_1 = require("os");
@@ -24,6 +24,8 @@ exports.CLAUDE_AGENTS_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'agents');
 exports.CLAUDE_PLUGINS_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'plugins', 'ekkos');
 exports.CLAUDE_STATE_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'state');
 exports.CLAUDE_MD = (0, path_1.join)(exports.CLAUDE_DIR, 'CLAUDE.md');
+exports.CLAUDE_RULES_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'rules');
+exports.CLAUDE_EKKOS_RULES = (0, path_1.join)(exports.CLAUDE_RULES_DIR, 'ekkos.md');
 exports.CURSOR_DIR = (0, path_1.join)(exports.HOME_DIR, '.cursor');
 exports.CURSOR_MCP = (0, path_1.join)(exports.CURSOR_DIR, 'mcp.json');
 exports.WINDSURF_DIR = (0, path_1.join)(exports.HOME_DIR, '.codeium', 'windsurf');

package/dist/utils/session-binding.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bind the real session name to the proxy
+ * This replaces the '_pending' placeholder for this user, enabling proper eviction
+ */
+export declare function bindSession(realSession: string, projectPath: string, pendingSession?: string): Promise<boolean>;

package/dist/utils/session-binding.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindSession = bindSession;
+const state_1 = require("./state");
+const MEMORY_API_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.dev';
+/**
+ * Bind the real session name to the proxy
+ * This replaces the '_pending' placeholder for this user, enabling proper eviction
+ */
+async function bindSession(realSession, projectPath, pendingSession) {
+    try {
+        // Get userId same way as run.ts
+        const config = (0, state_1.getConfig)();
+        let userId = config?.userId;
+        if (!userId || userId === 'anonymous') {
+            const token = (0, state_1.getAuthToken)();
+            if (token?.startsWith('ekk_')) {
+                const parts = token.split('_');
+                if (parts.length >= 2) {
+                    userId = parts[1];
+                }
+            }
+        }
+        if (!userId || userId === 'anonymous')
+            return false;
+        // Use global fetch (Node 18+)
+        const response = await fetch(`${MEMORY_API_URL}/proxy/session/bind`, {
+            method: 'POST',
+            signal: AbortSignal.timeout(2500),
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                userId,
+                realSession,
+                projectPath,
+                pendingSession: pendingSession || null,
+            })
+        });
+        return response.ok;
+    }
+    catch (err) {
+        // Fail silently - don't crash CLI
+        return false;
+    }
+}

package/dist/utils/state.js

@@ -341,6 +341,10 @@ function getActiveSessionByName(sessionName) {
  * Check if a process is still alive
  */
 function isProcessAlive(pid) {
+    // pid <= 1 (including 0 placeholders from hooks) are not valid user processes.
+    if (!Number.isInteger(pid) || pid <= 1) {
+        return false;
+    }
     try {
         // Sending signal 0 doesn't kill the process, just checks if it exists
         process.kill(pid, 0);

package/dist/utils/verify-remote-terminal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Remote Terminal Verification Script
+ *
+ * Systematically verifies that all remote terminal components are properly configured
+ * and working correctly. Run this after setup-remote to validate the installation.
+ */
+/**
+ * Run all verification tests
+ */
+export declare function verifyRemoteTerminal(): Promise<void>;