@proletariat/cli 0.3.9 → 0.3.11

package/dist/lib/execution/devcontainer.js

@@ -7,6 +7,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { DEFAULT_EXECUTION_CONFIG } from './types.js';
+import { parseChannel } from '../workspace-config.js';
 /**
  * Generate default devcontainer.json content
  *
@@ -16,13 +17,28 @@ import { DEFAULT_EXECUTION_CONFIG } from './types.js';
  */
 export function generateDevcontainerJson(options, config) {
     const cfg = config || DEFAULT_EXECUTION_CONFIG;
+    // Parse the channel to determine registry and version
+    const channel = parseChannel(options.prltChannel || 'npm');
+    const useMount = channel.registry === 'mount';
+    // Build args for Dockerfile
+    const buildArgs = {
+        TZ: options.timezone || 'America/Los_Angeles',
+    };
+    // Pass registry and version to Dockerfile
+    // For mount mode, we pass PRLT_REGISTRY=mount so Dockerfile skips npm install
+    buildArgs.PRLT_REGISTRY = channel.registry;
+    if (!useMount) {
+        buildArgs.PRLT_VERSION = channel.version || 'latest';
+    }
+    // For GitHub Packages, pass GITHUB_TOKEN as build arg
+    if (channel.registry === 'gh') {
+        buildArgs.GITHUB_TOKEN = '${localEnv:GITHUB_TOKEN}';
+    }
     const devcontainerJson = {
         name: `Agent: ${options.agentName}`,
         build: {
             dockerfile: 'Dockerfile',
-            args: {
-                TZ: options.timezone || 'America/Los_Angeles',
-            },
+            args: buildArgs,
         },
         customizations: {
             vscode: {
@@ -49,6 +65,8 @@ export function generateDevcontainerJson(options, config) {
             'source=claude-credentials,target=/home/node/.claude,type=volume',
             // NOTE: ~/.claude.json is COPIED (not mounted) to /workspace/.claude.json
             // to avoid corruption from concurrent writes by multiple containers
+            // NOTE: SSH agent socket mounting doesn't work reliably on Docker Desktop for Mac
+            // So we use HTTPS + token approach instead. The token is fetched fresh at spawn time.
             'source=${localEnv:PRLT_HQ_PATH}/.proletariat,target=/hq/.proletariat,type=bind',
             // PMO path can be anywhere (e.g., /hq/pmo or /hq/repos/myrepo/pmo)
             // Use PRLT_PMO_PATH env var to mount the actual location to /hq/pmo
@@ -57,6 +75,9 @@ export function generateDevcontainerJson(options, config) {
             // Worktree .git files reference paths like /Users/.../repos/{repoName}/.git/worktrees/name
             // These mounts make those paths accessible inside the container at /hq/repos/{repoName}
             ...(options.repoWorktrees || []).map(repoName => `source=\${localEnv:PRLT_HQ_PATH}/repos/${repoName},target=/hq/repos/${repoName},type=bind`),
+            // If using "mount" channel, mount local prlt build from PRLT_REPO_PATH
+            // The setup-prlt.sh script will detect /opt/prlt and configure the wrapper
+            ...(useMount ? ['source=${localEnv:PRLT_REPO_PATH},target=/opt/prlt,type=bind,readonly'] : []),
         ],
         containerEnv: {
             DEVCONTAINER: 'true',
@@ -129,8 +150,17 @@ USER node
 RUN npm install -g pnpm && npm install -g @anthropic-ai/claude-code
 USER root
 
-# Install prlt CLI from npm
-RUN npm install -g @proletariat/cli
+# Install prlt CLI from public npm
+# PRLT_REGISTRY: "npm" (install from npmjs.com) or "mount" (use host mount)
+# PRLT_VERSION: version/tag like "latest", "dev", "next", or "1.2.3"
+ARG PRLT_REGISTRY=npm
+ARG PRLT_VERSION=latest
+RUN if [ "\${PRLT_REGISTRY}" = "npm" ] || [ "\${PRLT_REGISTRY}" = "gh" ]; then \\
+      echo "Installing @proletariat/cli@\${PRLT_VERSION} from npm..." && \\
+      npm install -g @proletariat/cli@\${PRLT_VERSION}; \\
+    else \\
+      echo "prlt will be mounted from host (mount mode)"; \\
+    fi
 
 # Copy and set up scripts
 COPY init-firewall.sh /usr/local/bin/init-firewall.sh
@@ -365,8 +395,8 @@ if [ -f "/workspace/.claude.json" ]; then
     echo "Claude credentials copied"
 fi
 
-# Configure git to use GitHub token for authentication
-# Check for token in environment or get from gh CLI
+# Configure git authentication using GitHub token
+# Token is passed via GITHUB_TOKEN env var (set fresh at spawn time by runners.ts)
 TOKEN=""
 if [ -n "$GITHUB_TOKEN" ]; then
     TOKEN="$GITHUB_TOKEN"
@@ -398,7 +428,7 @@ if [ -n "$TOKEN" ]; then
 
     echo "Git configured for GitHub push via HTTPS"
 else
-    echo "Warning: No GitHub token found, push to GitHub will require manual auth"
+    echo "Warning: No GitHub token found, git push will require manual auth"
 fi
 
 # Check if prlt is already installed globally (via npm from GitHub Packages)
@@ -456,7 +486,9 @@ LOADER_EOF
 NODE_NO_WARNINGS=1 exec node --experimental-loader /home/node/.prlt-local/loader.mjs /opt/prlt/apps/cli/bin/run.js "$@"
 WRAPPER_EOF
     chmod +x "$WRAPPER"
-    echo "prlt wrapper ready at $WRAPPER"
+    # Create prltdev symlink for consistency with dev environment
+    ln -sf "$WRAPPER" /home/node/.npm-global/bin/prltdev
+    echo "prlt wrapper ready at $WRAPPER (also available as prltdev)"
 else
     echo "No mounted prlt found, skipping setup"
 fi

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

@@ -10,6 +10,54 @@ import { ExecutionEnvironment, DisplayMode, SessionManager, ExecutorType, Execut
  * Example: "TKT-347-implement-altman"
  */
 export declare function buildSessionName(context: ExecutionContext): string;
+import type { TerminalApp } from './types.js';
+/**
+ * Check if tmux control mode (-CC) should be used.
+ * Control mode is only used with iTerm when controlMode is enabled in config.
+ *
+ * When control mode is active:
+ * - iTerm handles scrolling, selection, and gestures natively
+ * - tmux mouse mode should be disabled to avoid conflicts
+ */
+export declare function shouldUseControlMode(terminalApp: TerminalApp, controlModeEnabled: boolean): boolean;
+/**
+ * Build the tmux mouse option string for session creation.
+ * Enables mouse mode for scroll support in tmux.
+ * To select text or switch tabs, hold Shift or Option to bypass tmux.
+ */
+export declare function buildTmuxMouseOption(_useControlMode: boolean): string;
+/**
+ * Build the tmux attach command based on control mode.
+ * Uses -u -CC flags for iTerm control mode (native scrolling/selection).
+ * -u forces UTF-8 mode which is required for proper iTerm integration.
+ * Uses regular attach otherwise.
+ */
+export declare function buildTmuxAttachCommand(useControlMode: boolean, includeUnicodeFlag?: boolean): string;
+/**
+ * Configure iTerm tmux preferences for control mode.
+ * - windowMode: whether tmux -CC opens windows as tabs or new windows
+ * - autoHide: automatically bury/hide the control session (the terminal where -CC was run)
+ * @param mode - 'tab' for tabs in current window, 'window' for new windows
+ */
+export declare function configureITermTmuxPreferences(mode: 'tab' | 'window'): void;
+export declare function configureITermTmuxWindowMode(mode: 'tab' | 'window'): void;
+/**
+ * Check if the claude-credentials Docker volume exists.
+ */
+export declare function credentialsVolumeExists(): boolean;
+/**
+ * Check if valid Claude credentials exist in the Docker volume.
+ * Returns true if credentials exist and are not expired.
+ */
+export declare function dockerCredentialsExist(): boolean;
+/**
+ * Get Docker credential info for display.
+ * Returns expiration date and subscription type if available.
+ */
+export declare function getDockerCredentialInfo(): {
+    expiresAt: Date;
+    subscriptionType?: string;
+} | null;
 export interface RunnerResult {
     success: boolean;
     pid?: string;
@@ -29,6 +77,17 @@ export type Runner = (context: ExecutionContext, executor: ExecutorType, config:
  * - User can reattach with `prlt session attach` if tab is closed
  */
 export declare function runHost(context: ExecutionContext, executor: ExecutorType, config: ExecutionConfig, displayMode?: DisplayMode): Promise<RunnerResult>;
+/**
+ * Check if GitHub token is available for git push operations.
+ * Checks environment variables first, then tries gh auth token.
+ * Returns the token if available, null otherwise.
+ */
+export declare function getGitHubToken(): string | null;
+/**
+ * Check if GitHub token is available.
+ * Returns true if token is available via env vars or gh CLI.
+ */
+export declare function isGitHubTokenAvailable(): boolean;
 /**
  * Check if Docker daemon is running.
  * Returns true if Docker is available and responsive.
@@ -36,9 +95,32 @@ export declare function runHost(context: ExecutionContext, executor: ExecutorTyp
  */
 export declare function isDockerRunning(): boolean;
 /**
- * Run command inside a devcontainer.
- * Uses the devcontainer CLI to start/exec in a VS Code devcontainer.
- * Provides filesystem isolation - agent can only access mounted worktrees.
+ * Check if the devcontainer CLI is installed.
+ * Returns true if the CLI is available, false otherwise.
+ * @deprecated No longer required - we use raw Docker commands now
+ */
+export declare function isDevcontainerCliInstalled(): boolean;
+/**
+ * Get the container name for an agent.
+ * Format: prlt-agent-{agentName}
+ */
+export declare function getAgentContainerName(agentName: string): string;
+/**
+ * Check if a Docker container exists (running or stopped).
+ */
+export declare function containerExists(containerName: string): boolean;
+/**
+ * Check if a Docker container is running.
+ */
+export declare function isContainerRunning(containerName: string): boolean;
+/**
+ * Get the container ID for a running container.
+ */
+export declare function getContainerId(containerName: string): string | null;
+/**
+ * Run command inside a Docker container.
+ * Uses raw Docker commands for filesystem isolation - no devcontainer CLI required.
+ * Agent can only access mounted worktrees and configured paths.
  *
  * @param displayMode - How to display output (terminal, foreground, background, tmux)
  * @param sessionManager - How to manage the session inside the container (tmux, direct)