@proletariat/cli 0.3.35 → 0.3.36

package/dist/commands/session/health.js

@@ -5,32 +5,13 @@ import Database from 'better-sqlite3';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
 import { ExecutionStorage } from '../../lib/execution/index.js';
-import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findSessionForExecution, } from '../../lib/execution/session-utils.js';
+import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findSessionForExecution, captureTmuxPane, } from '../../lib/execution/session-utils.js';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { visualPadEnd } from '../../lib/string-utils.js';
 import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 // =============================================================================
 // Detection Logic
 // =============================================================================
-/**
- * Capture the last N lines from a tmux pane.
- */
-function captureTmuxPane(sessionId, lines, containerId) {
-    try {
-        const captureCmd = `tmux capture-pane -t "${sessionId}" -p -S -${lines}`;
-        if (containerId) {
-            return execSync(`docker exec ${containerId} bash -c '${captureCmd}'`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 }).trim();
-        }
-        return execSync(captureCmd, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            timeout: 5000,
-        }).trim();
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * Detect agent health state from tmux pane content.
  *

package/dist/commands/session/index.js

@@ -1,11 +1,12 @@
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class Session extends PMOCommand {
-    static description = 'Manage agent tmux sessions (list, attach, detach)';
+    static description = 'Manage agent tmux sessions (list, attach, create, detach)';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> list',
         '<%= config.bin %> <%= command.id %> attach TKT-347-implement',
+        '<%= config.bin %> <%= command.id %> create my-session',
     ];
     static flags = {
         ...pmoBaseFlags,
@@ -22,8 +23,11 @@ export default class Session extends PMOCommand {
                 message: 'Session Management - What would you like to do?',
                 choices: [
                     { name: 'List active sessions', value: 'list', command: 'prlt session list --json' },
+                    { name: 'Create a new session', value: 'create', command: 'prlt session create --json' },
                     { name: 'Attach to a session', value: 'attach', command: 'prlt session attach --json' },
+                    { name: 'Peek at agent output', value: 'peek', command: 'prlt session peek --json' },
                     { name: 'Check agent health', value: 'health', command: 'prlt session health --json' },
+                    { name: 'Poke a running agent', value: 'poke', command: 'prlt session poke --json' },
                     { name: 'Cancel', value: 'cancel' },
                 ],
             }], jsonModeConfig);
@@ -35,12 +39,21 @@ export default class Session extends PMOCommand {
             case 'list':
                 await this.config.runCommand('session:list', []);
                 break;
+            case 'create':
+                await this.config.runCommand('session:create', []);
+                break;
             case 'attach':
                 await this.config.runCommand('session:attach', []);
                 break;
+            case 'peek':
+                await this.config.runCommand('session:peek', []);
+                break;
             case 'health':
                 await this.config.runCommand('session:health', []);
                 break;
+            case 'poke':
+                await this.config.runCommand('session:poke', []);
+                break;
         }
     }
 }

package/dist/commands/session/list.js

@@ -8,6 +8,24 @@ import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap,
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson } from '../../lib/prompt-json.js';
 import { visualPadEnd } from '../../lib/string-utils.js';
