ralph-cli-sandboxed 0.4.0 → 0.4.2

package/dist/commands/run.js

@@ -1,9 +1,9 @@
 import { spawn } from "child_process";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, appendFileSync, mkdirSync } from "fs";
 import { join } from "path";
-import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer } from "../utils/config.js";
+import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer, } from "../utils/config.js";
 import { resolvePromptVariables, getCliProviders } from "../templates/prompts.js";
-import { validatePrd, smartMerge, readPrdFile, writePrd, expandPrdFileReferences } from "../utils/prd-validator.js";
+import { validatePrd, smartMerge, readPrdFile, writePrd, expandPrdFileReferences, } from "../utils/prd-validator.js";
 import { getStreamJsonParser } from "../utils/stream-json.js";
 import { sendNotificationWithDaemonEvents } from "../utils/notification.js";
 const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing", "docs"];
@@ -32,10 +32,10 @@ function createFilteredPrd(prdPath, baseDir, category) {
         process.exit(1);
     }
     const items = parsed;
-    let filteredItems = items.filter(item => item.passes === false);
+    let filteredItems = items.filter((item) => item.passes === false);
     // Apply category filter if specified
     if (category) {
-        filteredItems = filteredItems.filter(item => item.category === category);
+        filteredItems = filteredItems.filter((item) => item.category === category);
     }
     // Expand @{filepath} references in description and steps
     const expandedItems = expandPrdFileReferences(filteredItems, baseDir);
@@ -44,7 +44,7 @@ function createFilteredPrd(prdPath, baseDir, category) {
     writeFileSync(tempPath, JSON.stringify(expandedItems, null, 2));
     return {
         tempPath,
-        hasIncomplete: filteredItems.length > 0
+        hasIncomplete: filteredItems.length > 0,
     };
 }
 /**
@@ -67,7 +67,15 @@ function syncPassesFromTasks(tasksPath, prdPath) {
         }
         const tasks = tasksParsed;
         const prdContent = readFileSync(prdPath, "utf-8");
-        const prdParsed = JSON.parse(prdContent);
+        let prdParsed;
+        try {
+            prdParsed = JSON.parse(prdContent);
+        }
+        catch {
+            console.warn("\x1b[33mWarning: prd.json contains invalid JSON - skipping sync.\x1b[0m");
+            console.warn("Run \x1b[36mralph fix-prd\x1b[0m after this session to repair.\n");
+            return { count: 0, taskNames: [] };
+        }
         if (!Array.isArray(prdParsed)) {
             console.warn("\x1b[33mWarning: prd.json is corrupted - skipping sync.\x1b[0m");
             console.warn("Run \x1b[36mralph fix-prd\x1b[0m after this session to repair.\n");
@@ -80,7 +88,7 @@ function syncPassesFromTasks(tasksPath, prdPath) {
         for (const task of tasks) {
             if (task.passes === true) {
                 // Find matching item in prd by description
-                const match = prd.find(item => item.description === task.description ||
+                const match = prd.find((item) => item.description === task.description ||
                     item.description.includes(task.description) ||
                     task.description.includes(item.description));
                 if (match && !match.passes) {
@@ -108,9 +116,7 @@ async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig
         let jsonLogPath;
         let lineBuffer = ""; // Buffer for incomplete JSON lines
         // Build CLI arguments: config args + yolo args + model args + prompt args
-        const cliArgs = [
-            ...(cliConfig.args ?? []),
-        ];
+        const cliArgs = [...(cliConfig.args ?? [])];
         // Only add yolo args when running in a container
         // Use yoloArgs from config if available, otherwise default to Claude's --dangerously-skip-permissions
         if (sandboxed) {
@@ -155,7 +161,7 @@ async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig
         }
         cliArgs.push(...promptArgs, promptValue);
         if (debug) {
-            console.log(`[debug] ${cliConfig.command} ${cliArgs.map(a => a.includes(" ") ? `"${a}"` : a).join(" ")}\n`);
+            console.log(`[debug] ${cliConfig.command} ${cliArgs.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}\n`);
             if (jsonLogPath) {
                 console.log(`[debug] Saving raw JSON to: ${jsonLogPath}\n`);
             }
@@ -246,7 +252,7 @@ async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig
  * Sleep for the specified number of milliseconds.
  */
 function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
  * Formats elapsed time in a human-readable format.
