@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/docker/list.js

@@ -0,0 +1,200 @@
+import { Command, Flags } from '@oclif/core';
+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';
+export default class DockerList extends Command {
+    static description = 'Show Docker containers from agent_work table with status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --running',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Show all containers (including non-devcontainer)',
+            default: false,
+        }),
+        running: Flags.boolean({
+            char: 'r',
+            description: 'Only show running containers',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DockerList);
+        // 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);
+        const containerStorage = new ContainerStorage(db);
+        try {
+            // Get containers tracked in agent_work (executions)
+            const trackedExecutions = this.getTrackedContainers(executionStorage);
+            // Get containers from containers table (source of truth for agent names)
+            const dbContainers = containerStorage.listContainers({ limit: 50 });
+            // Get running docker containers
+            const runningContainers = this.getDockerContainers(workspaceInfo.agentsPath, flags.all);
+            this.log(`\n${styles.header('Docker Containers')}`);
+            this.log('='.repeat(100));
+            // Display active executions from database
+            const activeExecutions = trackedExecutions.filter(e => e.status === 'running' || e.status === 'starting');
+            if (activeExecutions.length > 0) {
+                this.log(styles.subheader('\nActive Executions:'));
+                this.log(styles.muted(padEnd('ID', 15) +
+                    padEnd('Agent', 15) +
+                    padEnd('Ticket', 12) +
+                    padEnd('Status', 12) +
+                    'Container'));
+                this.log('-'.repeat(80));
+                for (const exec of activeExecutions) {
+                    const statusColor = getStatusColor(exec.status);
+                    const containerId = exec.containerId ? exec.containerId.substring(0, 12) : styles.muted('none');
+                    // Check if container is actually running in Docker
+                    let containerStatus = '';
+                    if (exec.containerId) {
+                        const isRunning = runningContainers.some(c => c.id.startsWith(exec.containerId.substring(0, 12)));
+                        containerStatus = isRunning ? styles.success(' (up)') : styles.warning(' (down)');
+                    }
+                    this.log(padEnd(exec.id, 15) +
+                        padEnd(exec.agentName, 15) +
+                        padEnd(exec.ticketId, 12) +
+                        statusColor(padEnd(exec.status, 12)) +
+                        containerId + containerStatus);
+                }
+            }
+            // Display containers from DB (with agent names - source of truth)
+            const filteredContainers = flags.running
+                ? runningContainers.filter(c => c.status.includes('Up'))
+                : runningContainers;
+            if (filteredContainers.length > 0) {
+                this.log(styles.subheader('\nDocker Containers' + (flags.all ? ' (all)' : ' (devcontainers)') + ':'));
+                this.log(styles.muted(padEnd('Container ID', 15) +
+                    padEnd('Agent', 15) +
+                    padEnd('Status', 15) +
+                    'Uptime'));
+                this.log('-'.repeat(70));
+                for (const container of filteredContainers) {
+                    const statusColor = container.status.includes('Up') ? styles.success : styles.muted;
+                    // Look up agent name from DB (source of truth)
+                    const dbContainer = dbContainers.find(c => c.dockerId.startsWith(container.id.substring(0, 12)));
+                    const agentName = dbContainer?.agentName || this.extractAgentFromImage(container.image) || container.name;
+                    this.log(padEnd(container.id, 15) +
+                        padEnd(agentName, 15) +
+                        statusColor(padEnd(container.status, 15)) +
+                        styles.muted(container.uptime));
+                }
+            }
+            else if (!flags.running) {
+                this.log(styles.muted('\nNo devcontainer Docker containers found.'));
+            }
+            else {
+                this.log(styles.muted('\nNo running containers found.'));
+            }
+            this.log(`\n${styles.muted('Commands:')}`);
+            this.log(styles.muted('  prlt docker status    Check Docker daemon status'));
+            this.log(`${styles.muted('  prlt docker clean     Remove orphaned containers')}\n`);
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    getTrackedContainers(executionStorage) {
+        // Get executions that used devcontainer environment
+        const executions = executionStorage.listExecutions({ limit: 50 });
+        return executions.filter(e => e.environment === 'devcontainer' ||
+            e.containerId);
+    }
+    getDockerContainers(agentsPath, showAll) {
+        try {
+            // Get containers - filter by devcontainer label unless --all
+            let cmd = 'docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.Label \\"devcontainer.local_folder\\"}}"';
+            const output = execSync(cmd, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            if (!output)
+                return [];
+            const containers = [];
+            const lines = output.split('\n');
+            for (const line of lines) {
+                const [id, name, image, status, agentDir] = line.split('|');
+                // Filter to devcontainers unless --all
+                if (!showAll && !agentDir)
+                    continue;
+                // Extract uptime from status
+                const uptimeMatch = status.match(/Up (.+)/);
+                const uptime = uptimeMatch ? uptimeMatch[1] : '-';
+                containers.push({
+                    id,
+                    name,
+                    image,
+                    status: status.split(' ').slice(0, 2).join(' '),
+                    agentDir: agentDir || null,
+                    uptime,
+                });
+            }
+            return containers;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Extract agent name from devcontainer image name (fallback only)
+     */
+    extractAgentFromImage(image) {
+        const match = image.match(/^vsc-([^-]+)-/);
+        return match ? match[1] : null;
+    }
+}
+function padEnd(str, length) {
+    return str.padEnd(length);
+}
+function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.substring(0, maxLength - 2) + '..';
+}
+function getStatusColor(status) {
+    switch (status) {
+        case 'running':
+            return styles.success;
+        case 'starting':
+            return styles.warning;
+        case 'completed':
+            return styles.muted;
+        case 'failed':
+            return styles.error;
+        case 'stopped':
+            return styles.muted;
+        default:
+            return (s) => s;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class DockerLogs extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        follow: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        tail: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        timestamps: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        target: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/docker/logs.js

@@ -0,0 +1,118 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { execSync, spawn } 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 } from '../../lib/execution/storage.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { resolveContainerId } from '../../lib/docker/resolve.js';
+export default class DockerLogs extends Command {
+    static description = 'View logs from a container (by execution ID, agent name, or container ID)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> WORK-001',
+        '<%= config.bin %> <%= command.id %> kalanick',
+        '<%= config.bin %> <%= command.id %> abc123 --follow',
+        '<%= config.bin %> <%= command.id %> WORK-001 --tail 100',
+    ];
+    static flags = {
+        follow: Flags.boolean({
+            char: 'f',
+            description: 'Follow log output',
+            default: false,
+        }),
+        tail: Flags.integer({
+            char: 'n',
+            description: 'Number of lines to show from the end',
+            default: 100,
+        }),
+        timestamps: Flags.boolean({
+            char: 't',
+            description: 'Show timestamps',
+            default: false,
+        }),
+    };
+    static args = {
+        target: Args.string({
+            description: 'Execution ID (WORK-XXX), agent name, or container ID',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DockerLogs);
+        if (!isDockerRunning()) {
+            this.error('Docker is not running. Start Docker Desktop or the Docker daemon first.');
+        }
+        // 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 {
+            const result = resolveContainerId(args.target, executionStorage);
+            if (!result.containerId) {
+                db.close();
+                this.error(result.error || 'Could not find container');
+            }
+            // Build docker logs command
+            const dockerArgs = ['logs'];
+            if (flags.follow) {
+                dockerArgs.push('--follow');
+            }
+            if (flags.tail) {
+                dockerArgs.push('--tail', String(flags.tail));
+            }
+            if (flags.timestamps) {
+                dockerArgs.push('--timestamps');
+            }
+            dockerArgs.push(result.containerId);
+            this.log(`\n${styles.header(`Logs for ${result.displayName}`)}`);
+            this.log(styles.muted(`Container: ${result.containerId}`));
+            this.log('─'.repeat(60) + '\n');
+            db.close();
+            if (flags.follow) {
+                // Stream logs
+                const proc = spawn('docker', dockerArgs, {
+                    stdio: 'inherit',
+                });
+                proc.on('error', (err) => {
+                    this.error(`Failed to get logs: ${err.message}`);
+                });
+            }
+            else {
+                // Get logs synchronously
+                try {
+                    const output = execSync(`docker ${dockerArgs.join(' ')}`, {
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                    });
+                    this.log(output);
+                }
+                catch (error) {
+                    if (error instanceof Error && 'stderr' in error) {
+                        this.error(`Failed to get logs: ${error.stderr}`);
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+}

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

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

package/dist/commands/docker/prune.js

@@ -0,0 +1,211 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync } from 'child_process';
+import inquirer from 'inquirer';
+import { styles } from '../../lib/styles.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class DockerPrune extends Command {
+    static description = 'Remove unused Docker resources (containers, images, volumes, networks)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --volumes',
+        '<%= 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 unused images, not just dangling ones',
+            default: false,
+        }),
+        volumes: Flags.boolean({
+            description: 'Also prune volumes (dangerous - data loss possible)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DockerPrune);
+        if (!isDockerRunning()) {
+            this.error('Docker is not running. Start Docker Desktop or the Docker daemon first.');
+        }
+        this.log(`\n${styles.header('Docker Prune')}`);
+        this.log('─'.repeat(60));
+        // Get current disk usage
+        this.log(styles.subheader('\nCurrent Docker disk usage:'));
+        try {
+            const dfOutput = execSync('docker system df', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.log(styles.muted(dfOutput));
+        }
+        catch {
+            this.log(styles.muted('Could not get disk usage info'));
+        }
+        // Show what will be pruned
+        this.log(styles.subheader('Will remove:'));
+        this.log(styles.muted('  • Stopped containers'));
+        this.log(styles.muted('  • Unused networks'));
+        if (flags.all) {
+            this.log(styles.muted('  • All unused images (not just dangling)'));
+        }
+        else {
+            this.log(styles.muted('  • Dangling images'));
+        }
+        this.log(styles.muted('  • Build cache'));
+        if (flags.volumes) {
+            this.log(styles.warning('  • Unused volumes (DATA LOSS POSSIBLE)'));
+        }
+        if (flags['dry-run']) {
+            this.log(`\n${styles.warning('[DRY RUN] Would prune the above resources')}\n`);
+            // Show what would be removed
+            this.showPrunePreview(flags.all, flags.volumes);
+            return;
+        }
+        // Confirm
+        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 = flags.volumes
+                ? 'This will remove unused resources INCLUDING VOLUMES. Data may be lost. Continue?'
+                : 'Remove unused Docker resources?';
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', confirmMessage, confirmChoices), createMetadata('docker prune', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: confirmMessage,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                this.log(`${styles.muted('Aborted.')}\n`);
+                return;
+            }
+        }
+        // Run prune
+        this.log(`\n${styles.muted('Pruning Docker resources...')}\n`);
+        try {
+            // Prune containers
+            this.log(styles.muted('Removing stopped containers...'));
+            const containerResult = execSync('docker container prune -f', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.log(styles.muted(containerResult.trim()));
+            // Prune networks
+            this.log(styles.muted('\nRemoving unused networks...'));
+            const networkResult = execSync('docker network prune -f', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.log(styles.muted(networkResult.trim()));
+            // Prune images
+            this.log(styles.muted('\nRemoving unused images...'));
+            const imageCmd = flags.all ? 'docker image prune -af' : 'docker image prune -f';
+            const imageResult = execSync(imageCmd, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.log(styles.muted(imageResult.trim()));
+            // Prune build cache
+            this.log(styles.muted('\nRemoving build cache...'));
+            const buildResult = execSync('docker builder prune -f', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.log(styles.muted(buildResult.trim()));
+            // Prune volumes if requested
+            if (flags.volumes) {
+                this.log(styles.warning('\nRemoving unused volumes...'));
+                const volumeResult = execSync('docker volume prune -f', {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                this.log(styles.muted(volumeResult.trim()));
+            }
+            this.log(`\n${styles.success('Docker prune completed')}`);
+            // Show new disk usage
+            this.log(styles.subheader('\nNew Docker disk usage:'));
+            const newDfOutput = execSync('docker system df', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.log(styles.muted(newDfOutput));
+        }
+        catch (error) {
+            this.log(styles.error(`Prune failed: ${error instanceof Error ? error.message : error}`));
+        }
+    }
+    showPrunePreview(includeAllImages, includeVolumes) {
+        this.log(styles.subheader('Preview of resources to remove:'));
+        this.log('');
+        // Stopped containers
+        try {
+            const containers = execSync('docker ps -aq --filter "status=exited" --filter "status=created"', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            const containerCount = containers ? containers.split('\n').length : 0;
+            this.log(styles.muted(`Containers: ${containerCount} stopped container(s)`));
+        }
+        catch {
+            this.log(styles.muted('Containers: Unable to check'));
+        }
+        // Dangling images
+        try {
+            const imageCmd = includeAllImages
+                ? 'docker images -q --filter "dangling=false" | wc -l'
+                : 'docker images -q --filter "dangling=true" | wc -l';
+            const imageCount = execSync(imageCmd, {
+                encoding: 'utf-8',
+                shell: '/bin/sh',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            const label = includeAllImages ? 'unused image(s)' : 'dangling image(s)';
+            this.log(styles.muted(`Images: ${imageCount} ${label}`));
+        }
+        catch {
+            this.log(styles.muted('Images: Unable to check'));
+        }
+        // Volumes
+        if (includeVolumes) {
+            try {
+                const volumes = execSync('docker volume ls -q --filter "dangling=true"', {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                const volumeCount = volumes ? volumes.split('\n').length : 0;
+                this.log(styles.warning(`Volumes: ${volumeCount} unused volume(s)`));
+            }
+            catch {
+                this.log(styles.muted('Volumes: Unable to check'));
+            }
+        }
+        this.log('');
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class DockerRestart extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        time: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        target: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}