@proletariat/cli 0.3.10 → 0.3.11

package/dist/commands/action/index.js

@@ -1,7 +1,7 @@
 import { Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
-import { shouldOutputJson, } from '../../lib/prompt-json.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class Action extends PMOCommand {
     static description = 'Interactive menu for work action operations';
     static aliases = ['actions'];

package/dist/commands/action/run.js

@@ -83,16 +83,15 @@ export default class ActionRun extends PMOCommand {
             }
         }
         else if (ticketIds.length > 0) {
-            // Get specific tickets
-            for (const id of ticketIds) {
+            // Get specific tickets in parallel
+            const results = await Promise.all(ticketIds.map(async (id) => {
                 const ticket = await this.storage.getTicket(id);
-                if (ticket) {
-                    tickets.push(ticket);
-                }
-                else {
+                if (!ticket) {
                     this.warn(`Ticket not found: ${id}`);
                 }
-            }
+                return ticket;
+            }));
+            tickets = results.filter((t) => t !== null);
         }
         else {
             // Interactive: show list of tickets to select
@@ -120,11 +119,8 @@ export default class ActionRun extends PMOCommand {
                     })),
                     validate: (input) => input.length > 0 || 'Select at least one ticket',
                 }]);
-            for (const id of selectedTickets) {
-                const ticket = await this.storage.getTicket(id);
-                if (ticket)
-                    tickets.push(ticket);
-            }
+            const selectedResults = await Promise.all(selectedTickets.map((id) => this.storage.getTicket(id)));
+            tickets = selectedResults.filter((t) => t !== null);
         }
         if (tickets.length === 0) {
             this.error('No tickets matched the criteria.');

package/dist/commands/agent/auth.d.ts

@@ -0,0 +1,30 @@
+import { Command } from '@oclif/core';
+export default class Auth extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    /**
+     * Check if the claude-credentials volume exists
+     */
+    private volumeExists;
+    /**
+     * Create the claude-credentials volume if it doesn't exist
+     */
+    private createVolume;
+    /**
+     * Check if valid credentials exist in the volume
+     */
+    private credentialsExist;
+    /**
+     * Get credential info for display
+     */
+    private getCredentialInfo;
+    /**
+     * Run the interactive login flow in a temporary container
+     */
+    private runLoginFlow;
+    run(): Promise<void>;
+}

package/dist/commands/agent/auth.js