@@ -291,14 +297,14 @@ function countPrdItems(prdPath, category) {
     const items = parsed;
     let filteredItems = items;
     if (category) {
-        filteredItems = items.filter(item => item.category === category);
+        filteredItems = items.filter((item) => item.category === category);
     }
-    const complete = filteredItems.filter(item => item.passes === true).length;
-    const incomplete = filteredItems.filter(item => item.passes === false).length;
+    const complete = filteredItems.filter((item) => item.passes === true).length;
+    const incomplete = filteredItems.filter((item) => item.passes === false).length;
     return {
         total: filteredItems.length,
         complete,
-        incomplete
+        incomplete,
     };
 }
 /**
@@ -332,7 +338,7 @@ function validateAndRecoverPrd(prdPath, validPrd) {
         console.log("\x1b[32mRecovered: restored valid PRD structure.\x1b[0m");
     }
     if (mergeResult.warnings.length > 0) {
-        mergeResult.warnings.forEach(w => console.log(`  \x1b[33m${w}\x1b[0m`));
+        mergeResult.warnings.forEach((w) => console.log(`  \x1b[33m${w}\x1b[0m`));
     }
     return { recovered: true, itemsUpdated: mergeResult.itemsUpdated };
 }
@@ -342,7 +348,14 @@ function validateAndRecoverPrd(prdPath, validPrd) {
  */
 function loadValidPrd(prdPath) {
     const content = readFileSync(prdPath, "utf-8");
-    return JSON.parse(content);
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        console.error("\x1b[31mError: prd.json contains invalid JSON.\x1b[0m");
+        console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
+        process.exit(1);
+    }
 }
 export async function run(args) {
     // Parse flags
@@ -419,13 +432,15 @@ export async function run(args) {
     // Only use provider's streamJsonArgs if defined, otherwise empty array (no special args)
     // This allows providers without JSON streaming to still have output displayed
     const streamJsonArgs = providerConfig?.streamJsonArgs ?? [];
-    const streamJson = streamJsonConfig?.enabled ? {
-        enabled: true,
-        saveRawJson: streamJsonConfig.saveRawJson !== false, // default true
-        outputDir: config.docker?.asciinema?.outputDir || ".recordings",
-        args: streamJsonArgs,
-        parser: getStreamJsonParser(config.cliProvider, debug),
-    } : undefined;
+    const streamJson = streamJsonConfig?.enabled
+        ? {
+            enabled: true,
+            saveRawJson: streamJsonConfig.saveRawJson !== false, // default true
+            outputDir: config.docker?.asciinema?.outputDir || ".recordings",
+            args: streamJsonArgs,
+            parser: getStreamJsonParser(config.cliProvider, debug),
+        }
+        : undefined;
     // Progress tracking: stop only if no tasks complete after N iterations
     const MAX_ITERATIONS_WITHOUT_PROGRESS = 3;
     // Get requested iteration count (may be adjusted dynamically)
@@ -467,6 +482,56 @@ export async function run(args) {
     let lastCompletedCount = initialCounts.complete;
     let lastTotalCount = initialCounts.total;
     let iterationsWithoutProgress = 0;
+    // Create PID file to prevent multiple concurrent runs
+    const pidFilePath = join(paths.dir, "run.pid");
+    // Check if another instance is already running
+    if (existsSync(pidFilePath)) {
+        try {
+            const existingPid = parseInt(readFileSync(pidFilePath, "utf-8").trim(), 10);
+            if (!isNaN(existingPid)) {
+                try {
+                    process.kill(existingPid, 0); // Check if process exists
+                    console.error(`\x1b[31mError: Another ralph run is already running (PID ${existingPid})\x1b[0m`);
+                    console.error("Use 'ralph stop' or '/stop' via Telegram to terminate it first.");
+                    process.exit(1);
+                }
+                catch {
+                    // Process doesn't exist, stale PID file - clean it up
+                    unlinkSync(pidFilePath);
+                }
+            }
+        }
+        catch {
+            // Ignore errors reading PID file, proceed to overwrite
+        }
+    }
+    // Write our PID file
+    writeFileSync(pidFilePath, process.pid.toString());
+    // Ensure PID file is cleaned up on exit
+    const cleanupPidFile = () => {
+        try {
+            if (existsSync(pidFilePath)) {
+                const storedPid = parseInt(readFileSync(pidFilePath, "utf-8").trim(), 10);
+                // Only delete if it's our PID (in case another instance started)
+                if (storedPid === process.pid) {
+                    unlinkSync(pidFilePath);
+                }
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    };
+    // Register cleanup handlers for various exit scenarios
+    process.on("exit", cleanupPidFile);
+    process.on("SIGINT", () => {
+        cleanupPidFile();
+        process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+        cleanupPidFile();
+        process.exit(143);
+    });
     try {
         while (true) {
             iterationCount++;
@@ -550,6 +615,7 @@ export async function run(args) {
                         command: config.notifyCommand,
                         debug,
                         daemonConfig: config.daemon,
+                        chatConfig: config.chat,
                     });
                     break;
                 }
@@ -564,6 +630,7 @@ export async function run(args) {
                     command: config.notifyCommand,
                     debug,
                     daemonConfig: config.daemon,
+                    chatConfig: config.chat,
                     taskName,
                 });
             }
@@ -598,7 +665,14 @@ export async function run(args) {
                     console.log(`Status: ${progressCounts.complete}/${progressCounts.total} complete, ${progressCounts.incomplete} remaining.`);
                     console.log("Check the PRD and task definitions for issues.");
                     // Send notification about stopped run
-                    await sendNotificationWithDaemonEvents("run_stopped", `Ralph: Run stopped - no progress after ${MAX_ITERATIONS_WITHOUT_PROGRESS} iterations. ${progressCounts.incomplete} tasks remaining.`, { command: config.notifyCommand, debug, daemonConfig: config.daemon });
+                    const stoppedMessage = `No progress after ${MAX_ITERATIONS_WITHOUT_PROGRESS} iterations. ${progressCounts.incomplete} tasks remaining.`;
+                    await sendNotificationWithDaemonEvents("run_stopped", `Ralph: Run stopped - ${stoppedMessage}`, {
+                        command: config.notifyCommand,
+                        debug,
+                        daemonConfig: config.daemon,
+                        chatConfig: config.chat,
+                        errorMessage: stoppedMessage,
+                    });
                     break;
                 }
             }
@@ -617,7 +691,14 @@ export async function run(args) {
                     console.error("This usually indicates a configuration error (e.g., missing API key).");
                     console.error("Please check your CLI configuration and try again.");
                     // Send notification about error
-                    await sendNotificationWithDaemonEvents("error", `Ralph: CLI failed ${consecutiveFailures} times with exit code ${exitCode}. Check configuration.`, { command: config.notifyCommand, debug, daemonConfig: config.daemon });
+                    const errorMessage = `CLI failed ${consecutiveFailures} times with exit code ${exitCode}. Check configuration.`;
+                    await sendNotificationWithDaemonEvents("error", `Ralph: ${errorMessage}`, {
+                        command: config.notifyCommand,
+                        debug,
+                        daemonConfig: config.daemon,
+                        chatConfig: config.chat,
+                        errorMessage,
+                    });
                     break;
                 }
                 console.log("Continuing to next iteration...");
@@ -662,6 +743,7 @@ export async function run(args) {
                         command: config.notifyCommand,
                         debug,
                         daemonConfig: config.daemon,
+                        chatConfig: config.chat,
                     });
                     break;
                 }
