@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/docker/restart.js

@@ -0,0 +1,129 @@
+import { Args, 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 { resolveContainerId, containerExists, sanitizeContainerId } from '../../lib/docker/resolve.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class DockerRestart extends Command {
+    static description = 'Restart 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 --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            aliases: ['yes', 'y'],
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        time: Flags.integer({
+            char: 't',
+            description: 'Seconds to wait before killing the container during stop',
+            default: 10,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            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(DockerRestart);
+        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');
+            }
+            // Check if container exists
+            if (!containerExists(result.containerId)) {
+                db.close();
+                this.error(`Container ${result.displayName} does not exist`);
+            }
+            this.log(`\n${styles.header('Restart Container')}`);
+            this.log(styles.muted(`Target: ${result.displayName}`));
+            this.log(styles.muted(`Container: ${result.containerId.substring(0, 12)}\n`));
+            // 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: 'Yes', value: 'true' },
+                    { name: 'No', value: 'false' },
+                ];
+                const confirmMessage = `Restart container ${result.displayName}?`;
+                // In JSON mode, output confirmation prompt
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'confirmed', confirmMessage, confirmChoices), createMetadata('docker restart', flags));
+                    db.close();
+                    return;
+                }
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: confirmMessage,
+                        default: true,
+                    },
+                ]);
+                if (!confirm) {
+                    this.log(`${styles.muted('Aborted.')}\n`);
+                    db.close();
+                    return;
+                }
+            }
+            // Restart container
+            this.log(styles.muted(`Restarting container (timeout: ${flags.time}s)...`));
+            try {
+                const safeId = sanitizeContainerId(result.containerId);
+                execSync(`docker restart -t ${flags.time} ${safeId}`, {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    timeout: (flags.time + 30) * 1000, // Extra time for startup
+                });
+                this.log(`${styles.success('Container restarted successfully')}\n`);
+            }
+            catch (error) {
+                this.log(`${styles.error(`Failed to restart container: ${error instanceof Error ? error.message : error}`)}\n`);
+            }
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class DockerShell extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        shell: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        user: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workdir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        target: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/docker/shell.js

@@ -0,0 +1,103 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { 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, isContainerRunning } from '../../lib/docker/resolve.js';
+export default class DockerShell extends Command {
+    static description = 'Open a shell in a running 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 --shell /bin/bash',
+    ];
+    static flags = {
+        shell: Flags.string({
+            char: 's',
+            description: 'Shell to use',
+            default: '/bin/sh',
+        }),
+        user: Flags.string({
+            char: 'u',
+            description: 'User to run as',
+        }),
+        workdir: Flags.string({
+            char: 'w',
+            description: 'Working directory inside the container',
+        }),
+    };
+    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(DockerShell);
+        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');
+            }
+            // Check if container is running
+            if (!isContainerRunning(result.containerId)) {
+                db.close();
+                this.error(`Container ${result.displayName} is not running. Start it first or use 'docker restart'.`);
+            }
+            this.log(`\n${styles.header(`Shell into ${result.displayName}`)}`);
+            this.log(styles.muted(`Container: ${result.containerId.substring(0, 12)}`));
+            this.log(styles.muted(`Shell: ${flags.shell}`));
+            this.log('─'.repeat(50) + '\n');
+            db.close();
+            // Build docker exec command
+            const dockerArgs = ['exec', '-it'];
+            if (flags.user) {
+                dockerArgs.push('--user', flags.user);
+            }
+            if (flags.workdir) {
+                dockerArgs.push('--workdir', flags.workdir);
+            }
+            dockerArgs.push(result.containerId, flags.shell);
+            // Spawn interactive shell
+            const proc = spawn('docker', dockerArgs, {
+                stdio: 'inherit',
+            });
+            proc.on('error', (err) => {
+                this.error(`Failed to open shell: ${err.message}`);
+            });
+            proc.on('exit', (code) => {
+                this.log('');
+                this.log(styles.muted(`Shell exited with code ${code}`));
+            });
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class DockerStart extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        attach: 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/start.js