+/**
+ * Find container sessions using prefix matching.
+ * Handles cases where the stored containerId format differs from docker ps output
+ * (e.g., full 64-char ID vs 12-char short ID).
+ */
+function findContainerSessionsByPrefix(containerTmuxSessions, containerId) {
+    // Try exact match first
+    const exact = containerTmuxSessions.get(containerId);
+    if (exact)
+        return exact;
+    // Fall back to prefix matching (handles short vs full ID mismatches)
+    for (const [key, sessions] of containerTmuxSessions) {
+        if (key.startsWith(containerId) || containerId.startsWith(key)) {
+            return sessions;
+        }
+    }
+    return [];
+}
 export default class SessionList extends PMOCommand {
     static description = 'List active tmux sessions (host and container)';
     static examples = [
@@ -65,7 +83,7 @@ export default class SessionList extends PMOCommand {
                 // If sessionId is NULL, try to find session by naming convention
                 if (!exec.sessionId) {
                     if (isContainer && exec.containerId) {
-                        const containerSessions = containerTmuxSessions.get(exec.containerId) || [];
+                        const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
                         const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
                         if (match) {
                             actualSessionId = match;
@@ -88,8 +106,8 @@ export default class SessionList extends PMOCommand {
                 else {
                     // sessionId is set, verify it exists
                     if (isContainer && exec.containerId) {
-                        const containerSessions = containerTmuxSessions.get(exec.containerId);
-                        exists = containerSessions?.includes(exec.sessionId) ?? false;
+                        const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
+                        exists = containerSessions.includes(exec.sessionId);
                         containerId = exec.containerId;
                     }
                     else {
@@ -105,14 +123,15 @@ export default class SessionList extends PMOCommand {
                         matchedHostSessions.add(actualSessionId);
                     }
                 }
-                // Only include if session exists, unless --all flag
-                // Note: actualSessionId is guaranteed non-null here due to continue above
-                if ((exists || flags.all) && actualSessionId) {
+                // Always include sessions from DB that have a sessionId.
+                // When tmux verification fails (e.g., Docker/tmux not accessible from MCP context),
+                // show the session with the DB status instead of silently dropping it.
+                if (actualSessionId) {
                     sessions.push({
                         sessionId: actualSessionId,
                         ticketId: exec.ticketId,
                         agentName: exec.agentName,
-                        status: exists ? exec.status : 'stale',
+                        status: exists ? exec.status : (flags.all ? 'stale' : exec.status),
                         environment: isContainer ? 'container' : 'host',
                         containerId,
                         exists,

package/dist/commands/session/peek.d.ts

@@ -0,0 +1,38 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionPeek extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        target: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        lines: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Resolve a target identifier to matching sessions.
+     * Supports: agent name, ticket ID (TKT-XXX), execution ID (WORK-XXX), or session ID.
+     */
+    private resolveTarget;
+    /**
+     * Resolve an execution ID (WORK-XXX) to matching sessions.
+     */
+    private resolveFromExecution;
+    /**
+     * Output peek content for a session.
+     * In raw mode: outputs plain text to stdout.
+     * In JSON mode: outputs structured JSON.
+     */
+    private outputPeek;
+    /**
+     * Get verified sessions from DB that have actual tmux processes.
+     * Same discovery pattern as attach.ts and list.ts.
+     */
+    private getVerifiedSessions;
+}

package/dist/commands/session/peek.js

@@ -0,0 +1,316 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/index.js';
+import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findSessionForExecution, captureTmuxPane, } from '../../lib/execution/session-utils.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+// =============================================================================
+// Command
+// =============================================================================
+export default class SessionPeek extends PMOCommand {
+    static description = 'View agent tmux pane content without attaching (non-interactive)';
+    static examples = [
+        '<%= config.bin %> session peek altman',
+        '<%= config.bin %> session peek TKT-123',
+        '<%= config.bin %> session peek WORK-ABCD1234',
+        '<%= config.bin %> session peek altman --lines 100',
+        '<%= config.bin %> session peek TKT-123 --json',
+        '<%= config.bin %> session peek altman | grep error',
+    ];
+    static args = {
+        target: Args.string({
+            description: 'Agent name, ticket ID (e.g. TKT-123), or execution ID (e.g. WORK-XXXXXXXX)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        lines: Flags.integer({
+            char: 'l',
+            description: 'Number of scrollback lines to capture',
+            default: 50,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SessionPeek);
+        const jsonMode = shouldOutputJson(flags);
+        // Discover all verified sessions
+        const sessions = this.getVerifiedSessions(jsonMode, flags);
+        if (sessions.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_SESSIONS', 'No active sessions found.', createMetadata('session peek', flags));
+                return;
+            }
+            this.log('');
+            this.log(styles.muted('No active sessions found.'));
+            this.log('');
+            this.log(styles.muted('Start work with: prlt work start <ticket-id>'));
+            this.log('');
+            return;
+        }
+        if (args.target) {
+            // Resolve target to matching session(s)
+            const matched = this.resolveTarget(args.target, sessions);
+            if (matched.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('SESSION_NOT_FOUND', `No matching session found for "${args.target}".`, createMetadata('session peek', flags));
+                    return;
+                }
+                this.error(`No matching session found for "${args.target}". Run "prlt session list" to see available sessions.`);
+            }
+            // Output all matched sessions
+            if (jsonMode && matched.length > 1) {
+                // Collect all captures into a single JSON response
+                const results = matched.map(session => {
+                    const containerId = session.environment === 'container' ? session.containerId : undefined;
+                    const content = captureTmuxPane(session.sessionId, flags.lines, containerId);
+                    return {
+                        sessionId: session.sessionId,
+                        ticketId: session.ticketId,
+                        agentName: session.agentName,
+                        environment: session.environment,
+                        containerId: session.containerId,
+                        lines: flags.lines,
+                        content,
+                        captureError: content === null
+                            ? `Failed to capture pane content for session "${session.sessionId}".`
+                            : undefined,
+                    };
+                });
+                outputSuccessAsJson({ sessions: results }, createMetadata('session peek', flags));
+                return;
+            }
+            for (const session of matched) {
+                this.outputPeek(session, flags.lines, jsonMode, flags);
+            }
+        }
+        else {
+            // No target: interactive selection
+            const selected = await this.selectFromList({
+                message: 'Select a session to peek at:',
+                items: sessions,
+                getName: (s) => `${s.sessionId} (${s.ticketId}) - ${s.agentName} [${s.environment}]`,
+                getValue: (s) => s.sessionId,
+                getCommand: (s) => `prlt session peek "${s.sessionId}" --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'session peek' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            const session = sessions.find(s => s.sessionId === selected);
+            if (!session) {
+                this.error('No session selected');
+            }
+            this.outputPeek(session, flags.lines, jsonMode, flags);
+        }
+    }
+    /**
+     * Resolve a target identifier to matching sessions.
+     * Supports: agent name, ticket ID (TKT-XXX), execution ID (WORK-XXX), or session ID.
+     */
+    resolveTarget(target, sessions) {
+        // Try exact session ID match
+        const exactSession = sessions.filter(s => s.sessionId === target);
+        if (exactSession.length > 0)
+            return exactSession;
+        // Try ticket ID match (e.g. TKT-123)
+        if (/^[A-Z]+-\d+$/i.test(target)) {
+            const ticketTarget = target.toUpperCase();
+            const ticketMatches = sessions.filter(s => s.ticketId === ticketTarget);
+            if (ticketMatches.length > 0)
+                return ticketMatches;
+        }
+        // Try execution ID match (WORK-XXX) — resolve via DB to find session
+        if (target.toUpperCase().startsWith('WORK-')) {
+            const executionMatch = this.resolveFromExecution(target.toUpperCase(), sessions);
+            if (executionMatch.length > 0)
+                return executionMatch;
+        }
+        // Try agent name match
+        const agentMatches = sessions.filter(s => s.agentName === target);
+        if (agentMatches.length > 0)
+            return agentMatches;
+        // Try partial session ID match
+        const partialMatches = sessions.filter(s => s.sessionId.includes(target) ||
+            s.ticketId.includes(target.toUpperCase()) ||
+            s.agentName.includes(target));
+        return partialMatches;
+    }
+    /**
+     * Resolve an execution ID (WORK-XXX) to matching sessions.
+     */
+    resolveFromExecution(executionId, sessions) {
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            const executionStorage = new ExecutionStorage(db);
+            const execution = executionStorage.getExecution(executionId);
+            if (execution) {
+                return sessions.filter(s => s.ticketId === execution.ticketId && s.agentName === execution.agentName);
+            }
+        }
+        catch {
+            // Workspace not available
+        }
+        finally {
+            db?.close();
+        }
+        return [];
+    }
+    /**
+     * Output peek content for a session.
+     * In raw mode: outputs plain text to stdout.
+     * In JSON mode: outputs structured JSON.
+     */
+    outputPeek(session, lines, jsonMode, flags) {
+        const containerId = session.environment === 'container' ? session.containerId : undefined;
+        const content = captureTmuxPane(session.sessionId, lines, containerId);
+        if (content === null) {
+            if (jsonMode) {
+                outputErrorAsJson('CAPTURE_FAILED', `Failed to capture pane content for session "${session.sessionId}". The session may no longer exist or tmux may not be available.`, createMetadata('session peek', flags));
+                return;
+            }
+            this.error(`Failed to capture pane content for session "${session.sessionId}". ` +
+                'The session may no longer exist or tmux may not be available.');
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                sessionId: session.sessionId,
+                ticketId: session.ticketId,
+                agentName: session.agentName,
+                environment: session.environment,
+                containerId: session.containerId,
+                lines,
+                content,
+            }, createMetadata('session peek', flags));
+        }
+        else {
+            // Raw text output — pipeable and scriptable
+            process.stdout.write(content + '\n');
+        }
+    }
+    /**
+     * Get verified sessions from DB that have actual tmux processes.
+     * Same discovery pattern as attach.ts and list.ts.
+     */
+    getVerifiedSessions(jsonMode, flags) {
+        const sessions = [];
+        let executionStorage = null;
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+        }
+        catch {
+            // Not in workspace — can still discover tmux sessions
+        }
+        try {
+            const hostTmuxSessions = getHostTmuxSessionNames();
+            const containerTmuxSessions = getContainerTmuxSessionMap();
+            const allContainerSessions = flattenContainerSessions(containerTmuxSessions);
+            const matchedHostSessions = new Set();
+            const matchedContainerSessions = new Set();
+            // Get active executions from DB
+            const activeExecutions = executionStorage ? [
+                ...(executionStorage.listExecutions({ status: 'running' }) || []),
+                ...(executionStorage.listExecutions({ status: 'starting' }) || []),
+            ] : [];
+            for (const exec of activeExecutions) {
+                const isContainer = exec.environment === 'devcontainer';
+                let exists = false;
+                let containerId;
+                let actualSessionId = exec.sessionId;
+                if (!exec.sessionId) {
+                    if (isContainer && exec.containerId) {
+                        const containerSessions = containerTmuxSessions.get(exec.containerId) || [];
+                        const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
+                        if (match) {
+                            actualSessionId = match;
+                            exists = true;
+                            containerId = exec.containerId;
+                        }
+                    }
+                    else {
+                        const match = findSessionForExecution(exec.ticketId, exec.agentName, hostTmuxSessions);
+                        if (match) {
+                            actualSessionId = match;
+                            exists = true;
+                        }
+                    }
+                    if (!actualSessionId)
+                        continue;
+                }
+                else {
+                    if (isContainer && exec.containerId) {
+                        const containerSessions = containerTmuxSessions.get(exec.containerId);
+                        exists = containerSessions?.includes(exec.sessionId) ?? false;
+                        containerId = exec.containerId;
+                    }
+                    else {
+                        exists = hostTmuxSessions.includes(exec.sessionId);
+                    }
+                }
+                if (exists && actualSessionId) {
+                    if (isContainer && containerId) {
+                        matchedContainerSessions.add(`${containerId}:${actualSessionId}`);
+                    }
+                    else {
+                        matchedHostSessions.add(actualSessionId);
+                    }
+                    sessions.push({
+                        sessionId: actualSessionId,
+                        ticketId: exec.ticketId,
+                        agentName: exec.agentName,
+                        environment: isContainer ? 'container' : 'host',
+                        containerId,
+                        source: 'db',
+                    });
+                }
+            }
+            // Discover orphan sessions matching prlt pattern
+            for (const sessionName of hostTmuxSessions) {
+                if (matchedHostSessions.has(sessionName))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        environment: 'host',
+                        source: 'discovered',
+                    });
+                }
+            }
+            for (const { sessionName, containerId } of allContainerSessions) {
+                if (matchedContainerSessions.has(`${containerId}:${sessionName}`))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        environment: 'container',
+                        containerId,
+                        source: 'discovered',
+                    });
+                }
+            }
+        }
+        finally {
+            db?.close();
+        }
+        return sessions;
+    }
+}

package/dist/commands/session/poke.d.ts

@@ -0,0 +1,27 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionPoke extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agent: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        message: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Resolve an agent identifier (name or ticket ID) to a running session.
+     * Looks up active executions and matches tmux sessions.
+     */
+    private resolveAgentSession;
+    /**
+     * Resolve the tmux session for a specific execution record.
+     */
+    private resolveSessionForExecution;
+}