@proletariat/cli 0.1.4 → 0.3.0

package/dist/lib/docker/resolve.js

@@ -0,0 +1,175 @@
+/**
+ * Docker Container Resolution
+ *
+ * Resolves various identifiers to Docker container IDs.
+ * Accepts: execution ID (WORK-XXX), agent name, or container ID.
+ */
+import { execSync } from 'child_process';
+/**
+ * Validate and sanitize a container ID to prevent shell injection.
+ * Docker container IDs are 64-character hex strings (or 12-char short form).
+ * Container names can contain alphanumeric, underscore, hyphen, and period.
+ *
+ * @throws Error if the ID contains invalid characters
+ */
+export function sanitizeContainerId(id) {
+    // Docker IDs/names: alphanumeric, underscore, hyphen, period only
+    // This prevents shell injection via characters like ; | & $ ` etc.
+    if (!/^[a-zA-Z0-9_.-]+$/.test(id)) {
+        throw new Error(`Invalid container ID: contains disallowed characters`);
+    }
+    // Reasonable length check (full SHA is 64, short is 12, names vary)
+    if (id.length > 128) {
+        throw new Error(`Invalid container ID: too long`);
+    }
+    return id;
+}
+/**
+ * Resolve a target identifier to a Docker container ID.
+ *
+ * @param target - Execution ID (WORK-XXX), agent name, or container ID
+ * @param executionStorage - ExecutionStorage instance
+ * @returns ResolveResult with containerId or error
+ */
+export function resolveContainerId(target, executionStorage) {
+    // Try as execution ID first (WORK-XXX pattern)
+    if (target.toUpperCase().startsWith('WORK-')) {
+        const execution = executionStorage.getExecution(target.toUpperCase());
+        if (!execution) {
+            return {
+                containerId: null,
+                displayName: target,
+                error: `Execution ${target} not found`,
+            };
+        }
+        if (!execution.containerId) {
+            return {
+                containerId: null,
+                executionId: execution.id,
+                agentName: execution.agentName,
+                displayName: `${execution.id} (${execution.agentName})`,
+                error: `Execution ${execution.id} has no associated container (environment: ${execution.environment})`,
+            };
+        }
+        return {
+            containerId: execution.containerId,
+            executionId: execution.id,
+            agentName: execution.agentName,
+            displayName: `${execution.id} (${execution.agentName})`,
+        };
+    }
+    // Try as agent name - look for running executions
+    const agentExecutions = executionStorage.getAgentRunningExecutions(target);
+    if (agentExecutions.length > 0) {
+        // Filter to those with containers
+        const withContainers = agentExecutions.filter((e) => e.containerId);
+        if (withContainers.length === 0) {
+            return {
+                containerId: null,
+                agentName: target,
+                displayName: target,
+                error: `Agent ${target} has ${agentExecutions.length} running execution(s) but none with containers`,
+            };
+        }
+        if (withContainers.length > 1) {
+            const ids = withContainers.map((e) => e.id).join(', ');
+            return {
+                containerId: null,
+                agentName: target,
+                displayName: target,
+                error: `Agent ${target} has multiple running containers. Specify an execution ID: ${ids}`,
+            };
+        }
+        const execution = withContainers[0];
+        return {
+            containerId: execution.containerId,
+            executionId: execution.id,
+            agentName: execution.agentName,
+            displayName: `${execution.id} (${execution.agentName})`,
+        };
+    }
+    // Try as container ID (full or partial)
+    const containerId = resolveDockerContainerId(target);
+    if (containerId) {
+        // Try to find matching execution
+        const allExecutions = executionStorage.listExecutions({ limit: 100 });
+        const matchingExecution = allExecutions.find((e) => e.containerId &&
+            (e.containerId === containerId ||
+                e.containerId.startsWith(target) ||
+                containerId.startsWith(e.containerId)));
+        return {
+            containerId,
+            executionId: matchingExecution?.id,
+            agentName: matchingExecution?.agentName,
+            displayName: matchingExecution
+                ? `${matchingExecution.id} (${matchingExecution.agentName})`
+                : `container ${target}`,
+        };
+    }
+    return {
+        containerId: null,
+        displayName: target,
+        error: `Could not find container for "${target}". Specify an execution ID (WORK-XXX), agent name, or container ID.`,
+    };
+}
+/**
+ * Resolve a partial container ID to full ID using docker.
+ */
+function resolveDockerContainerId(partialId) {
+    try {
+        // Sanitize before using in shell command
+        const safeId = sanitizeContainerId(partialId);
+        const output = execSync(`docker ps -aq --filter "id=${safeId}" --no-trunc`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const lines = output.split('\n').filter(Boolean);
+        if (lines.length === 1) {
+            return lines[0];
+        }
+        // Also try by name
+        const byName = execSync(`docker ps -aq --filter "name=${safeId}" --no-trunc`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const nameLines = byName.split('\n').filter(Boolean);
+        if (nameLines.length === 1) {
+            return nameLines[0];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a container is currently running.
+ */
+export function isContainerRunning(containerId) {
+    try {
+        const safeId = sanitizeContainerId(containerId);
+        const output = execSync(`docker inspect -f '{{.State.Running}}' ${safeId}`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return output === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a container exists (running or stopped).
+ */
+export function containerExists(containerId) {
+    try {
+        const safeId = sanitizeContainerId(containerId);
+        execSync(`docker inspect ${safeId}`, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,150 @@
+/**
+ * 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 Database from 'better-sqlite3';
+import { ExecutionConfig, TerminalApp, Shell, DisplayMode, OutputMode, ExecutionEnvironment } from './types.js';
+declare const CONFIG_KEYS: {
+    terminalApp: string;
+    shell: string;
+    defaultMode: string;
+    defaultExecutor: string;
+    autoExecute: string;
+    tmuxSession: string;
+    tmuxLayout: string;
+    tmuxControlMode: string;
+    dockerImage: string;
+    dockerNetwork: string;
+    dockerMemory: string;
+    dockerCpus: string;
+    vmDefaultHost: string;
+    vmUser: string;
+    vmKeyPath: string;
+    vmSyncMethod: string;
+    coderName: string;
+};
+/**
+ * Load execution config from database, merging with defaults
+ */
+export declare function loadExecutionConfig(db: Database.Database): ExecutionConfig;
+/**
+ * Save a single execution config setting to database
+ */
+export declare function saveExecutionSetting(db: Database.Database, key: keyof typeof CONFIG_KEYS, value: string): void;
+/**
+ * Save terminal app preference
+ */
+export declare function saveTerminalApp(db: Database.Database, app: TerminalApp): void;
+/**
+ * Save shell preference
+ */
+export declare function saveShell(db: Database.Database, shell: Shell): void;
+/**
+ * Save tmux control mode preference.
+ * When enabled and using iTerm, tmux -CC is used for native tab integration.
+ */
+export declare function saveTmuxControlMode(db: Database.Database, enabled: boolean): void;
+/**
+ * Check if terminal app preference has been set
+ */
+export declare function hasTerminalPreference(db: Database.Database): boolean;
+/**
+ * Check if shell preference has been set
+ */
+export declare function hasShellPreference(db: Database.Database): boolean;
+/**
+ * Auto-detect terminal app from environment.
+ * Uses TERM_PROGRAM env var set by most terminal emulators.
+ */
+export declare function detectTerminalApp(): TerminalApp | null;
+/**
+ * Auto-detect shell from environment.
+ * Uses SHELL env var.
+ */
+export declare function detectShell(): Shell | null;
+/**
+ * Prompt user for terminal app preference (first-time setup)
+ */
+export declare function promptTerminalPreference(db: Database.Database): Promise<TerminalApp>;
+/**
+ * Prompt user for tmux control mode preference (iTerm only).
+ * When enabled, tmux -CC is used for native iTerm tab/window integration.
+ */
+export declare function promptTmuxControlModePreference(db: Database.Database): Promise<boolean>;
+/**
+ * Get terminal app, auto-detecting or prompting if not set
+ */
+export declare function getTerminalApp(db: Database.Database): Promise<TerminalApp>;
+/**
+ * Prompt user for shell preference (first-time setup)
+ */
+export declare function promptShellPreference(db: Database.Database): Promise<Shell>;
+/**
+ * Get shell, auto-detecting or prompting if not set
+ */
+export declare function getShell(db: Database.Database): Promise<Shell>;
+export interface ExecutionPromptOptions {
+    /** Display mode selected by user */
+    displayMode: DisplayMode;
+    /** Environment selected by user */
+    environment: ExecutionEnvironment;
+    /** Skip output mode prompt and use this value instead */
+    outputMode?: OutputMode;
+    /** Skip permission prompt and use this value instead */
+    skipPermissions?: boolean;
+    /** Skip PR prompt and use this value instead */
+    createPR?: boolean;
+    /** Force re-prompt for terminal preferences */
+    reconfigure?: boolean;
+    /** Log function for status messages */
+    log?: (msg: string) => void;
+}
+export interface ExecutionPromptResult {
+    /** Execution config with terminal/shell/output settings */
+    executionConfig: ExecutionConfig;
+    /** Whether to skip permission checks */
+    skipPermissions: boolean;
+    /** Whether to create PR when work is ready */
+    createPR: boolean;
+}
+/**
+ * Prompt for all execution settings in a consistent way.
+ * Used by work start, work spawn, and work watch commands.
+ */
+export declare function promptExecutionSettings(db: Database.Database, options: ExecutionPromptOptions): Promise<ExecutionPromptResult>;
+/**
+ * Get GitHub username via gh CLI.
+ * Returns null if gh is not installed or not authenticated.
+ */
+export declare function getGitHubUsername(): string | null;
+/**
+ * Get git config user.name as default coder name.
+ * Returns null if git user.name is not configured.
+ */
+export declare function getGitUserName(): string | null;
+/**
+ * Get the configured coder name from the database.
+ * Returns null if not configured.
+ */
+export declare function getCoderName(db: Database.Database): string | null;
+/**
+ * Save coder name preference to database.
+ */
+export declare function saveCoderName(db: Database.Database, name: string): void;
+/**
+ * Check if coder name has been configured.
+ */
+export declare function hasCoderName(db: Database.Database): boolean;
+/**
+ * Prompt user for coder name preference (first-time setup).
+ * Uses git config user.name as default if available.
+ */
+export declare function promptCoderName(db: Database.Database): Promise<string>;
+/**
+ * Get coder name, auto-detecting from GitHub if not set.
+ * Priority: saved setting > GitHub username > git user.name > prompt
+ */
+export declare function getOrPromptCoderName(db: Database.Database): Promise<string>;
+export {};