@@ -0,0 +1,172 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync, spawnSync } from 'node:child_process';
+import { colors } from '../../lib/colors.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+const CLAUDE_CREDENTIALS_VOLUME = 'claude-credentials';
+export default class Auth extends Command {
+    static description = 'Set up Claude Code authentication for Docker containers (one-time setup)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --check',
+        '<%= config.bin %> <%= command.id %> --force',
+    ];
+    static flags = {
+        check: Flags.boolean({
+            description: 'Only check if credentials exist (do not prompt for login)',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Force re-authentication even if credentials exist',
+            default: false,
+        }),
+    };
+    /**
+     * Check if the claude-credentials volume exists
+     */
+    volumeExists() {
+        try {
+            execSync(`docker volume inspect ${CLAUDE_CREDENTIALS_VOLUME}`, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create the claude-credentials volume if it doesn't exist
+     */
+    createVolume() {
+        try {
+            execSync(`docker volume create ${CLAUDE_CREDENTIALS_VOLUME}`, { stdio: 'pipe' });
+        }
+        catch (error) {
+            this.error(`Failed to create Docker volume: ${error}`);
+        }
+    }
+    /**
+     * Check if valid credentials exist in the volume
+     */
+    credentialsExist() {
+        try {
+            const result = execSync(`docker run --rm -v ${CLAUDE_CREDENTIALS_VOLUME}:/data alpine cat /data/.credentials.json 2>/dev/null`, { stdio: 'pipe', encoding: 'utf-8' });
+            // Parse and validate the credentials
+            const creds = JSON.parse(result);
+            if (creds.claudeAiOauth?.accessToken && creds.claudeAiOauth?.expiresAt) {
+                // Check if expired
+                const expiresAt = creds.claudeAiOauth.expiresAt;
+                if (expiresAt > Date.now()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get credential info for display
+     */
+    getCredentialInfo() {
+        try {
+            const result = execSync(`docker run --rm -v ${CLAUDE_CREDENTIALS_VOLUME}:/data alpine cat /data/.credentials.json 2>/dev/null`, { stdio: 'pipe', encoding: 'utf-8' });
+            const creds = JSON.parse(result);
+            if (creds.claudeAiOauth?.expiresAt) {
+                return {
+                    expiresAt: new Date(creds.claudeAiOauth.expiresAt),
+                    subscriptionType: creds.claudeAiOauth.subscriptionType,
+                };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Run the interactive login flow in a temporary container
+     */
+    runLoginFlow() {
+        this.log(colors.primary('🔐 Starting Claude Code authentication...'));
+        this.log('');
+        this.log(colors.text('A temporary container will start with Claude Code.'));
+        this.log(colors.text('When prompted, type: /login'));
+        this.log(colors.text('Then complete the browser authentication.'));
+        this.log('');
+        this.log(colors.textSecondary('Press Ctrl+C to cancel.'));
+        this.log('');
+        try {
+            // Run interactive container with the volume mounted
+            const result = spawnSync('docker', [
+                'run',
+                '-it',
+                '--rm',
+                '-v', `${CLAUDE_CREDENTIALS_VOLUME}:/home/node/.claude`,
+                'node:20',
+                'bash', '-c',
+                // Install as root, then run claude as node user (so credentials have correct ownership)
+                'npm install -g @anthropic-ai/claude-code@latest --silent 2>/dev/null && chown -R node:node /home/node/.claude && echo "" && echo "Type: /login" && echo "" && su -s /bin/bash -c "HOME=/home/node CLAUDE_CONFIG_DIR=/home/node/.claude claude" node'
+            ], { stdio: 'inherit' });
+            return result.status === 0;
+        }
+        catch (error) {
+            this.log(colors.error(`Login flow failed: ${error}`));
+            return false;
+        }
+    }
+    async run() {
+        const { flags } = await this.parse(Auth);
+        // Check Docker is running
+        if (!isDockerRunning()) {
+            this.error('Docker is not running. Please start Docker Desktop and try again.');
+        }
+        // Ensure volume exists
+        if (!this.volumeExists()) {
+            this.log(colors.textSecondary(`Creating Docker volume: ${CLAUDE_CREDENTIALS_VOLUME}`));
+            this.createVolume();
+        }
+        // Check for existing credentials
+        const hasCredentials = this.credentialsExist();
+        if (flags.check) {
+            // Just report status
+            if (hasCredentials) {
+                const info = this.getCredentialInfo();
+                this.log(colors.success('✓ Claude Code credentials are configured'));
+                if (info) {
+                    this.log(colors.textSecondary(`  Subscription: ${info.subscriptionType || 'unknown'}`));
+                    this.log(colors.textSecondary(`  Expires: ${info.expiresAt.toLocaleDateString()}`));
+                }
+            }
+            else {
+                this.log(colors.warning('✗ No Claude Code credentials found'));
+                this.log(colors.textSecondary('  Run "prlt agent auth" to authenticate'));
+                this.exit(1);
+            }
+            return;
+        }
+        if (hasCredentials && !flags.force) {
+            const info = this.getCredentialInfo();
+            this.log(colors.success('✓ Claude Code credentials already configured'));
+            if (info) {
+                this.log(colors.textSecondary(`  Subscription: ${info.subscriptionType || 'unknown'}`));
+                this.log(colors.textSecondary(`  Expires: ${info.expiresAt.toLocaleDateString()}`));
+            }
+            this.log('');
+            this.log(colors.text('Use --force to re-authenticate.'));
+            return;
+        }
+        // Run the login flow
+        const success = this.runLoginFlow();
+        if (success && this.credentialsExist()) {
+            this.log('');
+            this.log(colors.success('✓ Authentication successful!'));
+            this.log(colors.textSecondary('  Credentials saved to Docker volume: ' + CLAUDE_CREDENTIALS_VOLUME));
+            this.log(colors.textSecondary('  All agent containers will share these credentials.'));
+        }
+        else {
+            this.log('');
+            this.log(colors.warning('Authentication may not have completed.'));
+            this.log(colors.textSecondary('Run "prlt agent auth --check" to verify.'));
+        }
+    }
+}

package/dist/commands/agent/discover.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Discover extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agent/discover.js

@@ -0,0 +1,67 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { discoverAgentsOnDisk } from '../../lib/database/index.js';
+export default class Discover extends Command {
+    static description = 'Discover agents on disk that are not registered in the database';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --dry-run',
+    ];
+    static flags = {
+        'dry-run': Flags.boolean({
+            description: 'Show what would be discovered without making changes',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Discover);
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            this.log(chalk.bold('\n🔍 Agent Discovery\n'));
+            if (flags['dry-run']) {
+                this.log(chalk.yellow('Dry run mode - no changes will be made\n'));
+            }
+            const result = discoverAgentsOnDisk(workspaceInfo.path);
+            // Report discovered agents
+            if (result.discovered.length > 0) {
+                this.log(chalk.green.bold(`✅ Discovered ${result.discovered.length} new agent(s):\n`));
+                for (const agent of result.discovered) {
+                    const typeLabel = agent.type === 'persistent' ? chalk.cyan('[staff]') : chalk.yellow('[temp]');
+                    this.log(`   ${chalk.bold(agent.name)} ${typeLabel}`);
+                    this.log(chalk.dim(`      Path: ${agent.path}`));
+                }
+                this.log('');
+            }
+            else {
+                this.log(chalk.dim('No new agents discovered on disk.\n'));
+            }
+            // Report cleaned agents
+            if (result.cleaned.length > 0) {
+                this.log(chalk.yellow.bold(`🧹 Cleaned up ${result.cleaned.length} missing agent(s):\n`));
+                for (const name of result.cleaned) {
+                    this.log(`   ${chalk.dim(name)} - directory no longer exists`);
+                }
+                this.log('');
+            }
+            // Summary
+            if (result.discovered.length === 0 && result.cleaned.length === 0) {
+                this.log(chalk.green('✓ Database is in sync with disk.\n'));
+            }
+            else {
+                const total = result.discovered.length + result.cleaned.length;
+                this.log(chalk.bold(`Summary: ${total} change(s) made`));
+                if (result.discovered.length > 0) {
+                    this.log(`   Discovered: ${result.discovered.length} agent(s)`);
+                }
+                if (result.cleaned.length > 0) {
+                    this.log(`   Cleaned: ${result.cleaned.length} agent(s)`);
+                }
+                this.log('');
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/index.js

@@ -1,7 +1,8 @@
 import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
 import { colors } from '../../lib/colors.js';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
-import { shouldOutputJson, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class Agent extends PMOCommand {
     static description = 'Manage agents in the workspace';
     static examples = [
@@ -30,8 +31,7 @@ export default class Agent extends PMOCommand {
         const { flags } = await this.parse(Agent);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // Define choices once, use for both JSON and interactive modes
-        // Each choice includes the full command for AI agents to execute
+        // Define choices for JSON mode (flat list with commands)
         const menuChoices = [
             { id: 'list', name: 'List all agents', command: 'prlt agent list --format json' },
             { id: 'status', name: 'Show status', command: 'prlt agent status --json' },
@@ -42,6 +42,7 @@ export default class Agent extends PMOCommand {
             { id: 'shell', name: 'Open shell', command: 'prlt agent shell --json' },
             { id: 'restart', name: 'Restart', command: 'prlt agent restart --json' },
             { id: 'rebuild', name: 'Rebuild', command: 'prlt agent rebuild --json' },
+            { id: 'discover', name: 'Discover agents on disk', command: 'prlt agent discover' },
             { id: 'cancel', name: 'Cancel', command: '' },
         ];
         const message = 'What would you like to do?';
@@ -50,15 +51,43 @@ export default class Agent extends PMOCommand {
         this.log(colors.textMuted('Note: Agent pre-registration is no longer required!'));
         this.log(colors.textMuted('Use "prlt work spawn" to create ephemeral agents automatically.'));
         this.log('');
-        const action = await this.selectFromList({
-            message,
-            items: menuChoices,
-            getName: (c) => c.name,
-            getValue: (c) => c.id,
-            getCommand: (c) => c.command,
-            jsonMode: jsonMode ? { flags, commandName: 'agent' } : null,
-        });
-        if (action === 'cancel' || !action) {
+        // In JSON mode, output flat list with commands
+        if (jsonMode) {
+            outputPromptAsJson({
+                type: 'list',
+                name: 'action',
+                message,
+                choices: menuChoices.map(c => ({ name: c.name, value: c.id, command: c.command })),
+            }, createMetadata('agent', flags));
+            return;
+        }
+        // Interactive mode with separators for logical groupings
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message,
+                choices: [
+                    // View/Info group
+                    { name: '📋 List all agents', value: 'list' },
+                    { name: '📊 Show status', value: 'status' },
+                    { name: '📂 Visit directory', value: 'visit' },
+                    new inquirer.Separator(),
+                    // Management group
+                    { name: '👔 Manage staff agents', value: 'staff' },
+                    { name: '⏱️  Manage temp agents', value: 'temp' },
+                    { name: '🎨 Manage themes', value: 'themes' },
+                    new inquirer.Separator(),
+                    // Operations group
+                    { name: '🐚 Open shell', value: 'shell' },
+                    { name: '🔄 Restart', value: 'restart' },
+                    { name: '🔨 Rebuild', value: 'rebuild' },
+                    { name: '🔍 Discover agents on disk', value: 'discover' },
+                    new inquirer.Separator(),
+                    // Cancel
+                    { name: '❌ Cancel', value: 'cancel' },
+                ],
+            }]);
+        if (action === 'cancel') {
             this.log(colors.textMuted('Operation cancelled.'));
             return;
         }
@@ -120,6 +149,12 @@ export default class Agent extends PMOCommand {
                     await cmd.run();
                     break;
                 }
+                case 'discover': {
+                    const { default: DiscoverCommand } = await import('./discover.js');
+                    const cmd = new DiscoverCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
                 default:
                     this.error(`Unknown action: ${action}`);
             }

package/dist/commands/agent/list.d.ts

@@ -2,6 +2,9 @@ import { Command } from '@oclif/core';
 export default class List extends Command {
     static description: string;
     static examples: string[];
-    static flags: {};
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/agent/list.js

@@ -1,32 +1,85 @@
-import { Command } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { getWorkspaceInfo, getAllAgentsStatus, getAgentTmuxSessions } from '../../lib/agents/commands.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class List extends Command {
     static description = 'List all agents and their current status';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type staff',
+        '<%= config.bin %> <%= command.id %> --type temp',
     ];
-    static flags = {};
+    static flags = {
+        type: Flags.string({
+            char: 't',
+            description: 'Filter by agent type',
+            options: ['staff', 'temp', 'all'],
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
     async run() {
         try {
+            const { flags } = await this.parse(List);
+            const jsonMode = shouldOutputJson(flags);
             // Get workspace information
             const workspaceInfo = getWorkspaceInfo();
             // Filter to active agents only
             const activeAgents = workspaceInfo.agents.filter(a => a.status === 'active');
-            if (activeAgents.length === 0) {
-                this.log(chalk.yellow('No active agents found.'));
+            // Determine type filter - prompt if not provided
+            let typeFilter = flags.type;
+            if (!typeFilter) {
+                // In JSON mode, output type selection prompt
+                if (jsonMode) {
+                    outputPromptAsJson({
+                        type: 'list',
+                        name: 'type',
+                        message: 'Which agents do you want to list?',
+                        choices: [
+                            { name: 'All agents', value: 'all', command: 'prlt agent list --type all --json' },
+                            { name: 'Staff agents only', value: 'staff', command: 'prlt agent list --type staff --json' },
+                            { name: 'Temp agents only', value: 'temp', command: 'prlt agent list --type temp --json' },
+                        ],
+                    }, createMetadata('agent list', flags));
+                    return;
+                }
+                // Interactive mode - prompt for type
+                const { selectedType } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedType',
+                        message: 'Which agents do you want to list?',
+                        choices: [
+                            { name: '📋 All agents', value: 'all' },
+                            { name: '👔 Staff agents only', value: 'staff' },
+                            { name: '⏱️  Temp agents only', value: 'temp' },
+                        ],
+                    }]);
+                typeFilter = selectedType;
+            }
+            // Filter agents based on type selection
+            const staffAgents = activeAgents.filter(a => a.type === 'persistent');
+            const tempAgents = activeAgents.filter(a => a.type === 'ephemeral');
+            const showStaff = typeFilter === 'all' || typeFilter === 'staff';
+            const showTemp = typeFilter === 'all' || typeFilter === 'temp';
+            const filteredAgents = [
+                ...(showStaff ? staffAgents : []),
+                ...(showTemp ? tempAgents : []),
+            ];
+            if (filteredAgents.length === 0) {
+                const typeLabel = typeFilter === 'all' ? '' : ` ${typeFilter}`;
+                this.log(chalk.yellow(`No active${typeLabel} agents found.`));
                 this.log(chalk.dim('Use "prlt agent staff add" or "prlt work spawn" to create agents.'));
                 return;
             }
             // Get status for all active agents
             const agentsStatus = getAllAgentsStatus(workspaceInfo);
-            // Separate by type
-            const staffAgents = activeAgents.filter(a => a.type === 'persistent');
-            const tempAgents = activeAgents.filter(a => a.type === 'ephemeral');
             // Staff agents section
-            if (staffAgents.length > 0) {
+            if (showStaff && staffAgents.length > 0) {
                 this.log(chalk.bold.cyan('\n Staff Agents:\n'));
                 const staffStatus = agentsStatus.filter(a => staffAgents.some(s => s.name === a.name));
                 for (const agentStatus of staffStatus) {
@@ -75,7 +128,7 @@ export default class List extends Command {
                 }
             }
             // Temp agents section
-            if (tempAgents.length > 0) {
+            if (showTemp && tempAgents.length > 0) {
                 this.log(chalk.bold.yellow('\n Temporary Agents:\n'));
                 const tempStatus = agentsStatus.filter(a => tempAgents.some(s => s.name === a.name));
                 for (const agentStatus of tempStatus) {
@@ -106,17 +159,26 @@ export default class List extends Command {
                 const sessions = getAgentTmuxSessions(a.name);
                 return sessions.length > 0;
             }).length;
-            const totalAssignedTickets = agentsStatus.reduce((sum, a) => sum + a.assignedTickets.length, 0);
+            // Calculate tickets for filtered agents only
+            const filteredAgentNames = new Set(filteredAgents.map(a => a.name));
+            const filteredStatus = agentsStatus.filter(a => filteredAgentNames.has(a.name));
+            const totalAssignedTickets = filteredStatus.reduce((sum, a) => sum + a.assignedTickets.length, 0);
             this.log(chalk.bold(`Summary:`));
-            this.log(`   Staff agents: ${staffAgents.length} (${activeStaffCount} active)`);
-            this.log(`   Temp agents: ${tempAgents.length} (${activeTempCount} active${runningTempCount > 0 ? `, ${runningTempCount} running` : ''})`);
+            if (showStaff) {
+                this.log(`   Staff agents: ${staffAgents.length} (${activeStaffCount} active)`);
+            }
+            if (showTemp) {
+                this.log(`   Temp agents: ${tempAgents.length} (${activeTempCount} active${runningTempCount > 0 ? `, ${runningTempCount} running` : ''})`);
+            }
             if (workspaceInfo.hasPMO) {
                 this.log(`   Tickets assigned: ${totalAssignedTickets}`);
             }
-            // Show cleaned agents count if any
-            const cleanedAgents = workspaceInfo.agents.filter(a => a.status === 'cleaned');
-            if (cleanedAgents.length > 0) {
-                this.log(chalk.dim(`   Cleaned (historical): ${cleanedAgents.length}`));
+            // Show cleaned agents count if any (only when showing all)
+            if (typeFilter === 'all') {
+                const cleanedAgents = workspaceInfo.agents.filter(a => a.status === 'cleaned');
+                if (cleanedAgents.length > 0) {
+                    this.log(chalk.dim(`   Cleaned (historical): ${cleanedAgents.length}`));
+                }
             }
         }
         catch (error) {