@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/docker/clean.js

@@ -0,0 +1,224 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync } from 'child_process';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { sanitizeContainerId } from '../../lib/docker/resolve.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class DockerClean extends Command {
+    static description = 'Remove orphaned containers (containers without running agents)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --force',
+        '<%= config.bin %> <%= command.id %> --dry-run',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            aliases: ['yes', 'y'],
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        'dry-run': Flags.boolean({
+            char: 'd',
+            description: 'Show what would be removed without removing',
+            default: false,
+        }),
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Remove all stopped devcontainers (not just orphaned)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DockerClean);
+        // Check Docker status first
+        if (!isDockerRunning()) {
+            this.log(`\n${styles.error('Docker is not running')}`);
+            this.log(`${styles.muted('Start Docker Desktop or the Docker daemon first.')}\n`);
+            return;
+        }
+        // Get workspace info
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            this.error('Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        let db;
+        try {
+            db = new Database(dbPath);
+        }
+        catch {
+            this.error('Could not open workspace database.');
+        }
+        const executionStorage = new ExecutionStorage(db);
+        try {
+            // Find orphaned containers
+            const orphanedContainers = this.findOrphanedContainers(executionStorage, workspaceInfo.agentsPath, flags.all);
+            if (orphanedContainers.length === 0) {
+                this.log(`\n${styles.success('No orphaned containers found.')}\n`);
+                db.close();
+                return;
+            }
+            // Display orphaned containers
+            this.log(`\n${styles.header('Orphaned Containers')}`);
+            this.log('='.repeat(80));
+            this.log(styles.muted(padEnd('Container ID', 15) +
+                padEnd('Name', 30) +
+                padEnd('Status', 15) +
+                'Reason'));
+            this.log('-'.repeat(80));
+            for (const container of orphanedContainers) {
+                this.log(padEnd(container.id, 15) +
+                    padEnd(truncate(container.name, 28), 30) +
+                    padEnd(container.status, 15) +
+                    styles.muted(container.reason));
+            }
+            if (flags['dry-run']) {
+                this.log(`\n${styles.warning(`[DRY RUN] Would remove ${orphanedContainers.length} container(s)`)}\n`);
+                db.close();
+                return;
+            }
+            // Confirm removal
+            if (!flags.force) {
+                // Check if JSON output mode is active
+                const jsonMode = shouldOutputJson(flags);
+                // Build choices once, use for both JSON and interactive modes
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                const confirmMessage = `Remove ${orphanedContainers.length} orphaned container(s)?`;
+                // In JSON mode, output confirmation prompt
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'confirmed', confirmMessage, confirmChoices), createMetadata('docker clean', flags));
+                    db.close();
+                    return;
+                }
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: confirmMessage,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    this.log(`\n${styles.muted('Aborted.')}\n`);
+                    db.close();
+                    return;
+                }
+            }
+            // Remove containers
+            let removed = 0;
+            let failed = 0;
+            for (const container of orphanedContainers) {
+                try {
+                    const safeId = sanitizeContainerId(container.id);
+                    // Stop container if running
+                    if (container.status.includes('Up')) {
+                        this.log(styles.muted(`Stopping ${container.id}...`));
+                        execSync(`docker stop ${safeId}`, {
+                            stdio: ['pipe', 'pipe', 'pipe'],
+                            timeout: 30000,
+                        });
+                    }
+                    // Remove container
+                    this.log(styles.muted(`Removing ${container.id}...`));
+                    execSync(`docker rm ${safeId}`, {
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    removed++;
+                }
+                catch (error) {
+                    this.log(styles.error(`Failed to remove ${container.id}: ${error instanceof Error ? error.message : error}`));
+                    failed++;
+                }
+            }
+            if (removed > 0) {
+                this.log(`\n${styles.success(`Removed ${removed} container(s)`)}`);
+            }
+            if (failed > 0) {
+                this.log(styles.error(`Failed to remove ${failed} container(s)`));
+            }
+            this.log('');
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    findOrphanedContainers(executionStorage, agentsPath, includeAllStopped) {
+        const orphaned = [];
+        try {
+            // Get all devcontainers
+            const output = execSync('docker ps -a --format "{{.ID}}|{{.Names}}|{{.Status}}|{{.Label \\"devcontainer.local_folder\\"}}"', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            if (!output)
+                return [];
+            // Get running executions from database
+            const runningExecutions = executionStorage.listExecutions({ status: 'running' });
+            const startingExecutions = executionStorage.listExecutions({ status: 'starting' });
+            const activeExecutions = [...runningExecutions, ...startingExecutions];
+            const lines = output.split('\n');
+            for (const line of lines) {
+                const [id, name, status, agentDir] = line.split('|');
+                // Only consider devcontainers (have agentDir label)
+                if (!agentDir)
+                    continue;
+                const isRunning = status.includes('Up');
+                const isStopped = !isRunning;
+                // Check if this container has an active execution
+                const hasActiveExecution = activeExecutions.some(exec => exec.containerId && (exec.containerId === id ||
+                    exec.containerId.startsWith(id) ||
+                    id.startsWith(exec.containerId)));
+                // Skip healthy containers (running with active execution)
+                if (isRunning && hasActiveExecution)
+                    continue;
+                // Skip normal stopped containers unless --all flag
+                if (isStopped && !hasActiveExecution && !includeAllStopped)
+                    continue;
+                // Remaining containers are orphaned - determine reason
+                const reason = isStopped
+                    ? hasActiveExecution
+                        ? 'Container stopped but execution active'
+                        : 'Stopped devcontainer'
+                    : 'No active execution';
+                orphaned.push({
+                    id,
+                    name,
+                    status: status.split(' ').slice(0, 2).join(' '),
+                    agentDir,
+                    reason,
+                });
+            }
+            return orphaned;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+function padEnd(str, length) {
+    return str.padEnd(length);
+}
+function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.substring(0, maxLength - 2) + '..';
+}

package/dist/commands/docker/index.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class Docker extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private selectContainer;
+    /**
+     * Get raw container info from Docker (no agent name inference)
+     */
+    private getDockerContainers;
+    /**
+     * Extract agent name from devcontainer image name.
+     * Only used for NEW/untracked containers - DB is source of truth otherwise.
+     */
+    private extractAgentFromImage;
+}

package/dist/commands/docker/index.js

@@ -0,0 +1,274 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { execSync } from 'child_process';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage, ContainerStorage } from '../../lib/execution/storage.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Docker extends Command {
+    static description = 'Manage Docker containers used by agents';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> docker status',
+        '<%= config.bin %> docker list',
+        '<%= config.bin %> docker logs WORK-001',
+        '<%= config.bin %> docker start WORK-001',
+        '<%= config.bin %> docker stop kalanick',
+        '<%= config.bin %> docker shell WORK-001',
+        '<%= config.bin %> docker restart abc123',
+        '<%= config.bin %> docker sync',
+        '<%= config.bin %> docker clean',
+        '<%= config.bin %> docker prune',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Docker);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { name: 'Check Docker status', value: 'status' },
+            { name: 'List containers', value: 'list' },
+            { name: 'View container logs', value: 'logs' },
+            { name: 'Start a container', value: 'start' },
+            { name: 'Stop a container', value: 'stop' },
+            { name: 'Shell into container', value: 'shell' },
+            { name: 'Restart a container', value: 'restart' },
+            { name: 'Sync containers from Docker', value: 'sync' },
+            { name: 'Clean orphaned containers', value: 'clean' },
+            { name: 'Prune unused resources', value: 'prune' },
+            { name: 'Exit', value: 'exit' },
+        ];
+        const message = 'What would you like to do?';
+        // In JSON mode, output menu prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('docker', flags));
+            return;
+        }
+        this.log('');
+        this.log(styles.header('Docker Management'));
+        this.log('');
+        const { action } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message,
+                choices: [
+                    ...menuChoices.slice(0, 7),
+                    new inquirer.Separator(),
+                    ...menuChoices.slice(7, 10),
+                    new inquirer.Separator(),
+                    menuChoices[10],
+                ],
+            },
+        ]);
+        if (action === 'exit') {
+            return;
+        }
+        // Commands that require a target
+        const targetCommands = ['logs', 'start', 'stop', 'shell', 'restart'];
+        if (targetCommands.includes(action)) {
+            const target = await this.selectContainer(action);
+            if (!target)
+                return;
+            await this.config.runCommand(`docker:${action}`, [target]);
+        }
+        else {
+            await this.config.runCommand(`docker:${action}`, []);
+        }
+    }
+    async selectContainer(action) {
+        // Check Docker first
+        const dockerRunning = isDockerRunning();
+        if (!dockerRunning) {
+            this.error('Docker is not running. Start Docker Desktop or the Docker daemon first.');
+        }
+        // Get workspace info (optional - we can still show docker containers without it)
+        let workspaceInfo;
+        let db = null;
+        let executionStorage = null;
+        let containerStorage = null;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+            containerStorage = new ContainerStorage(db);
+        }
+        catch {
+            // No workspace - that's ok, we'll just show docker containers
+        }
+        try {
+            // Get raw docker container info (just IDs and status)
+            const dockerContainers = this.getDockerContainers();
+            // Sync containers to database (if we have a workspace)
+            // This uses image name to determine agent for NEW containers only
+            if (containerStorage && dockerContainers.length > 0) {
+                const containersWithAgent = dockerContainers.map(c => ({
+                    ...c,
+                    agentName: this.extractAgentFromImage(c.image),
+                }));
+                containerStorage.syncFromDocker(containersWithAgent);
+            }
+            // Get tracked containers from DB (source of truth for agent names)
+            const trackedContainers = containerStorage
+                ? containerStorage.listContainers({ limit: 50 })
+                : [];
+            // Get tracked executions with containers from DB
+            const trackedExecutions = executionStorage
+                ? executionStorage.listExecutions({ limit: 50 }).filter(e => e.environment === 'devcontainer' || e.containerId)
+                : [];
+            // Track which docker IDs we've already added
+            const addedDockerIds = new Set();
+            // Build choices
+            const choices = [];
+            // Column header
+            const header = styles.muted(`  ${'ID'.padEnd(14)} ${'Agent'.padEnd(15)} Status`);
+            // Add active executions first (with container info from DB)
+            const activeExecutions = trackedExecutions.filter(e => e.status === 'running' || e.status === 'starting');
+            if (activeExecutions.length > 0) {
+                choices.push(new inquirer.Separator('── Active Executions ──'));
+                choices.push(new inquirer.Separator(header));
+                for (const exec of activeExecutions) {
+                    // Get container from DB (source of truth)
+                    const container = trackedContainers.find(c => c.currentExecutionId === exec.id);
+                    const dockerContainer = exec.containerId
+                        ? dockerContainers.find(c => c.id.startsWith(exec.containerId.substring(0, 12)))
+                        : null;
+                    const isRunning = dockerContainer?.status.startsWith('Up') || container?.status === 'running';
+                    const statusIcon = isRunning ? styles.success('●') : styles.warning('◐');
+                    // Use agent name from execution record (DB source of truth)
+                    choices.push({
+                        name: `${statusIcon} ${exec.id.padEnd(14)} ${exec.agentName.padEnd(15)} ${styles.success(exec.status)}`,
+                        value: exec.id,
+                    });
+                    if (exec.containerId) {
+                        addedDockerIds.add(exec.containerId.substring(0, 12));
+                    }
+                }
+            }
+            // Add containers from database (not tied to active executions)
+            // Agent name comes from DB - the authoritative source
+            const standbyContainers = trackedContainers.filter(c => !activeExecutions.some(e => e.containerId?.startsWith(c.dockerId.substring(0, 12))) &&
+                c.status !== 'removed');
+            if (standbyContainers.length > 0) {
+                choices.push(new inquirer.Separator('── Containers ──'));
+                if (activeExecutions.length === 0) {
+                    choices.push(new inquirer.Separator(header));
+                }
+                for (const container of standbyContainers) {
+                    const dockerStatus = dockerContainers.find(d => d.id.startsWith(container.dockerId.substring(0, 12)));
+                    const isRunning = dockerStatus?.status.startsWith('Up');
+                    const statusIcon = isRunning ? styles.success('●') : styles.muted('○');
+                    const statusText = isRunning ? styles.success('running') : styles.muted(container.status);
+                    // Agent name from DB (source of truth)
+                    choices.push({
+                        name: `${statusIcon} ${container.dockerId.substring(0, 12).padEnd(14)} ${container.agentName.padEnd(15)} ${statusText}`,
+                        value: container.dockerId,
+                    });
+                    addedDockerIds.add(container.dockerId.substring(0, 12));
+                }
+            }
+            // Add devcontainers from Docker that aren't in DB yet
+            // Fall back to parsing image name only for untracked containers
+            const untracked = dockerContainers.filter(c => !addedDockerIds.has(c.id.substring(0, 12)));
+            if (untracked.length > 0) {
+                choices.push(new inquirer.Separator('── Untracked (run sync) ──'));
+                for (const container of untracked) {
+                    const isRunning = container.status.startsWith('Up');
+                    const statusIcon = isRunning ? styles.success('●') : styles.muted('○');
+                    const statusText = isRunning ? styles.success('running') : styles.muted(container.status.toLowerCase());
+                    // Parse agent from image only for untracked containers
+                    const agentName = this.extractAgentFromImage(container.image);
+                    choices.push({
+                        name: `${statusIcon} ${container.id.substring(0, 12).padEnd(14)} ${agentName.padEnd(15)} ${statusText}`,
+                        value: container.id,
+                    });
+                }
+            }
+            // Add separator and options
+            choices.push(new inquirer.Separator());
+            choices.push({ name: 'Enter container ID manually...', value: '__manual__' });
+            choices.push({ name: styles.muted('Cancel'), value: '__cancel__' });
+            if (db)
+                db.close();
+            if (choices.length <= 2) {
+                // Only manual option, just ask for input
+                const { target } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'target',
+                        message: 'No containers found. Enter container ID:',
+                        validate: (input) => input.trim().length > 0 || 'Target is required',
+                    },
+                ]);
+                return target.trim();
+            }
+            const { target } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'target',
+                    message: `Select container to ${action}:`,
+                    choices,
+                    pageSize: 15,
+                },
+            ]);
+            if (target === '__cancel__') {
+                return null;
+            }
+            if (target === '__manual__') {
+                const { manualTarget } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'manualTarget',
+                        message: 'Enter execution ID (WORK-XXX), agent name, or container ID:',
+                        validate: (input) => input.trim().length > 0 || 'Target is required',
+                    },
+                ]);
+                return manualTarget.trim();
+            }
+            return target;
+        }
+        catch (error) {
+            if (db)
+                db.close();
+            throw error;
+        }
+    }
+    /**
+     * Get raw container info from Docker (no agent name inference)
+     */
+    getDockerContainers() {
+        try {
+            const output = execSync('docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}"', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            if (!output)
+                return [];
+            return output.split('\n').filter(Boolean).map(line => {
+                const [id, name, image, status] = line.split('|');
+                return { id, name, image, status };
+            }).filter(c => c.image.startsWith('vsc-')); // Only devcontainers
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Extract agent name from devcontainer image name.
+     * Only used for NEW/untracked containers - DB is source of truth otherwise.
+     */
+    extractAgentFromImage(image) {
+        const match = image.match(/^vsc-([^-]+)-/);
+        return match ? match[1] : 'unknown';
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class DockerList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        running: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private getTrackedContainers;
+    private getDockerContainers;
+    /**
+     * Extract agent name from devcontainer image name (fallback only)
+     */
+    private extractAgentFromImage;
+}