@ekkos/cli 1.2.18 → 1.3.1

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,38 +1065,39 @@ 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();
             let header = '';
             let separator = '';
             let rows = [];
-            // Always show all 7 columns: Turn, Model, Context, Cache Rd, Cache Wr, Output, Cost
+            // Always show all 8 columns: Turn, Time, Model, Context, Cache Rd, Cache Wr, Output, Cost
             // Shrink flex columns to fit narrow panes instead of dropping them.
             const colNum = 4;
+            const colTime = 8; // "HH:MM:SS" or "H:MM AM"
             const colM = 7;
             const colCtx = 7;
             const colCost = 8;
-            const nDividers = 6;
-            const fixedW = colNum + colM + colCtx + colCost;
+            const nDividers = 7;
+            const fixedW = colNum + colTime + colM + colCtx + colCost;
             const flexTotal = Math.max(0, w - fixedW - nDividers);
             let rdW = Math.max(5, Math.floor(flexTotal * 0.35));
             let wrW = Math.max(5, Math.floor(flexTotal * 0.30));
@@ -1110,14 +1119,30 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                     rdW -= trimRd;
                 }
             }
-            header = `{bold}${pad('Turn', colNum)}${div}${pad('Model', colM)}${div}${pad('Context', colCtx)}${div}${rpad('Cache Rd', rdW)}${div}${rpad('Cache Wr', wrW)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}{/bold}`;
-            separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(rdW)}┼${'─'.repeat(wrW)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}{/gray-fg}`;
+            // Format turn timestamp to short time string
+            const fmtTime = (iso) => {
+                if (!iso)
+                    return '--:--';
+                try {
+                    const d = new Date(iso);
+                    const h = d.getHours();
+                    const m = d.getMinutes().toString().padStart(2, '0');
+                    const s = d.getSeconds().toString().padStart(2, '0');
+                    return `${h}:${m}:${s}`;
+                }
+                catch {
+                    return '--:--';
+                }
+            };
+            header = `{bold}${pad('Turn', colNum)}${div}${pad('Time', colTime)}${div}${pad('Model', colM)}${div}${pad('Context', colCtx)}${div}${rpad('Cache Rd', rdW)}${div}${rpad('Cache Wr', wrW)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}{/bold}`;
+            separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colTime)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(rdW)}┼${'─'.repeat(wrW)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}{/gray-fg}`;
             rows = turns.map(t => {
                 const mTag = modelTag(t.routedModel);
                 const mColor = t.routedModel.includes('haiku') ? 'green' : t.routedModel.includes('sonnet') ? 'blue' : 'magenta';
                 const costFlag = t.cost > 1.0 ? '{red-fg}' : t.cost > 0.5 ? '{yellow-fg}' : '{white-fg}';
                 const costEnd = t.cost > 1.0 ? '{/red-fg}' : t.cost > 0.5 ? '{/yellow-fg}' : '{/white-fg}';
                 return (pad(String(t.turn), colNum) + div +
+                    `{gray-fg}${pad(fmtTime(t.timestamp), colTime)}{/gray-fg}` + div +
                     `{${mColor}-fg}${pad(mTag, colM)}{/${mColor}-fg}` + div +
                     pad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
                     `{green-fg}${rpad(fmtK(t.cacheRead), rdW)}{/green-fg}` + div +
@@ -1212,9 +1237,22 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
             return null;
         }
     }
-    async function updateWindowBox() {
+    // Cache last fetched usage data so the countdown can tick every second
+    let cachedUsage = null;
+    // Fetch fresh usage data from API (called every 15s)
+    async function fetchAndCacheUsage() {
+        try {
+            cachedUsage = await fetchAnthropicUsage();
+        }
+        catch (err) {
+            dlog(`Window fetch: ${err.message}`);
+        }
+        renderWindowBox();
+    }
+    // Render countdown from cached data (called every 1s)
+    function renderWindowBox() {
         try {
-            const usage = await fetchAnthropicUsage();
+            const usage = cachedUsage;
             let line1 = ' {gray-fg}No usage data{/gray-fg}';
             let line2 = '';
             // ── 5h Window (from Anthropic OAuth API) ──
@@ -1222,26 +1260,38 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                 const pct = usage.five_hour.utilization;
                 const resetAt = new Date(usage.five_hour.resets_at).getTime();
                 const remainMs = Math.max(0, resetAt - Date.now());
-                const remainMin = Math.round(remainMs / 60000);
-                const rH = Math.floor(remainMin / 60);
-                const rM = remainMin % 60;
+                const remainSec = Math.round(remainMs / 1000);
+                const rH = Math.floor(remainSec / 3600);
+                const rM = Math.floor((remainSec % 3600) / 60);
+                const rS = remainSec % 60;
                 const pctColor = pct < 50 ? 'green' : pct < 80 ? 'yellow' : 'red';
-                const timeColor = remainMin > 120 ? 'green' : remainMin > 60 ? 'yellow' : 'red';
+                const countdown = `${rH}h${rM.toString().padStart(2, '0')}m${rS.toString().padStart(2, '0')}s`;
+                const resetDate = new Date(resetAt);
+                const resetTime = resetDate.toLocaleString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: '2-digit' });
                 line1 = ` {bold}5h:{/bold}` +
                     ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
-                    `  {${timeColor}-fg}${rH}h${rM}m left{/${timeColor}-fg}`;
+                    `  {${pctColor}-fg}⏱ ${countdown}{/${pctColor}-fg}` +
+                    `  resets ${resetTime}`;
             }
             // ── Weekly (from Anthropic OAuth API) ──
             if (usage?.seven_day) {
                 const pct = usage.seven_day.utilization;
                 const resetAt = new Date(usage.seven_day.resets_at);
-                const dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-                const resetDay = dayNames[resetAt.getDay()];
-                const resetHour = resetAt.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+                const remainMs = Math.max(0, resetAt.getTime() - Date.now());
+                const remainSec = Math.round(remainMs / 1000);
+                const rD = Math.floor(remainSec / 86400);
+                const rH = Math.floor((remainSec % 86400) / 3600);
+                const rM = Math.floor((remainSec % 3600) / 60);
+                const rS = remainSec % 60;
                 const pctColor = pct < 50 ? 'green' : pct < 80 ? 'yellow' : 'red';
+                const countdown = rD > 0
+                    ? `${rD}d${rH}h${rM.toString().padStart(2, '0')}m`
+                    : `${rH}h${rM.toString().padStart(2, '0')}m${rS.toString().padStart(2, '0')}s`;
+                const resetTime = resetAt.toLocaleString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: '2-digit' });
                 line2 = ` {bold}Week:{/bold}` +
                     ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
