@proletariat/cli 0.2.0 → 0.3.0

package/dist/lib/execution/config.js

@@ -0,0 +1,541 @@
+/**
+ * Execution Configuration Storage
+ *
+ * Stores user preferences for execution settings in the workspace SQLite database.
+ * Uses the workspace_settings table (not pmo_settings - execution is workspace-level).
+ */
+import inquirer from 'inquirer';
+import { DEFAULT_EXECUTION_CONFIG } from './types.js';
+import { isGHInstalled, isGHAuthenticated } from '../pr/index.js';
+import { execSync } from 'child_process';
+const SETTINGS_TABLE = 'workspace_settings';
+// Config keys stored in workspace_settings table
+const CONFIG_KEYS = {
+    terminalApp: 'execution.terminal.app',
+    shell: 'execution.shell',
+    defaultMode: 'execution.default_mode',
+    defaultExecutor: 'execution.default_executor',
+    autoExecute: 'execution.auto_execute',
+    tmuxSession: 'execution.tmux.session',
+    tmuxLayout: 'execution.tmux.layout',
+    tmuxControlMode: 'execution.tmux.control_mode',
+    dockerImage: 'execution.docker.image',
+    dockerNetwork: 'execution.docker.network',
+    dockerMemory: 'execution.docker.memory',
+    dockerCpus: 'execution.docker.cpus',
+    vmDefaultHost: 'execution.vm.default_host',
+    vmUser: 'execution.vm.user',
+    vmKeyPath: 'execution.vm.key_path',
+    vmSyncMethod: 'execution.vm.sync_method',
+    coderName: 'coder.name',
+};
+/**
+ * Get a setting value from the database
+ */
+function getSetting(db, key) {
+    const row = db
+        .prepare(`SELECT value FROM ${SETTINGS_TABLE} WHERE key = ?`)
+        .get(key);
+    return row?.value ?? null;
+}
+/**
+ * Set a setting value in the database
+ */
+function setSetting(db, key, value) {
+    db.prepare(`
+    INSERT INTO ${SETTINGS_TABLE} (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
+/**
+ * Load execution config from database, merging with defaults
+ */
+export function loadExecutionConfig(db) {
+    const config = { ...DEFAULT_EXECUTION_CONFIG };
+    // Load terminal app
+    const terminalApp = getSetting(db, CONFIG_KEYS.terminalApp);
+    if (terminalApp) {
+        config.terminal = { app: terminalApp };
+    }
+    // Load shell
+    const shell = getSetting(db, CONFIG_KEYS.shell);
+    if (shell) {
+        config.shell = shell;
+    }
+    // Load default environment
+    const defaultEnvironment = getSetting(db, CONFIG_KEYS.defaultMode);
+    if (defaultEnvironment) {
+        config.defaultEnvironment = defaultEnvironment;
+    }
+    // Load default executor
+    const defaultExecutor = getSetting(db, CONFIG_KEYS.defaultExecutor);
+    if (defaultExecutor) {
+        config.defaultExecutor = defaultExecutor;
+    }
+    // Load auto execute
+    const autoExecute = getSetting(db, CONFIG_KEYS.autoExecute);
+    if (autoExecute !== null) {
+        config.autoExecute = autoExecute === 'true';
+    }
+    // Load tmux settings
+    const tmuxSession = getSetting(db, CONFIG_KEYS.tmuxSession);
+    if (tmuxSession) {
+        config.tmux = { ...config.tmux, session: tmuxSession };
+    }
+    const tmuxLayout = getSetting(db, CONFIG_KEYS.tmuxLayout);
+    if (tmuxLayout) {
+        config.tmux = { ...config.tmux, layout: tmuxLayout };
+    }
+    const tmuxControlMode = getSetting(db, CONFIG_KEYS.tmuxControlMode);
+    if (tmuxControlMode !== null) {
+        config.tmux = { ...config.tmux, controlMode: tmuxControlMode === 'true' };
+    }
+    // Load docker settings
+    const dockerImage = getSetting(db, CONFIG_KEYS.dockerImage);
+    if (dockerImage) {
+        config.docker = { ...config.docker, image: dockerImage };
+    }
+    const dockerNetwork = getSetting(db, CONFIG_KEYS.dockerNetwork);
+    if (dockerNetwork) {
+        config.docker = { ...config.docker, network: dockerNetwork };
+    }
+    const dockerMemory = getSetting(db, CONFIG_KEYS.dockerMemory);
+    if (dockerMemory) {
+        config.docker = { ...config.docker, memory: dockerMemory };
+    }
+    const dockerCpus = getSetting(db, CONFIG_KEYS.dockerCpus);
+    if (dockerCpus) {
+        config.docker = { ...config.docker, cpus: parseInt(dockerCpus, 10) };
+    }
+    // Load VM settings
+    const vmDefaultHost = getSetting(db, CONFIG_KEYS.vmDefaultHost);
+    if (vmDefaultHost) {
+        config.vm = { ...config.vm, defaultHost: vmDefaultHost };
+    }
+    const vmUser = getSetting(db, CONFIG_KEYS.vmUser);
+    if (vmUser) {
+        config.vm = { ...config.vm, user: vmUser };
+    }
+    const vmKeyPath = getSetting(db, CONFIG_KEYS.vmKeyPath);
+    if (vmKeyPath) {
+        config.vm = { ...config.vm, keyPath: vmKeyPath };
+    }
+    const vmSyncMethod = getSetting(db, CONFIG_KEYS.vmSyncMethod);
+    if (vmSyncMethod) {
+        config.vm = { ...config.vm, syncMethod: vmSyncMethod };
+    }
+    return config;
+}
+/**
+ * Save a single execution config setting to database
+ */
+export function saveExecutionSetting(db, key, value) {
+    setSetting(db, CONFIG_KEYS[key], value);
+}
+/**
+ * Save terminal app preference
+ */
+export function saveTerminalApp(db, app) {
+    setSetting(db, CONFIG_KEYS.terminalApp, app);
+}
+/**
+ * Save shell preference
+ */
+export function saveShell(db, shell) {
+    setSetting(db, CONFIG_KEYS.shell, shell);
+}
+/**
+ * Save tmux control mode preference.
+ * When enabled and using iTerm, tmux -CC is used for native tab integration.
+ */
+export function saveTmuxControlMode(db, enabled) {
+    setSetting(db, CONFIG_KEYS.tmuxControlMode, enabled.toString());
+}
+/**
+ * Check if terminal app preference has been set
+ */
+export function hasTerminalPreference(db) {
+    return getSetting(db, CONFIG_KEYS.terminalApp) !== null;
+}
+/**
+ * Check if shell preference has been set
+ */
+export function hasShellPreference(db) {
+    return getSetting(db, CONFIG_KEYS.shell) !== null;
+}
+/**
+ * Auto-detect terminal app from environment.
+ * Uses TERM_PROGRAM env var set by most terminal emulators.
+ */
+export function detectTerminalApp() {
+    const termProgram = process.env.TERM_PROGRAM?.toLowerCase() || '';
+    // Map TERM_PROGRAM values to our TerminalApp type
+    if (termProgram === 'iterm.app')
+        return 'iTerm';
+    if (termProgram === 'apple_terminal')
+        return 'Terminal';
+    if (termProgram === 'alacritty')
+        return 'Alacritty';
+    if (termProgram === 'wezterm')
+        return 'WezTerm';
+    if (termProgram === 'ghostty')
+        return 'Ghostty';
+    if (termProgram === 'kitty')
+        return 'Kitty';
+    if (termProgram === 'warp')
+        return 'Warp';
+    // Also check TERMINAL_EMULATOR for some apps
+    const termEmulator = process.env.TERMINAL_EMULATOR?.toLowerCase() || '';
+    if (termEmulator.includes('jetbrains'))
+        return 'tmux'; // IDE terminal, fall back to tmux
+    return null;
+}
+/**
+ * Auto-detect shell from environment.
+ * Uses SHELL env var.
+ */
+export function detectShell() {
+    const shellPath = process.env.SHELL || '';
+    const shellName = shellPath.split('/').pop()?.toLowerCase() || '';
+    if (shellName === 'zsh')
+        return 'zsh';
+    if (shellName === 'bash')
+        return 'bash';
+    if (shellName === 'fish')
+        return 'fish';
+    return null;
+}
+/**
+ * Prompt user for terminal app preference (first-time setup)
+ */
+export async function promptTerminalPreference(db) {
+    const { terminalApp } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'terminalApp',
+            message: 'Which terminal app would you like to use for agent execution?',
+            choices: [
+                { name: 'iTerm', value: 'iTerm' },
+                { name: 'Terminal.app (macOS default)', value: 'Terminal' },
+                { name: 'Alacritty', value: 'Alacritty' },
+                { name: 'Ghostty', value: 'Ghostty' },
+                { name: 'Kitty', value: 'Kitty' },
+                { name: 'tmux', value: 'tmux' },
+                { name: 'Warp', value: 'Warp' },
+                { name: 'WezTerm', value: 'WezTerm' },
+            ],
+            default: 'iTerm',
+        },
+    ]);
+    // Save preference to database
+    saveTerminalApp(db, terminalApp);
+    // If iTerm selected, prompt for control mode preference
+    if (terminalApp === 'iTerm') {
+        await promptTmuxControlModePreference(db);
+    }
+    return terminalApp;
+}
+/**
+ * Prompt user for tmux control mode preference (iTerm only).
+ * When enabled, tmux -CC is used for native iTerm tab/window integration.
+ */
+export async function promptTmuxControlModePreference(db) {
+    const { useControlMode } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'useControlMode',
+            message: 'iTerm tmux integration mode:',
+            choices: [
+                {
+                    name: 'Native tabs (tmux -CC) - iTerm handles windows/scrollback natively (Recommended)',
+                    value: true,
+                },
+                {
+                    name: 'Standard tmux - Traditional tmux interface inside iTerm',
+                    value: false,
+                },
+            ],
+            default: true,
+        },
+    ]);
+    // Save preference to database
+    saveTmuxControlMode(db, useControlMode);
+    return useControlMode;
+}
+/**
+ * Get terminal app, auto-detecting or prompting if not set
+ */
+export async function getTerminalApp(db) {
+    const config = loadExecutionConfig(db);
+    // If already set, return it
+    if (hasTerminalPreference(db)) {
+        return config.terminal.app;
+    }
+    // Try auto-detection first
+    const detected = detectTerminalApp();
+    if (detected) {
+        saveTerminalApp(db, detected);
+        // If iTerm detected, also enable control mode by default (best experience)
+        if (detected === 'iTerm') {
+            saveTmuxControlMode(db, true);
+        }
+        return detected;
+    }
+    // Fall back to prompting user
+    return promptTerminalPreference(db);
+}
+/**
+ * Prompt user for shell preference (first-time setup)
+ */
+export async function promptShellPreference(db) {
+    const { shell } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'shell',
+            message: 'Which shell do you use?',
+            choices: [
+                { name: 'zsh (macOS default)', value: 'zsh' },
+                { name: 'bash', value: 'bash' },
+                { name: 'fish', value: 'fish' },
+            ],
+            default: 'zsh',
+        },
+    ]);
+    // Save preference to database
+    saveShell(db, shell);
+    return shell;
+}
+/**
+ * Get shell, auto-detecting or prompting if not set
+ */
+export async function getShell(db) {
+    const config = loadExecutionConfig(db);
+    // If already set, return it
+    if (hasShellPreference(db)) {
+        return config.shell;
+    }
+    // Try auto-detection first
+    const detected = detectShell();
+    if (detected) {
+        saveShell(db, detected);
+        return detected;
+    }
+    // Fall back to prompting user
+    return promptShellPreference(db);
+}
+/**
+ * Prompt for all execution settings in a consistent way.
+ * Used by work start, work spawn, and work watch commands.
+ */
+export async function promptExecutionSettings(db, options) {
+    const { displayMode, environment, log = () => { } } = options;
+    // Load execution config from database
+    const executionConfig = loadExecutionConfig(db);
+    // If terminal display mode, ensure terminal and shell preferences are set (prompts on first use)
+    const needsTerminalConfig = displayMode === 'terminal';
+    if (needsTerminalConfig) {
+        const needsTerminal = !hasTerminalPreference(db);
+        const needsShell = !hasShellPreference(db);
+        // First-time setup header
+        if ((needsTerminal || needsShell) && !options.reconfigure) {
+            log('First-time execution setup');
+            log('');
+        }
+        let terminalApp;
+        let shell;
+        if (options.reconfigure) {
+            terminalApp = await promptTerminalPreference(db);
+            shell = await promptShellPreference(db);
+        }
+        else {
+            terminalApp = await getTerminalApp(db);
+            shell = await getShell(db);
+        }
+        executionConfig.terminal.app = terminalApp;
+        executionConfig.shell = shell;
+    }
+    // Prompt for output mode (interactive vs print)
+    // Only show this for terminal mode where streaming makes sense (not background)
+    let outputMode = options.outputMode ?? DEFAULT_EXECUTION_CONFIG.outputMode;
+    const streamingDisplayModes = ['terminal'];
+    if (options.outputMode === undefined && streamingDisplayModes.includes(displayMode)) {
+        const { selectedOutputMode } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedOutputMode',
+                message: 'How should Claude display output?',
+                choices: [
+                    { name: 'interactive  - Watch Claude work in real-time (streaming UI)', value: 'interactive' },
+                    { name: 'print        - Show final result only (better for logs)', value: 'print' },
+                ],
+                default: 'interactive',
+            },
+        ]);
+        outputMode = selectedOutputMode;
+    }
+    executionConfig.outputMode = outputMode;
+    // Prompt for permissions mode (unless flag override is provided)
+    let skipPermissions = options.skipPermissions ?? false;
+    if (options.skipPermissions === undefined) {
+        const containerNote = (environment === 'devcontainer' || environment === 'docker')
+            ? ' (container provides additional isolation)'
+            : '';
+        const { permissionMode } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'permissionMode',
+                message: `Permission mode for Claude Code${containerNote}:`,
+                choices: [
+                    { name: '🔒 safe   - Requires approval for dangerous operations (recommended)', value: 'safe' },
+                    { name: '⚠️  danger - Skip permission checks (--dangerously-skip-permissions)', value: 'danger' },
+                ],
+                default: 'safe',
+            },
+        ]);
+        skipPermissions = permissionMode === 'danger';
+    }
+    // Prompt for PR creation when work is complete (unless flag override is provided)
+    let createPR = options.createPR ?? false;
+    if (options.createPR === undefined) {
+        const ghAvailable = isGHInstalled() && isGHAuthenticated();
+        if (ghAvailable) {
+            const { prChoice } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'prChoice',
+                    message: 'Create a pull request when work is ready?',
+                    choices: [
+                        { name: '✓ Yes - Create PR when running `prlt work ready`', value: 'yes' },
+                        { name: '✗ No  - Just move ticket to review (can create PR later)', value: 'no' },
+                    ],
+                    default: 'yes',
+                },
+            ]);
+            createPR = prChoice === 'yes';
+        }
+    }
+    return {
+        executionConfig,
+        skipPermissions,
+        createPR,
+    };
+}
+// =============================================================================
+// Coder Name Configuration
+// =============================================================================
+/**
+ * Get GitHub username via gh CLI.
+ * Returns null if gh is not installed or not authenticated.
+ */
+export function getGitHubUsername() {
+    try {
+        const username = execSync('gh api user --jq .login', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return username || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get git config user.name as default coder name.
+ * Returns null if git user.name is not configured.
+ */
+export function getGitUserName() {
+    try {
+        const userName = execSync('git config user.name', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return userName || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the configured coder name from the database.
+ * Returns null if not configured.
+ */
+export function getCoderName(db) {
+    return getSetting(db, CONFIG_KEYS.coderName);
+}
+/**
+ * Save coder name preference to database.
+ */
+export function saveCoderName(db, name) {
+    setSetting(db, CONFIG_KEYS.coderName, name);
+}
+/**
+ * Check if coder name has been configured.
+ */
+export function hasCoderName(db) {
+    return getSetting(db, CONFIG_KEYS.coderName) !== null;
+}
+/**
+ * Prompt user for coder name preference (first-time setup).
+ * Uses git config user.name as default if available.
+ */
+export async function promptCoderName(db) {
+    const gitUserName = getGitUserName();
+    const defaultName = gitUserName
+        ? gitUserName.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+        : '';
+    const { coderName } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'coderName',
+            message: 'Enter your coder name (used in branch names):',
+            default: defaultName || undefined,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Coder name is required';
+                }
+                // Validate it's kebab-case compatible
+                const normalized = input.toLowerCase().replace(/[^a-z0-9-]/g, '');
+                if (normalized !== input) {
+                    return 'Coder name must be lowercase letters, numbers, and hyphens only';
+                }
+                return true;
+            },
+        },
+    ]);
+    // Save preference to database
+    saveCoderName(db, coderName);
+    return coderName;
+}
+/**
+ * Get coder name, auto-detecting from GitHub if not set.
+ * Priority: saved setting > GitHub username > git user.name > prompt
+ */
+export async function getOrPromptCoderName(db) {
+    // If already set, return it
+    const existing = getCoderName(db);
+    if (existing) {
+        return existing;
+    }
+    // Try GitHub username first (most reliable for branch naming)
+    const ghUsername = getGitHubUsername();
+    if (ghUsername) {
+        saveCoderName(db, ghUsername);
+        return ghUsername;
+    }
+    // Fall back to git user.name (normalized to kebab-case)
+    const gitUserName = getGitUserName();
+    if (gitUserName) {
+        const normalized = gitUserName
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        if (normalized) {
+            saveCoderName(db, normalized);
+            return normalized;
+        }
+    }
+    // Last resort - prompt user
+    return promptCoderName(db);
+}

package/dist/lib/execution/devcontainer.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Devcontainer Template Generator
+ *
+ * Generates .devcontainer/ configuration for agent sandboxed execution.
+ * Uses a custom Dockerfile with network firewall for security sandboxing.
+ */
+import { ExecutionConfig } from './types.js';
+export interface DevcontainerOptions {
+    agentName: string;
+    agentDir: string;
+    repoWorktrees?: string[];
+    memory?: string;
+    cpus?: number;
+    timezone?: string;
+}
+export interface DevcontainerJson {
+    name: string;
+    build: {
+        dockerfile: string;
+        args?: Record<string, string>;
+    };
+    customizations: {
+        vscode: {
+            extensions: string[];
+            settings?: Record<string, unknown>;
+        };
+    };
+    capAdd: string[];
+    runArgs: string[];
+    remoteUser: string;
+    mounts: string[];
+    containerEnv?: Record<string, string>;
+    workspaceFolder: string;
+    postStartCommand: string;
+    waitFor: string;
+}
+/**
+ * Generate default devcontainer.json content
+ *
+ * Uses a custom Dockerfile with firewall for network sandboxing.
+ * Mounts the entire agent workspace directory so all contents (repos, prompt files, etc.)
+ * are accessible inside the container at /workspace.
+ */
+export declare function generateDevcontainerJson(options: DevcontainerOptions, config?: ExecutionConfig): DevcontainerJson;
+/**
+ * Generate Dockerfile content for the devcontainer.
+ * Uses architecture auto-detection for cross-platform compatibility.
+ */
+export declare function generateDockerfile(options: DevcontainerOptions): string;
+/**
+ * Generate firewall initialization script.
+ * Whitelists only necessary domains for Claude Code operation.
+ */
+export declare function generateFirewallScript(): string;
+/**
+ * Generate prlt setup script.
+ * Rebuilds better-sqlite3 if prlt is mounted from host (not installed via npm).
+ */
+export declare function generatePrltSetupScript(): string;
+/**
+ * Create .devcontainer/ directory structure for an agent
+ * Writes devcontainer.json, Dockerfile, and init-firewall.sh
+ */
+export declare function createDevcontainerConfig(options: DevcontainerOptions, config?: ExecutionConfig): void;
+/**
+ * Check if agent has devcontainer configuration
+ */
+export declare function hasDevcontainerConfig(agentDir: string): boolean;
+/**
+ * Read existing devcontainer.json
+ */
+export declare function readDevcontainerJson(agentDir: string): DevcontainerJson | null;
+/**
+ * Update devcontainer.json with new mounts (e.g., when new repo worktrees are added)
+ *
+ * Note: With the simplified mount strategy (entire agent workspace), this is mainly
+ * for backwards compatibility or if someone wants to customize mounts.
+ */
+export declare function updateDevcontainerMounts(agentDir: string, _repoWorktrees: string[]): void;
+/**
+ * Get list of repo directories inside the agent workspace.
+ * With the full workspace mount, this returns all non-hidden subdirectories
+ * (excluding .devcontainer).
+ */
+export declare function getMountedRepos(agentDir: string): string[];