@@ -678,6 +760,8 @@ export async function run(args) {
                 // Ignore cleanup errors
             }
         }
+        // Clean up PID file
+        cleanupPidFile();
     }
     const endTime = Date.now();
     const elapsed = formatElapsedTime(startTime, endTime);

package/dist/commands/slack.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Slack setup command - automates Slack app creation for Ralph instances.
+ *
+ * Uses Slack's App Manifest API to programmatically create apps,
+ * ensuring each Ralph instance has its own dedicated Slack app.
+ */
+/**
+ * Main command handler.
+ */
+export declare function slack(args: string[]): Promise<void>;

package/dist/commands/slack.js

@@ -0,0 +1,333 @@
+/**
+ * Slack setup command - automates Slack app creation for Ralph instances.
+ *
+ * Uses Slack's App Manifest API to programmatically create apps,
+ * ensuring each Ralph instance has its own dedicated Slack app.
+ */
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getRalphDir, loadConfig } from "../utils/config.js";
+import { promptInput, promptConfirm } from "../utils/prompt.js";
+const HELP_TEXT = `
+ralph slack - Slack integration setup
+
+Usage:
+  ralph slack setup     Create a new Slack app for this Ralph instance
+  ralph slack status    Show current Slack configuration
+  ralph slack help      Show this help message
+
+The setup command will:
+  1. Create a new Slack app using the Slack App Manifest API
+  2. Guide you through installing the app to your workspace
+  3. Help you generate the required tokens
+  4. Save the configuration to .ralph/config.json
+
+Prerequisites:
+  - A Slack workspace where you have admin permissions
+  - A configuration token from https://api.slack.com/apps
+    → Click "Your App Configuration Tokens" → Generate Token
+    → Use the "Access Token" (not the Refresh Token) - both start with xoxe-
+    → This token is per-account, not per-app - you can reuse it
+
+Why separate apps?
+  Slack Socket Mode only allows ONE connection per app. Using the same app
+  for multiple Ralph instances causes messages to be randomly delivered to
+  the wrong instance. Each Ralph chat needs its own Slack app.
+`;
+/**
+ * Slack App Manifest for Ralph bot.
+ * Includes all required scopes, slash commands, and Socket Mode support.
+ */
+function createAppManifest(appName) {
+    return {
+        display_information: {
+            name: appName,
+            description: "Ralph AI assistant for software development",
+            background_color: "#1a1a2e",
+        },
+        features: {
+            bot_user: {
+                display_name: appName,
+                always_online: true,
+            },
+            slash_commands: [
+                {
+                    command: "/ralph",
+                    description: "Ralph AI assistant - run commands or chat with Claude",
+                    usage_hint: "<command> [args] or <prompt for Claude>",
+                    should_escape: false,
+                },
+            ],
+        },
+        oauth_config: {
+            scopes: {
+                bot: [
+                    "app_mentions:read",
+                    "chat:write",
+                    "chat:write.public",
+                    "commands",
+                    "channels:history",
+                    "groups:history",
+                    "im:history",
+                    "mpim:history",
+                    "channels:read",
+                    "groups:read",
+                    "im:read",
+                    "mpim:read",
+                    "users:read",
+                ],
+            },
+        },
+        settings: {
+            event_subscriptions: {
+                bot_events: [
+                    "message.channels",
+                    "message.groups",
+                    "message.im",
+                    "message.mpim",
+                    "app_mention",
+                ],
+            },
+            interactivity: {
+                is_enabled: true,
+            },
+            org_deploy_enabled: false,
+            socket_mode_enabled: true,
+            token_rotation_enabled: false,
+        },
+    };
+}
+/**
+ * Create a Slack app using the Manifest API.
+ */
+async function createSlackApp(configToken, appName) {
+    const manifest = createAppManifest(appName);
+    try {
+        const response = await fetch("https://slack.com/api/apps.manifest.create", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${configToken}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ manifest: JSON.stringify(manifest) }),
+        });
+        const data = (await response.json());
+        if (!data.ok) {
+            console.error(`\nError creating Slack app: ${data.error}`);
+            if (data.errors) {
+                console.error("Manifest errors:");
+                for (const err of data.errors) {
+                    console.error(`  - ${err.message} (at ${err.pointer})`);
+                }
+            }
+            return null;
+        }
+        return {
+            appId: data.app_id,
+            clientId: data.credentials.client_id,
+            clientSecret: data.credentials.client_secret,
+            signingSecret: data.credentials.signing_secret,
+        };
+    }
+    catch (err) {
+        console.error(`\nNetwork error: ${err instanceof Error ? err.message : "Unknown error"}`);
+        return null;
+    }
+}
+/**
+ * Interactive setup flow for creating a new Slack app.
+ */
+async function setupSlack() {
+    console.log("\n=== Ralph Slack Setup ===\n");
+    console.log("This wizard will create a new Slack app for your Ralph instance.");
+    console.log("Each Ralph instance needs its own Slack app to avoid message routing issues.\n");
+    // Check if config exists
+    const ralphDir = getRalphDir();
+    const configPath = join(ralphDir, "config.json");
+    if (!existsSync(configPath)) {
+        console.error("Error: .ralph/config.json not found. Run 'ralph init' first.");
+        process.exit(1);
+    }
+    // Step 1: Get configuration token
+    console.log("Step 1: Configuration Token\n");
+    console.log("You need a Slack configuration token to create apps programmatically.");
+    console.log("This token is tied to your Slack account (not per-app) - you can reuse it.");
+    console.log("\nGet one at: https://api.slack.com/apps");
+    console.log("  → Scroll down to 'Your App Configuration Tokens'");
+    console.log("  → Click 'Generate Token' and select your workspace");
+    console.log("  → Copy the 'Access Token' (not the Refresh Token)\n");
+    const configToken = await promptInput("Paste your configuration token (xoxe-...): ");
+    if (!configToken.startsWith("xoxe")) {
+        console.error("\nInvalid token format. Configuration tokens start with 'xoxe'.");
+        console.error("Note: This is different from bot tokens (xoxb-) or app tokens (xapp-).");
+        process.exit(1);
+    }
+    // Step 2: Choose app name
+    console.log("\nStep 2: App Name\n");
+    // Try to derive a name from the project directory
+    const projectDir = process.cwd().split("/").pop() || "ralph";
+    const suggestedName = `Ralph - ${projectDir}`;
+    let appName = await promptInput(`App name [${suggestedName}]: `);
+    if (!appName) {
+        appName = suggestedName;
+    }
+    // Validate app name (max 35 chars, must be unique)
+    if (appName.length > 35) {
+        appName = appName.substring(0, 35);
+        console.log(`  (Truncated to: ${appName})`);
+    }
+    // Step 3: Create the app
+    console.log("\nStep 3: Creating Slack App...\n");
+    const appResult = await createSlackApp(configToken, appName);
+    if (!appResult) {
+        console.error("\nFailed to create Slack app. Please check your token and try again.");
+        process.exit(1);
+    }
+    console.log(`✓ Created Slack app: ${appName}`);
+    console.log(`  App ID: ${appResult.appId}`);
+    // Step 4: Install the app
+    console.log("\nStep 4: Install the App to Your Workspace\n");
+    console.log("Open this URL in your browser to install the app:");
+    console.log(`\n  https://api.slack.com/apps/${appResult.appId}/install-on-team\n`);
+    console.log("Click 'Install to Workspace' and authorize the app.");
+    await promptInput("Press Enter after you've installed the app...");
+    // Step 5: Get the Bot Token
+    console.log("\nStep 5: Bot Token (xoxb-...)\n");
+    console.log("After installation, get your Bot Token from:");
+    console.log(`  https://api.slack.com/apps/${appResult.appId}/oauth`);
+    console.log("\nLook for 'Bot User OAuth Token' (starts with xoxb-).\n");
+    const botToken = await promptInput("Paste your Bot Token (xoxb-...): ");
+    if (!botToken.startsWith("xoxb-")) {
+        console.error("\nInvalid token format. Bot tokens start with 'xoxb-'.");
+        process.exit(1);
+    }
+    // Step 6: Generate App-Level Token for Socket Mode
+    console.log("\nStep 6: App-Level Token for Socket Mode\n");
+    console.log("Socket Mode requires an app-level token. Generate one at:");
+    console.log(`  https://api.slack.com/apps/${appResult.appId}/general`);
+    console.log("\nScroll to 'App-Level Tokens' and click 'Generate Token and Scopes'.");
+    console.log("  → Name it something like 'socket-mode'");
+    console.log("  → Add the scope: connections:write");
+    console.log("  → Click 'Generate'\n");
+    const appToken = await promptInput("Paste your App Token (xapp-...): ");
+    if (!appToken.startsWith("xapp-")) {
+        console.error("\nInvalid token format. App tokens start with 'xapp-'.");
+        process.exit(1);
+    }
+    // Step 7: Get Channel ID (optional)
+    console.log("\nStep 7: Channel Configuration (Optional)\n");
+    console.log("For security, you can restrict Ralph to specific channels.");
+    console.log("To get a channel ID: right-click the channel → 'View channel details' → scroll down.\n");
+    const channelId = await promptInput("Channel ID to restrict to (leave empty for all): ");
+    // Step 8: Save configuration
+    console.log("\nStep 8: Saving Configuration...\n");
+    const config = loadConfig();
+    const updatedConfig = {
+        ...config,
+        chat: {
+            ...config.chat,
+            enabled: true,
+            provider: "slack",
+            slack: {
+                enabled: true,
+                botToken,
+                appToken,
+                signingSecret: appResult.signingSecret,
+                allowedChannelIds: channelId ? [channelId] : undefined,
+            },
+        },
+    };
+    writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
+    console.log("✓ Configuration saved to .ralph/config.json\n");
+    // Step 9: Test connection
+    const shouldTest = await promptConfirm("Test the connection now?");
+    if (shouldTest && channelId) {
+        console.log("\nTesting connection...\n");
+        try {
+            // Dynamic import to avoid issues if @slack/web-api isn't installed
+            const dynamicImport = new Function("specifier", "return import(specifier)");
+            const { WebClient } = await dynamicImport("@slack/web-api");
+            const client = new WebClient(botToken);
+            // Test auth
+            const authResult = await client.auth.test();
+            console.log(`✓ Authenticated as @${authResult.user}`);
+            // Send test message
+            await client.chat.postMessage({
+                channel: channelId,
+                text: "👋 Ralph is now connected! Use `/ralph help` to see available commands.",
+            });
+            console.log(`✓ Test message sent to channel ${channelId}`);
+        }
+        catch (err) {
+            console.error(`\nConnection test failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+            console.log("You can test later with: ralph chat test <channel_id>");
+        }
+    }
+    // Done!
+    console.log("\n=== Setup Complete ===\n");
+    console.log("Your Ralph instance now has its own Slack app!");
+    console.log("\nNext steps:");
+    console.log("  1. Start the chat daemon: ralph chat start");
+    console.log("  2. Invite the bot to your channel: /invite @" + appName);
+    console.log("  3. Try a command: /ralph status");
+    console.log("\nImportant: Each Ralph project should have its own Slack app.");
+    console.log("Run 'ralph slack setup' in each project directory.\n");
+}
+/**
+ * Show current Slack configuration status.
+ */
+function showStatus() {
+    console.log("\n=== Slack Configuration Status ===\n");
+    try {
+        const config = loadConfig();
+        const slack = config.chat?.slack;
+        if (!slack) {
+            console.log("Status: Not configured");
+            console.log("\nRun 'ralph slack setup' to configure Slack integration.\n");
+            return;
+        }
+        console.log(`Provider: ${config.chat?.provider || "not set"}`);
+        console.log(`Enabled: ${slack.enabled !== false ? "Yes" : "No"}`);
+        console.log(`Bot Token: ${slack.botToken ? maskToken(slack.botToken) : "not set"}`);
+        console.log(`App Token: ${slack.appToken ? maskToken(slack.appToken) : "not set"}`);
+        console.log(`Signing Secret: ${slack.signingSecret ? "••••••••" : "not set"}`);
+        console.log(`Allowed Channels: ${slack.allowedChannelIds?.join(", ") || "all"}`);
+        console.log();
+    }
+    catch (err) {
+        console.error("Error loading config:", err instanceof Error ? err.message : "Unknown error");
+        process.exit(1);
+    }
+}
+/**
+ * Mask a token for display, showing only prefix and last 4 chars.
+ */
+function maskToken(token) {
+    if (token.length <= 10)
+        return "••••••••";
+    const prefix = token.substring(0, token.indexOf("-") + 1);
+    const suffix = token.substring(token.length - 4);
+    return `${prefix}••••${suffix}`;
+}
+/**
+ * Main command handler.
+ */
+export async function slack(args) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help") {
+        console.log(HELP_TEXT);
+        return;
+    }
+    switch (subcommand) {
+        case "setup":
+            await setupSlack();
+            break;
+        case "status":
+            showStatus();
+            break;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            console.error("Run 'ralph slack help' for usage information.");
+            process.exit(1);
+    }
+}