-                    `  resets ${resetDay} ${resetHour}`;
+                    `  {${pctColor}-fg}⏱ ${countdown}{/${pctColor}-fg}` +
+                    `  resets ${resetTime}`;
             }
             windowBox.setContent(line1 + (line2 ? '\n' + line2 : ''));
         }
@@ -1254,6 +1304,8 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         }
         catch { }
     }
+    // Legacy wrapper for backward compat
+    async function updateWindowBox() { await fetchAndCacheUsage(); }
     // ── Handle terminal resize ──
     // Recalculate all widget positions from new screen.height
     screen.on('resize', () => {
@@ -1284,6 +1336,7 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     screen.key(['C-c'], () => {
         clearInterval(pollInterval);
         clearInterval(windowPollInterval);
+        clearInterval(countdownInterval);
         clearInterval(headerAnimInterval);
         clearInterval(fortuneInterval);
         screen.destroy();
@@ -1293,6 +1346,7 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         screen.key(['q'], () => {
             clearInterval(pollInterval);
             clearInterval(windowPollInterval);
+            clearInterval(countdownInterval);
             clearInterval(headerAnimInterval);
             clearInterval(fortuneInterval);
             screen.destroy();
@@ -1400,7 +1454,8 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         fortuneText = activeFortunes[fortuneIdx];
         renderHeader();
     }, 30000);
-    const windowPollInterval = setInterval(updateWindowBox, 15000); // every 15s
+    const windowPollInterval = setInterval(fetchAndCacheUsage, 15000); // fetch fresh data every 15s
+    const countdownInterval = setInterval(renderWindowBox, 1000); // tick countdown every 1s
 }
 // ── Helpers ──
 function fmtK(n) {
@@ -1443,10 +1498,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 {};