@shepai/cli 1.147.0 → 1.148.0-pr462.42531fe

package/dist/src/presentation/web/hooks/use-deploy-action.js

@@ -27,34 +27,9 @@ export function useDeployAction(input) {
             mountedRef.current = false;
         };
     }, []);
-    // Fetch status on mount — recover running dev servers after page reload
-    useEffect(() => {
-        if (!input)
-            return;
-        let cancelled = false;
-        (async () => {
-            try {
-                const result = await getDeploymentStatus(input.targetId);
-                if (cancelled || !mountedRef.current)
-                    return;
-                if (result && result.state !== 'Stopped') {
-                    log.info(`mount recovery: "${input.targetId}" state=${result.state}, url=${result.url}`);
-                    setStatus(result.state);
-                    setUrl(result.url);
-                    startPolling(input.targetId);
-                }
-            }
-            catch {
-                // Server container may not be available (e.g., in tests)
-                log.debug(`mount recovery failed for "${input.targetId}" — ignoring`);
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-        // Only run on mount (input identity is stable from the caller)
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [input?.targetId]);
+    // Mount recovery removed — getGraphData() already enriches nodes with
+    // deployment status (get-graph-data.ts lines 180-200). No need to call
+    // a server action per node on every mount.
     // Cleanup on unmount
     useEffect(() => {
         return () => {
@@ -108,32 +83,11 @@ export function useDeployAction(input) {
             }
         }, POLL_INTERVAL);
     }, [stopPolling]);
-    // Idle poll — when no deployment is known, periodically check if one was
-    // started externally (e.g., from the drawer while the repo node is mounted).
-    const IDLE_POLL_INTERVAL = 5000;
-    useEffect(() => {
-        if (!input || status !== null)
-            return;
-        const timer = setInterval(async () => {
-            if (!mountedRef.current)
-                return;
-            try {
-                const result = await getDeploymentStatus(input.targetId);
-                if (!mountedRef.current)
-                    return;
-                if (result && result.state !== 'Stopped') {
-                    log.info(`idle poll: "${input.targetId}" state=${result.state}, url=${result.url}`);
-                    setStatus(result.state);
-                    setUrl(result.url);
-                    startPolling(input.targetId);
-                }
-            }
-            catch {
-                // ignore
-            }
-        }, IDLE_POLL_INTERVAL);
-        return () => clearInterval(timer);
-    }, [input, status, startPolling]);
+    // Idle poll removed — it was calling getDeploymentStatus every 5s for EVERY
+    // node on the canvas (~25 nodes = ~5 server action calls/sec). The mount
+    // recovery effect above (line 57) already checks on mount. Deployments
+    // started externally (e.g., from the drawer) should update the node via
+    // reconcile from the graph-data poll instead.
     const handleDeploy = useCallback(async () => {
         if (!input) {
             log.warn('deploy() called but input is null — no-op');

package/dist/src/presentation/web/lib/session-scanner.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared session scanning logic used by both /api/sessions and /api/sessions-batch.
+ *
+ * Scans Claude Code and Cursor session directories for JSONL session files,
+ * parsing headers to extract preview, message count, and timestamps.
+ */
+export interface SessionResult {
+    id: string;
+    agentType: string;
+    preview: string | null;
+    messageCount: number;
+    firstMessageAt: string | null;
+    lastMessageAt: string | null;
+    createdAt: string | null;
+    projectPath: string;
+    filePath: string;
+    /** mtime for sorting — not sent to client */
+    _mtime: number;
+}
+export declare function scanClaudeSessions(repositoryPath: string, limit: number, includeWorktrees?: boolean): Promise<SessionResult[]>;
+export declare function scanCursorSessions(repositoryPath: string, limit: number): Promise<SessionResult[]>;
+/**
+ * Scan sessions for a single repository path from all providers.
+ * Merges and sorts by recency.
+ */
+export declare function scanSessionsForPath(repositoryPath: string, limit: number, includeWorktrees?: boolean): Promise<SessionResult[]>;
+//# sourceMappingURL=session-scanner.d.ts.map

package/dist/src/presentation/web/lib/session-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-scanner.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/session-scanner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;CAChB;AAsID,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACb,gBAAgB,UAAQ,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CA2C1B;AAiED,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,EAAE,CAAC,CA6D1B;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACb,gBAAgB,UAAQ,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CAS1B"}

package/dist/src/presentation/web/lib/session-scanner.js

@@ -0,0 +1,255 @@
+/**
+ * Shared session scanning logic used by both /api/sessions and /api/sessions-batch.
+ *
+ * Scans Claude Code and Cursor session directories for JSONL session files,
+ * parsing headers to extract preview, message count, and timestamps.
+ */
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readdir, stat } from 'node:fs/promises';
+// ── Path encoding helpers ─────────────────────────────────────────────
+/**
+ * Claude Code encodes paths by replacing '/', '\', '.' with '-'.
+ * e.g. /home/user/.shep/repos/abc → -home-user--shep-repos-abc
+ */
+function claudeEncodePath(p) {
+    return p.replace(/[/\\.]/g, '-');
+}
+/**
+ * Cursor encodes paths by stripping the leading '/', removing dots,
+ * and replacing '/' and '\' with '-'.
+ * e.g. /home/user/.shep/repos/abc → home-user-shep-repos-abc
+ */
+function cursorEncodePath(p) {
+    return p.replace(/^\//, '').replace(/\./g, '').replace(/[/\\]/g, '-');
+}
+// ── Shared helpers ────────────────────────────────────────────────────
+function extractText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (typeof block === 'object' && block !== null) {
+                const b = block;
+                if (b.type === 'text' && typeof b.text === 'string')
+                    return b.text;
+            }
+        }
+    }
+    return null;
+}
+const PREVIEW_READ_BYTES = 8_192; // 8KB is enough for first few messages
+// ── Claude Code session scanner ───────────────────────────────────────
+async function collectJsonlFiles(projectDir) {
+    let entries;
+    try {
+        entries = await readdir(projectDir);
+    }
+    catch {
+        return [];
+    }
+    const jsonlFiles = entries.filter((e) => e.endsWith('.jsonl'));
+    const fileInfos = await Promise.allSettled(jsonlFiles.map(async (name) => {
+        const filePath = join(projectDir, name);
+        const s = await stat(filePath);
+        return { name, filePath, mtime: s.mtime.getTime() };
+    }));
+    return fileInfos
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => r.value);
+}
+async function parseClaudeSession(filePath, fileName, mtime, repositoryPath) {
+    const { createReadStream } = await import('node:fs');
+    const id = fileName.replace('.jsonl', '');
+    let preview = null;
+    let firstTimestamp = null;
+    let messageCount = 0;
+    const head = await new Promise((resolve) => {
+        const chunks = [];
+        let size = 0;
+        const stream = createReadStream(filePath, { end: PREVIEW_READ_BYTES - 1 });
+        stream.on('data', (chunk) => {
+            chunks.push(chunk);
+            size += chunk.length;
+        });
+        stream.on('end', () => resolve(Buffer.concat(chunks, size).toString('utf-8')));
+        stream.on('error', () => resolve(''));
+    });
+    if (!head)
+        return null;
+    const lines = head.split('\n').filter((l) => l.trim());
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === 'user' || entry.type === 'assistant') {
+                const role = entry.message?.role;
+                if (role === 'user' || role === 'assistant') {
+                    messageCount++;
+                    if (entry.timestamp) {
+                        firstTimestamp ??= entry.timestamp;
+                    }
+                    if (role === 'user' && preview === null) {
+                        preview = extractText(entry.message?.content);
+                    }
+                }
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    if (messageCount === 0)
+        return null;
+    const mtimeIso = new Date(mtime).toISOString();
+    return {
+        id,
+        agentType: 'claude-code',
+        preview,
+        messageCount,
+        firstMessageAt: firstTimestamp,
+        lastMessageAt: mtimeIso,
+        createdAt: firstTimestamp ?? mtimeIso,
+        projectPath: repositoryPath,
+        filePath,
+        _mtime: mtime,
+    };
+}
+export async function scanClaudeSessions(repositoryPath, limit, includeWorktrees = false) {
+    const dirName = claudeEncodePath(repositoryPath);
+    const projectsRoot = join(homedir(), '.claude', 'projects');
+    const primaryDir = join(projectsRoot, dirName);
+    let allFiles = await collectJsonlFiles(primaryDir);
+    if (includeWorktrees) {
+        try {
+            const allDirs = await readdir(projectsRoot);
+            const prefixMatches = allDirs.filter((d) => d !== dirName && d.startsWith(dirName));
+            const normalizedRepoPath = repositoryPath.replace(/\\/g, '/');
+            const repoHash = createHash('sha256').update(normalizedRepoPath).digest('hex').slice(0, 16);
+            const shepHome = join(homedir(), '.shep').replace(/\\/g, '/');
+            const shepWorktreePrefix = claudeEncodePath(join(shepHome, 'repos', repoHash));
+            const shepMatches = allDirs.filter((d) => d.startsWith(shepWorktreePrefix) && !prefixMatches.includes(d) && d !== dirName);
+            const worktreeDirs = [...prefixMatches, ...shepMatches];
+            const worktreeResults = await Promise.all(worktreeDirs.map((d) => collectJsonlFiles(join(projectsRoot, d))));
+            for (const files of worktreeResults) {
+                allFiles = allFiles.concat(files);
+            }
+        }
+        catch {
+            // projectsRoot doesn't exist — no sessions at all
+        }
+    }
+    const valid = allFiles.sort((a, b) => b.mtime - a.mtime).slice(0, limit);
+    const results = await Promise.allSettled(valid.map(async (fi) => parseClaudeSession(fi.filePath, fi.name, fi.mtime, repositoryPath)));
+    return results
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((s) => s !== null);
+}
+// ── Cursor session scanner ────────────────────────────────────────────
+async function parseCursorSession(filePath, fileName, mtime, repositoryPath) {
+    const { createReadStream } = await import('node:fs');
+    const id = fileName.replace('.jsonl', '');
+    const head = await new Promise((resolve) => {
+        const chunks = [];
+        let size = 0;
+        const stream = createReadStream(filePath, { end: PREVIEW_READ_BYTES - 1 });
+        stream.on('data', (chunk) => {
+            chunks.push(chunk);
+            size += chunk.length;
+        });
+        stream.on('end', () => resolve(Buffer.concat(chunks, size).toString('utf-8')));
+        stream.on('error', () => resolve(''));
+    });
+    if (!head)
+        return null;
+    let preview = null;
+    let messageCount = 0;
+    const lines = head.split('\n').filter((l) => l.trim());
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.role === 'user' || entry.role === 'assistant') {
+                messageCount++;
+                if (entry.role === 'user' && preview === null) {
+                    preview = extractText(entry.message?.content);
+                }
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    if (messageCount === 0)
+        return null;
+    const mtimeIso = new Date(mtime).toISOString();
+    return {
+        id,
+        agentType: 'cursor',
+        preview,
+        messageCount,
+        firstMessageAt: mtimeIso,
+        lastMessageAt: mtimeIso,
+        createdAt: mtimeIso,
+        projectPath: repositoryPath,
+        filePath,
+        _mtime: mtime,
+    };
+}
+export async function scanCursorSessions(repositoryPath, limit) {
+    const dirName = cursorEncodePath(repositoryPath);
+    const transcriptsDir = join(homedir(), '.cursor', 'projects', dirName, 'agent-transcripts');
+    let entries;
+    try {
+        entries = await readdir(transcriptsDir);
+    }
+    catch {
+        return [];
+    }
+    const fileInfos = await Promise.allSettled(entries.map(async (entry) => {
+        const entryPath = join(transcriptsDir, entry);
+        const s = await stat(entryPath);
+        if (s.isFile() && entry.endsWith('.jsonl')) {
+            return { name: entry, filePath: entryPath, mtime: s.mtime.getTime() };
+        }
+        if (s.isDirectory()) {
+            const jsonlPath = join(entryPath, `${entry}.jsonl`);
+            try {
+                const jsonlStat = await stat(jsonlPath);
+                return {
+                    name: `${entry}.jsonl`,
+                    filePath: jsonlPath,
+                    mtime: jsonlStat.mtime.getTime(),
+                };
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }));
+    const valid = fileInfos
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((v) => v !== null)
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, limit);
+    const results = await Promise.allSettled(valid.map(async (fi) => parseCursorSession(fi.filePath, fi.name, fi.mtime, repositoryPath)));
+    return results
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((s) => s !== null);
+}
+/**
+ * Scan sessions for a single repository path from all providers.
+ * Merges and sorts by recency.
+ */
+export async function scanSessionsForPath(repositoryPath, limit, includeWorktrees = false) {
+    const [claudeSessions, cursorSessions] = await Promise.all([
+        scanClaudeSessions(repositoryPath, limit, includeWorktrees),
+        scanCursorSessions(repositoryPath, limit),
+    ]);
+    return [...claudeSessions, ...cursorSessions]
+        .sort((a, b) => b._mtime - a._mtime)
+        .slice(0, Math.min(limit, 50));
+}