@ekkos/cli 1.2.18 → 1.3.0

package/dist/commands/dashboard.js

@@ -361,7 +361,7 @@ function findLatestJsonl(projectPath, createdAfterMs) {
         projectPath.replace(/\//g, '-'), // macOS: /Users/name → -Users-name
     ]);
     const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
-    for (const encoded of candidateEncodings) {
+    for (const encoded of Array.from(candidateEncodings)) {
         const projectDir = path.join(projectsRoot, encoded);
         if (!fs.existsSync(projectDir))
             continue;
@@ -392,7 +392,7 @@ function findJsonlBySessionId(projectPath, sessionId) {
         projectPath.replace(/\//g, '-'),
     ]);
     const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
-    for (const encoded of candidateEncodings) {
+    for (const encoded of Array.from(candidateEncodings)) {
         const exactPath = path.join(projectsRoot, encoded, `${sessionId}.jsonl`);
         if (fs.existsSync(exactPath))
             return exactPath;
@@ -425,15 +425,11 @@ async function waitForNewSession() {
     catch { }
     console.log(chalk_1.default.gray('  Waiting for new session to start...'));
     const maxWaitMs = 120000; // 2 minutes max
-    const pollMs = 3000;
+    const pollMs = 1000; // 1s poll — faster than before since we exit early
     const startWait = Date.now();
     let candidateName = null;
     while (Date.now() - startWait < maxWaitMs) {
         // ── Windows hook hint file ──────────────────────────────────────────────
-        // On Windows, active-sessions.json is never populated because hook processes
-        // are short-lived and their PIDs are dead by the time we poll. Instead, the
-        // user-prompt-submit.ps1 hook writes ~/.ekkos/hook-session-hint.json with
-        // { sessionName, sessionId, projectPath, ts } on every turn. Read it here.
         const hintPath = path.join(state_js_1.EKKOS_DIR, 'hook-session-hint.json');
         try {
             if (fs.existsSync(hintPath)) {
@@ -443,37 +439,34 @@ async function waitForNewSession() {
                     const jsonlPath = findJsonlBySessionId(hint.projectPath, hint.sessionId || '')
                         || findLatestJsonl(hint.projectPath, launchTs)
                         || resolveJsonlPath(hint.sessionName, launchTs);
-                    if (jsonlPath) {
-                        console.log(chalk_1.default.green(`  Found session (hook hint): ${hint.sessionName}`));
-                        return { sessionName: hint.sessionName, jsonlPath };
-                    }
+                    // Return immediately — JSONL may be null; dashboard will lazy-resolve
+                    console.log(chalk_1.default.green(`  Found session (hook hint): ${hint.sessionName}`));
+                    return { sessionName: hint.sessionName, jsonlPath, launchCwd: hint.projectPath || launchCwd, launchTs };
                 }
             }
         }
         catch { /* ignore */ }
         // ── Standard: active-sessions.json (works on Mac/Linux) ────────────────
         const sessions = (0, state_js_1.getActiveSessions)();
-        // Find sessions that started after our launch
         for (const s of sessions) {
             const startedMs = new Date(s.startedAt).getTime();
             if (startedMs >= launchTs - 2000) {
                 candidateName = s.sessionName;
-                // Try standard resolution (works when session bind has happened with real UUID)
-                const jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
-                if (jsonlPath) {
-                    console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
-                    return { sessionName: s.sessionName, jsonlPath };
-                }
-                // Try all unique projectPaths for this session name (bind may create second entry)
-                const allPaths = new Set(sessions.filter(x => x.sessionName === s.sessionName && x.projectPath)
-                    .map(x => x.projectPath));
-                for (const pp of allPaths) {
-                    const latestJsonl = findLatestJsonl(pp, launchTs);
-                    if (latestJsonl) {
-                        console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
-                        return { sessionName: s.sessionName, jsonlPath: latestJsonl };
+                // Try to resolve JSONL immediately (may succeed if Claude already created it)
+                let jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
+                if (!jsonlPath) {
+                    const allPaths = new Set(sessions.filter(x => x.sessionName === s.sessionName && x.projectPath)
+                        .map(x => x.projectPath));
+                    for (const pp of Array.from(allPaths)) {
+                        jsonlPath = findLatestJsonl(pp, launchTs);
+                        if (jsonlPath)
+                            break;
                     }
                 }
+                // Return immediately with session name — JSONL may still be null
+                // (Claude Code hasn't created it yet). Dashboard will lazy-resolve.
+                console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
+                return { sessionName: s.sessionName, jsonlPath, launchCwd: s.projectPath || launchCwd, launchTs };
             }
         }
         // Fallback: use launch CWD to find any new JSONL
@@ -482,12 +475,10 @@ async function waitForNewSession() {
             if (latestJsonl) {
                 const name = candidateName || path.basename(latestJsonl, '.jsonl');
                 console.log(chalk_1.default.green(`  Found session via CWD: ${name}`));
-                return { sessionName: name, jsonlPath: latestJsonl };
+                return { sessionName: name, jsonlPath: latestJsonl, launchCwd, launchTs };
             }
         }
-        // Broad fallback: scan ALL project directories for any new JSONL (Windows safety net).
-        // Claude creates the JSONL immediately when a session starts, before the first message.
-        // This catches cases where path encoding doesn't match.
+        // Broad fallback: scan ALL project directories for any new JSONL
         {
             const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
             try {
@@ -512,12 +503,11 @@ async function waitForNewSession() {
                         .sort((a, b) => b.birthtime - a.birthtime);
                     if (allNewJsonl.length > 0) {
                         const jsonlPath = allNewJsonl[0].path;
-                        // Derive name from filename (e.g. abc123.jsonl → use candidateName if set, else basename)
                         const baseName = path.basename(jsonlPath, '.jsonl');
                         const derivedName = /^[0-9a-f]{8}-/.test(baseName) ? (0, state_js_1.uuidToWords)(baseName) : baseName;
                         const name = candidateName || derivedName;
                         console.log(chalk_1.default.green(`  Found session via scan: ${name}`));
-                        return { sessionName: name, jsonlPath };
+                        return { sessionName: name, jsonlPath, launchCwd, launchTs };
                     }
                 }
             }
@@ -526,20 +516,18 @@ async function waitForNewSession() {
         await sleep(pollMs);
         process.stdout.write(chalk_1.default.gray('.'));
     }
-    // Timeout — try one more time with the candidate name (still use birthtime filter)
+    // Timeout — return candidate if we have one (dashboard will lazy-resolve JSONL)
     if (candidateName) {
-        console.log(chalk_1.default.yellow(`\n  Timeout. Trying ${candidateName} anyway...`));
+        console.log(chalk_1.default.yellow(`\n  Timeout. Launching with ${candidateName}...`));
         const jsonlPath = resolveJsonlPath(candidateName, launchTs);
-        if (jsonlPath)
-            return { sessionName: candidateName, jsonlPath };
+        return { sessionName: candidateName, jsonlPath, launchCwd, launchTs };
     }
     // Last resort: latest session overall
     const latestName = getLatestSession();
     if (latestName) {
         console.log(chalk_1.default.yellow(`\n  Falling back to latest: ${latestName}`));
         const jsonlPath = resolveJsonlPath(latestName);
-        if (jsonlPath)
-            return { sessionName: latestName, jsonlPath };
+        return { sessionName: latestName, jsonlPath, launchCwd, launchTs };
     }
     console.log(chalk_1.default.red('  No session found.'));
     process.exit(1);
@@ -548,7 +536,8 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 // ── TUI Dashboard ──
-async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
+async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs, launchCwd, launchTs) {
+    let jsonlPath = initialJsonlPath;
     let sessionName = displaySessionName(initialSessionName);
     const blessed = require('blessed');
     const contrib = require('blessed-contrib');
@@ -958,11 +947,30 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     }
     function updateDashboard() {
         ensureLayoutSynced();
+        // ── Lazy JSONL resolution ──────────────────────────────────────────────
+        // Dashboard may launch before Claude Code creates the JSONL file.
+        // Keep trying to find it on each poll tick.
+        if (!jsonlPath || !fs.existsSync(jsonlPath)) {
+            const resolved = resolveJsonlPath(initialSessionName, launchTs)
+                || (launchCwd ? findLatestJsonl(launchCwd, launchTs) : null);
+            if (resolved) {
+                jsonlPath = resolved;
+                dlog(`Lazy-resolved JSONL: ${jsonlPath}`);
+            }
+            else {
+                // Still no JSONL — render the header/footer so the dashboard isn't blank
+                renderHeader();
+                try {
+                    screen.render();
+                }
+                catch { }
+                return;
+            }
+        }
         // Resolve "initializing" → real session name from JSONL UUID filename
         if (sessionName === 'initializing' || sessionName === 'session') {
             try {
                 const basename = path.basename(jsonlPath, '.jsonl');
-                // JSONL filename is the session UUID (e.g., 607bd8e4-0a04-4db2-acf5-3f794be0f956.jsonl)
                 if (/^[0-9a-f]{8}-/.test(basename)) {
                     sessionName = displaySessionName(basename);
                     screen.title = `ekkOS - ${sessionName}`;
@@ -1057,24 +1065,24 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
             // wrap by one char if this is too tight, which pushes Cost to next line.
             const w = Math.max(18, turnBox.width - 4); // usable content width
             const div = '│';
-            function pad(s, width) {
+            const pad = (s, width) => {
                 if (s.length >= width)
                     return s.slice(0, width);
                 return s + ' '.repeat(width - s.length);
-            }
-            function rpad(s, width) {
+            };
+            const rpad = (s, width) => {
                 if (s.length >= width)
                     return s.slice(0, width);
                 return ' '.repeat(width - s.length) + s;
-            }
-            function cpad(s, width) {
+            };
+            const cpad = (s, width) => {
                 if (s.length >= width)
                     return s.slice(0, width);
                 const total = width - s.length;
                 const left = Math.floor(total / 2);
                 const right = total - left;
                 return ' '.repeat(left) + s + ' '.repeat(right);
-            }
+            };
             // Data rows — RENDER ALL TURNS for full scrollback history
             // Don't slice to visibleRows only — let user scroll through entire session
             const turns = data.turns.slice().reverse();
@@ -1443,10 +1451,10 @@ exports.dashboardCommand = new commander_1.Command('dashboard')
     .option('--compact', 'Minimal layout for small terminals')
     .action(async (sessionNameArg, options) => {
     const refreshMs = parseInt(options.refresh) || 2000;
-    // --wait-for-new: poll until a brand new session appears
+    // --wait-for-new: poll until session name appears (JSONL may not exist yet)
     if (options.waitForNew) {
-        const { sessionName, jsonlPath } = await waitForNewSession();
-        await launchDashboard(sessionName, jsonlPath, refreshMs);
+        const result = await waitForNewSession();
+        await launchDashboard(result.sessionName, result.jsonlPath, refreshMs, result.launchCwd, result.launchTs);
         return;
     }
     let sessionName = null;

package/dist/commands/hooks.d.ts

@@ -1,12 +1,16 @@
 /**
- * ekkOS CLI: hooks subcommand
- * Implements: ekkos hooks install | verify | status
+ * ekkOS CLI: hooks subcommand — DEPRECATED
  *
- * Per ekkOS Onboarding Spec v1.2 + Addendum:
- * - Manifest-driven deployment
- * - SHA256 checksum verification
- * - Installed-state manifest tracking
+ * Hooks are no longer needed. ekkOS CLI and proxy handle everything.
+ * Use `ekkos run` to start.
+ *
+ * This command is kept for backwards compatibility. The install/verify/status
+ * subcommands print a deprecation notice and exit cleanly. Utility functions
+ * (findProjectRoot, expandPath, loadManifest) are preserved for internal use
+ * by other commands (e.g. doctor).
  */
+export declare function expandPath(p: string): string;
+export declare function findProjectRoot(startDir?: string): string;
 interface ManifestFile {
     source: string;
     destination: string;
@@ -61,49 +65,34 @@ interface Manifest {
         checksumAlgorithm: string;
     };
 }
-interface VerifyResult {
-    status: 'PASS' | 'WARN' | 'FAIL';
-    issues: Array<{
-        severity: 'error' | 'warning';
-        file?: string;
-        message: string;
-    }>;
-}
-declare function expandPath(p: string): string;
-/**
- * Find the ekkos-manifest.json file
- * Search order per spec:
- * 1. <packageRoot>/templates/ekkos-manifest.json
- * 2. <distRoot>/../templates/ekkos-manifest.json
- * 3. In monorepo dev: <repoRoot>/templates/ekkos-manifest.json
- */
 export declare function findManifest(): {
     path: string;
     templatesDir: string;
 } | null;
-/**
- * Load manifest from disk
- */
 export declare function loadManifest(): {
     manifest: Manifest;
     path: string;
     templatesDir: string;
 } | null;
-declare function findProjectRoot(startDir?: string): string;
-interface InstallOptions {
+export interface VerifyResult {
+    status: 'PASS' | 'WARN' | 'FAIL';
+    issues: Array<{
+        severity: 'error' | 'warning';
+        file?: string;
+        message: string;
+    }>;
+}
+export declare function hooksInstall(_options: {
     global?: boolean;
     project?: boolean;
     verbose?: boolean;
-}
-export declare function hooksInstall(options: InstallOptions): Promise<void>;
-interface VerifyOptions {
+}): Promise<void>;
+export declare function hooksVerify(_options: {
     global?: boolean;
     project?: boolean;
     verbose?: boolean;
-}
-export declare function hooksVerify(options: VerifyOptions): Promise<VerifyResult>;
-interface StatusOptions {
+}): Promise<VerifyResult>;
+export declare function hooksStatus(_options: {
     verbose?: boolean;
-}
-export declare function hooksStatus(options: StatusOptions): Promise<void>;
-export { findProjectRoot, expandPath };
+}): Promise<void>;
+export {};