@@ -0,0 +1,92 @@
+import { Args, 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 } from '../../lib/execution/storage.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { resolveContainerId, isContainerRunning, sanitizeContainerId } from '../../lib/docker/resolve.js';
+export default class DockerStart extends Command {
+    static description = 'Start a stopped 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',
+    ];
+    static flags = {
+        attach: Flags.boolean({
+            char: 'a',
+            description: 'Attach to container after starting',
+            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(DockerStart);
+        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');
+            }
+            // Check if container is already running
+            if (isContainerRunning(result.containerId)) {
+                this.log(`\n${styles.warning(`Container ${result.displayName} is already running`)}\n`);
+                db.close();
+                return;
+            }
+            this.log(`\n${styles.header('Start Container')}`);
+            this.log(styles.muted(`Target: ${result.displayName}`));
+            this.log(styles.muted(`Container: ${result.containerId.substring(0, 12)}\n`));
+            // Start container
+            this.log(styles.muted('Starting container...'));
+            try {
+                const attachFlag = flags.attach ? '-a' : '';
+                const safeId = sanitizeContainerId(result.containerId);
+                execSync(`docker start ${attachFlag} ${safeId}`, {
+                    stdio: flags.attach ? 'inherit' : ['pipe', 'pipe', 'pipe'],
+                });
+                // Update execution status if we have an execution ID
+                if (result.executionId) {
+                    executionStorage.updateStatus(result.executionId, 'running');
+                }
+                this.log(`${styles.success('Container started successfully')}\n`);
+            }
+            catch (error) {
+                this.log(`${styles.error(`Failed to start container: ${error instanceof Error ? error.message : error}`)}\n`);
+            }
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+export default class DockerStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/docker/status.js

@@ -0,0 +1,40 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'child_process';
+import { styles } from '../../lib/styles.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+export default class DockerStatus extends Command {
+    static description = 'Check if Docker daemon is running';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {};
+    async run() {
+        this.log(`\n${styles.header('Docker Status')}`);
+        this.log('─'.repeat(50));
+        const running = isDockerRunning();
+        if (running) {
+            this.log(`${styles.success('Running')} Docker daemon is available`);
+            // Get more details
+            try {
+                const version = execSync('docker version --format "{{.Server.Version}}"', {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                const info = execSync('docker info --format "{{.Containers}} containers ({{.ContainersRunning}} running)"', {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                this.log(`\n${styles.muted(`  Version: ${version}`)}`);
+                this.log(styles.muted(`  ${info}\n`));
+            }
+            catch {
+                // Ignore errors getting additional info
+                this.log('');
+            }
+        }
+        else {
+            this.log(`${styles.error('Not Running')} Docker daemon is not available\n`);
+            this.log(`${styles.muted('Start Docker Desktop or the Docker daemon to use devcontainer features.')}\n`);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class DockerStop 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>;
+}

package/dist/commands/docker/stop.js

@@ -0,0 +1,134 @@
+import { Args, 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 { resolveContainerId, isContainerRunning, sanitizeContainerId } from '../../lib/docker/resolve.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class DockerStop extends Command {
+    static description = 'Stop a running 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 --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            aliases: ['yes', 'y'],
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        time: Flags.integer({
+            char: 't',
+            description: 'Seconds to wait before killing the container',
+            default: 10,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            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(DockerStop);
+        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');
+            }
+            // Check if container is running
+            if (!isContainerRunning(result.containerId)) {
+                this.log(`\n${styles.warning(`Container ${result.displayName} is not running`)}\n`);
+                db.close();
+                return;
+            }
+            this.log(`\n${styles.header('Stop Container')}`);
+            this.log(styles.muted(`Target: ${result.displayName}`));
+            this.log(styles.muted(`Container: ${result.containerId.substring(0, 12)}\n`));
+            // 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 = `Stop container ${result.displayName}?`;
+                // In JSON mode, output confirmation prompt
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'confirmed', confirmMessage, confirmChoices), createMetadata('docker stop', flags));
+                    db.close();
+                    return;
+                }
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: confirmMessage,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    this.log(`${styles.muted('Aborted.')}\n`);
+                    db.close();
+                    return;
+                }
+            }
+            // Stop container
+            this.log(styles.muted(`Stopping container (timeout: ${flags.time}s)...`));
+            try {
+                const safeId = sanitizeContainerId(result.containerId);
+                execSync(`docker stop -t ${flags.time} ${safeId}`, {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    timeout: (flags.time + 5) * 1000,
+                });
+                // Update execution status if we have an execution ID
+                if (result.executionId) {
+                    executionStorage.updateStatus(result.executionId, 'stopped');
+                }
+                this.log(`${styles.success('Container stopped successfully')}\n`);
+            }
+            catch (error) {
+                this.log(`${styles.error(`Failed to stop container: ${error instanceof Error ? error.message : error}`)}\n`);
+            }
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class DockerSync extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    /**
+     * Get raw container info from Docker
+     */
+    private getDockerContainers;
+    /**
+     * Extract agent name from devcontainer image name.
+     * Only used for initial sync - DB is source of truth after that.
+     */
+    private extractAgentFromImage;
+}