onkol 0.1.0

package/dist/cli/auto-discover.d.ts

@@ -0,0 +1,11 @@
+export interface DiscoveredService {
+    name: string;
+    type: 'docker' | 'pm2' | 'systemd' | 'process';
+    port?: string;
+    image?: string;
+    status?: string;
+}
+export declare function parseDockerPs(output: string): DiscoveredService[];
+export declare function parseSsOutput(output: string): DiscoveredService[];
+export declare function discoverServices(): DiscoveredService[];
+export declare function formatServicesMarkdown(services: DiscoveredService[]): string;

package/dist/cli/auto-discover.js

@@ -0,0 +1,60 @@
+import { execSync } from 'child_process';
+export function parseDockerPs(output) {
+    const lines = output.trim().split('\n').slice(1);
+    return lines
+        .filter((line) => line.trim().length > 0)
+        .map((line) => {
+        const parts = line.split(/\s{2,}/);
+        const name = parts[parts.length - 1]?.trim();
+        const image = parts[1]?.trim();
+        const portsField = parts.find((p) => p.includes('->')) || '';
+        const portMatch = portsField.match(/:(\d+)->/);
+        return { name, type: 'docker', port: portMatch?.[1], image };
+    })
+        .filter((s) => s.name);
+}
+export function parseSsOutput(output) {
+    const lines = output.trim().split('\n').slice(1);
+    return lines
+        .filter((line) => line.includes('LISTEN'))
+        .map((line) => {
+        const portMatch = line.match(/\*:(\d+)/);
+        const processMatch = line.match(/\("([^"]+)"/);
+        return {
+            name: processMatch?.[1] || 'unknown',
+            type: 'process',
+            port: portMatch?.[1],
+        };
+    })
+        .filter((s) => s.port);
+}
+export function discoverServices() {
+    const services = [];
+    try {
+        const dockerOutput = execSync('docker ps --format "table {{.ID}}\\t{{.Image}}\\t{{.Ports}}\\t{{.Names}}"', { encoding: 'utf-8', timeout: 5000 });
+        services.push(...parseDockerPs(dockerOutput));
+    }
+    catch { /* docker not available */ }
+    try {
+        const ssOutput = execSync('ss -tlnp 2>/dev/null', { encoding: 'utf-8', timeout: 5000 });
+        const processServices = parseSsOutput(ssOutput);
+        const dockerPorts = new Set(services.map((s) => s.port));
+        services.push(...processServices.filter((s) => !dockerPorts.has(s.port)));
+    }
+    catch { /* ss not available */ }
+    return services;
+}
+export function formatServicesMarkdown(services) {
+    if (services.length === 0)
+        return 'No services discovered.\n';
+    let md = '## Discovered Services\n\n';
+    for (const s of services) {
+        md += `- **${s.name}** (${s.type})`;
+        if (s.port)
+            md += ` on port ${s.port}`;
+        if (s.image)
+            md += ` — image: ${s.image}`;
+        md += '\n';
+    }
+    return md;
+}

package/dist/cli/discord-api.d.ts

@@ -0,0 +1,19 @@
+export declare function buildCreateCategoryPayload(name: string): {
+    name: string;
+    type: number;
+};
+export declare function buildCreateChannelPayload(name: string, parentId: string): {
+    name: string;
+    type: number;
+    parent_id: string;
+};
+export declare function createCategory(token: string, guildId: string, name: string): Promise<{
+    id: string;
+    name: string;
+}>;
+export declare function createChannel(token: string, guildId: string, name: string, parentId: string): Promise<{
+    id: string;
+    name: string;
+}>;
+export declare function deleteChannel(token: string, channelId: string): Promise<void>;
+export declare function sendMessage(token: string, channelId: string, content: string): Promise<void>;

package/dist/cli/discord-api.js

@@ -0,0 +1,53 @@
+const DISCORD_API = 'https://discord.com/api/v10';
+function sanitizeChannelName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+}
+export function buildCreateCategoryPayload(name) {
+    return { name, type: 4 };
+}
+export function buildCreateChannelPayload(name, parentId) {
+    return { name: sanitizeChannelName(name), type: 0, parent_id: parentId };
+}
+export async function createCategory(token, guildId, name) {
+    const res = await fetch(`${DISCORD_API}/guilds/${guildId}/channels`, {
+        method: 'POST',
+        headers: { Authorization: `Bot ${token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(buildCreateCategoryPayload(name)),
+    });
+    if (!res.ok)
+        throw new Error(`Failed to create category: ${res.status} ${await res.text()}`);
+    return res.json();
+}
+export async function createChannel(token, guildId, name, parentId) {
+    const res = await fetch(`${DISCORD_API}/guilds/${guildId}/channels`, {
+        method: 'POST',
+        headers: { Authorization: `Bot ${token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(buildCreateChannelPayload(name, parentId)),
+    });
+    if (!res.ok)
+        throw new Error(`Failed to create channel: ${res.status} ${await res.text()}`);
+    return res.json();
+}
+export async function deleteChannel(token, channelId) {
+    const res = await fetch(`${DISCORD_API}/channels/${channelId}`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bot ${token}` },
+    });
+    if (!res.ok && res.status !== 404) {
+        throw new Error(`Failed to delete channel: ${res.status} ${await res.text()}`);
+    }
+}
+export async function sendMessage(token, channelId, content) {
+    const res = await fetch(`${DISCORD_API}/channels/${channelId}/messages`, {
+        method: 'POST',
+        headers: { Authorization: `Bot ${token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ content }),
+    });
+    if (!res.ok)
+        throw new Error(`Failed to send message: ${res.status} ${await res.text()}`);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+import { program } from 'commander';
+import chalk from 'chalk';
+import { mkdirSync, writeFileSync, readFileSync, copyFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+import { runSetupPrompts } from './prompts.js';
+import { createCategory, createChannel } from './discord-api.js';
+import { discoverServices, formatServicesMarkdown } from './auto-discover.js';
+import { renderOrchestratorClaude, renderSettings } from './templates.js';
+import { generateSystemdUnit, generateCrontab } from './systemd.js';
+program
+    .name('onkol')
+    .description('Decentralized on-call agent system')
+    .version('0.1.0');
+program
+    .command('setup')
+    .description('Set up an Onkol node on this VM')
+    .action(async () => {
+    console.log(chalk.bold('\nWelcome to Onkol Setup\n'));
+    const homeDir = process.env.HOME || '/root';
+    const answers = await runSetupPrompts(homeDir);
+    const dir = resolve(answers.installDir);
+    // Create directory structure
+    console.log(chalk.gray('Creating directories...'));
+    for (const sub of ['knowledge', 'workers', 'workers/.archive', 'scripts', 'plugins/discord-filtered', '.claude']) {
+        mkdirSync(resolve(dir, sub), { recursive: true });
+    }
+    // Build allowed users list from Discord user ID prompt
+    const user = process.env.USER || 'root';
+    const allowedUsers = [];
+    if (answers.discordUserId.trim()) {
+        allowedUsers.push(answers.discordUserId.trim());
+    }
+    // --- CRITICAL: Create Discord category and orchestrator channel ---
+    console.log(chalk.gray('Creating Discord category and channel...'));
+    let category;
+    let orchChannel;
+    try {
+        category = await createCategory(answers.botToken, answers.guildId, answers.nodeName);
+        orchChannel = await createChannel(answers.botToken, answers.guildId, 'orchestrator', category.id);
+    }
+    catch (err) {
+        console.error(chalk.red(`\nFATAL: Could not create Discord category/channel.`));
+        console.error(chalk.red(`${err instanceof Error ? err.message : err}`));
+        console.error(chalk.red('\nCheck that:'));
+        console.error(chalk.red('  1. Your bot token is correct'));
+        console.error(chalk.red('  2. Your server (guild) ID is correct'));
+        console.error(chalk.red('  3. The bot has been invited to the server with "Manage Channels" permission'));
+        process.exit(1);
+    }
+    console.log(chalk.green('✓ Discord category and #orchestrator channel created'));
+    // Write config.json
+    const config = {
+        nodeName: answers.nodeName,
+        botToken: answers.botToken,
+        guildId: answers.guildId,
+        categoryId: category.id,
+        orchestratorChannelId: orchChannel.id,
+        allowedUsers,
+        maxWorkers: 3,
+        installDir: dir,
+        plugins: answers.plugins,
+    };
+    writeFileSync(resolve(dir, 'config.json'), JSON.stringify(config, null, 2), { mode: 0o600 });
+    // Handle registry
+    if (answers.registryMode === 'import' && answers.registryPath) {
+        copyFileSync(answers.registryPath, resolve(dir, 'registry.json'));
+    }
+    else if (answers.registryMode !== 'prompt') {
+        writeFileSync(resolve(dir, 'registry.json'), '{}');
+    }
+    // Handle services
+    let servicesMd = '# Services\n\nNo services configured yet.\n';
+    if (answers.serviceMode === 'auto') {
+        console.log(chalk.gray('Discovering services...'));
+        const services = discoverServices();
+        servicesMd = formatServicesMarkdown(services);
+        console.log(chalk.green(`Found ${services.length} services.`));
+    }
+    else if (answers.serviceMode === 'import' && answers.serviceSummaryPath) {
+        servicesMd = readFileSync(answers.serviceSummaryPath, 'utf-8');
+    }
+    if (answers.serviceMode !== 'prompt') {
+        writeFileSync(resolve(dir, 'services.md'), servicesMd);
+    }
+    // Generate CLAUDE.md
+    const claudeMd = renderOrchestratorClaude({ nodeName: answers.nodeName, maxWorkers: 3 });
+    writeFileSync(resolve(dir, 'CLAUDE.md'), claudeMd);
+    // Generate .claude/settings.json
+    const settings = renderSettings({ bashLogPath: resolve(dir, 'bash-log.txt') });
+    writeFileSync(resolve(dir, '.claude/settings.json'), settings);
+    // Write orchestrator .mcp.json
+    const pluginPath = resolve(dir, 'plugins/discord-filtered/index.ts');
+    const mcpJson = {
+        mcpServers: {
+            'discord-filtered': {
+                command: 'bun',
+                args: [pluginPath],
+                env: {
+                    DISCORD_BOT_TOKEN: answers.botToken,
+                    DISCORD_CHANNEL_ID: orchChannel.id,
+                    DISCORD_ALLOWED_USERS: JSON.stringify(allowedUsers),
+                },
+            },
+        },
+    };
+    writeFileSync(resolve(dir, '.mcp.json'), JSON.stringify(mcpJson, null, 2));
+    // Initialize tracking and knowledge index
+    writeFileSync(resolve(dir, 'workers/tracking.json'), '[]');
+    writeFileSync(resolve(dir, 'knowledge/index.json'), '[]');
+    writeFileSync(resolve(dir, 'state.md'), '');
+    // Pre-accept Claude Code trust dialog for the onkol directory
+    console.log(chalk.gray('Configuring Claude Code trust...'));
+    const claudeJsonPath = resolve(homeDir, '.claude/.claude.json');
+    try {
+        const claudeJson = existsSync(claudeJsonPath) ? JSON.parse(readFileSync(claudeJsonPath, 'utf-8')) : {};
+        if (!claudeJson.projects)
+            claudeJson.projects = {};
+        claudeJson.projects[dir] = {
+            ...(claudeJson.projects[dir] || {}),
+            allowedTools: [],
+            hasTrustDialogAccepted: true,
+        };
+        writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
+        console.log(chalk.green('✓ Claude Code trust pre-accepted for ' + dir));
+    }
+    catch {
+        console.log(chalk.yellow('⚠ Could not pre-accept trust dialog. You may need to accept it manually on first run.'));
+    }
+    // Handle setup prompts
+    const pendingPrompts = [];
+    if (answers.registryPrompt) {
+        pendingPrompts.push({ target: 'registry.json', prompt: answers.registryPrompt, status: 'pending' });
+    }
+    if (answers.servicesPrompt) {
+        pendingPrompts.push({ target: 'services.md', prompt: answers.servicesPrompt, status: 'pending' });
+    }
+    if (answers.claudeMdPrompt) {
+        pendingPrompts.push({ target: 'CLAUDE.md', prompt: answers.claudeMdPrompt, status: 'pending' });
+    }
+    if (pendingPrompts.length > 0) {
+        writeFileSync(resolve(dir, 'setup-prompts.json'), JSON.stringify({ pending: pendingPrompts }, null, 2));
+    }
+    // --- CRITICAL: Copy scripts ---
+    const requiredScripts = ['spawn-worker.sh', 'dissolve-worker.sh', 'list-workers.sh', 'check-worker.sh', 'healthcheck.sh', 'start-orchestrator.sh'];
+    const scriptsSource = resolve(__dirname, '../../scripts');
+    console.log(chalk.gray('Copying scripts...'));
+    if (!existsSync(scriptsSource)) {
+        console.error(chalk.red(`\nFATAL: Scripts directory not found at ${scriptsSource}`));
+        console.error(chalk.red('The onkol package appears to be corrupted. Reinstall with: npm install -g onkol'));
+        process.exit(1);
+    }
+    for (const script of requiredScripts) {
+        const src = resolve(scriptsSource, script);
+        const dst = resolve(dir, 'scripts', script);
+        if (!existsSync(src)) {
+            console.error(chalk.red(`\nFATAL: Required script not found: ${src}`));
+            process.exit(1);
+        }
+        copyFileSync(src, dst);
+        execSync(`chmod +x "${dst}"`);
+    }
+    console.log(chalk.green(`✓ ${requiredScripts.length} scripts installed`));
+    // --- CRITICAL: Copy plugin source ---
+    // Look for .ts source files first (for bun), fall back to .js compiled files
+    const pluginFiles = ['index', 'mcp-server', 'discord-client', 'message-batcher'];
+    const pluginSourceDir = resolve(__dirname, '../plugin');
+    const projectSrcDir = resolve(__dirname, '../../src/plugin');
+    console.log(chalk.gray('Installing discord-filtered plugin...'));
+    let pluginCopied = 0;
+    for (const base of pluginFiles) {
+        const dst = resolve(dir, 'plugins/discord-filtered', `${base}.ts`);
+        // Try .ts from project src first, then .ts from dist, then .js from dist
+        const candidates = [
+            resolve(projectSrcDir, `${base}.ts`),
+            resolve(pluginSourceDir, `${base}.ts`),
+            resolve(pluginSourceDir, `${base}.js`),
+        ];
+        const found = candidates.find(c => existsSync(c));
+        if (found) {
+            copyFileSync(found, found.endsWith('.js') ? resolve(dir, 'plugins/discord-filtered', `${base}.js`) : dst);
+            pluginCopied++;
+        }
+    }
+    if (pluginCopied < pluginFiles.length) {
+        console.error(chalk.red(`\nFATAL: Only ${pluginCopied}/${pluginFiles.length} plugin files found.`));
+        console.error(chalk.red(`Searched in:\n  ${projectSrcDir}\n  ${pluginSourceDir}`));
+        console.error(chalk.red('The onkol package appears to be corrupted. Reinstall with: npm install -g onkol'));
+        process.exit(1);
+    }
+    // Create plugin package.json and install deps
+    const pluginPkgJson = {
+        name: 'discord-filtered',
+        version: '0.1.0',
+        private: true,
+        dependencies: {
+            '@modelcontextprotocol/sdk': '^1.0.0',
+            'discord.js': '^14.0.0',
+        },
+    };
+    writeFileSync(resolve(dir, 'plugins/discord-filtered/package.json'), JSON.stringify(pluginPkgJson, null, 2));
+    console.log(chalk.gray('Installing plugin dependencies (bun install)...'));
+    try {
+        execSync('bun install', { cwd: resolve(dir, 'plugins/discord-filtered'), stdio: 'pipe' });
+        console.log(chalk.green(`✓ Plugin installed with ${pluginCopied} files + dependencies`));
+    }
+    catch {
+        console.error(chalk.red('\nFATAL: Failed to install plugin dependencies.'));
+        console.error(chalk.red('Is bun installed? Install with: curl -fsSL https://bun.sh/install | bash'));
+        process.exit(1);
+    }
+    // Install systemd service
+    const systemdUnit = generateSystemdUnit(answers.nodeName, user, dir);
+    const unitPath = `/etc/systemd/system/onkol-${answers.nodeName}.service`;
+    console.log(chalk.gray('\nInstalling systemd service...'));
+    try {
+        writeFileSync(resolve(dir, `onkol-${answers.nodeName}.service`), systemdUnit);
+        execSync(`sudo cp "${resolve(dir, `onkol-${answers.nodeName}.service`)}" "${unitPath}"`, { stdio: 'pipe' });
+        execSync('sudo systemctl daemon-reload', { stdio: 'pipe' });
+        execSync(`sudo systemctl enable onkol-${answers.nodeName}`, { stdio: 'pipe' });
+        console.log(chalk.green(`✓ Systemd service installed and enabled`));
+    }
+    catch {
+        console.log(chalk.yellow(`⚠ Could not install systemd service automatically (need sudo).`));
+        console.log(chalk.yellow(`  To install manually:`));
+        console.log(chalk.gray(`  sudo tee ${unitPath} << 'EOF'\n${systemdUnit}EOF`));
+        console.log(chalk.gray(`  sudo systemctl daemon-reload`));
+        console.log(chalk.gray(`  sudo systemctl enable onkol-${answers.nodeName}`));
+    }
+    // Install health check timers — try cron first, then systemd user timers
+    console.log(chalk.gray('Installing health check timers...'));
+    let timersInstalled = false;
+    // Try crontab
+    try {
+        execSync('which crontab', { stdio: 'pipe' });
+        const cron = generateCrontab(dir);
+        const existingCron = (() => { try {
+            return execSync('crontab -l 2>/dev/null', { encoding: 'utf-8' });
+        }
+        catch {
+            return '';
+        } })();
+        if (!existingCron.includes(resolve(dir, 'scripts/healthcheck.sh'))) {
+            const newCron = existingCron.trimEnd() + '\n' + cron;
+            execSync(`echo ${JSON.stringify(newCron)} | crontab -`, { stdio: 'pipe' });
+        }
+        console.log(chalk.green(`✓ Cron jobs installed (healthcheck every 5min, archive cleanup daily)`));
+        timersInstalled = true;
+    }
+    catch { /* crontab not available */ }
+    // Fallback: systemd user timers (works on Arch, Fedora, etc. without cronie)
+    if (!timersInstalled) {
+        try {
+            const installTimersScript = resolve(dir, 'scripts/install-timers.sh');
+            if (existsSync(installTimersScript)) {
+                execSync(`bash "${installTimersScript}"`, { stdio: 'pipe' });
+            }
+            else {
+                // Create and run inline
+                const timerDir = resolve(homeDir, '.config/systemd/user');
+                mkdirSync(timerDir, { recursive: true });
+                const healthcheckPath = resolve(dir, 'scripts/healthcheck.sh');
+                writeFileSync(resolve(timerDir, 'onkol-healthcheck.service'), `[Unit]\nDescription=Onkol healthcheck\n[Service]\nType=oneshot\nExecStart=${healthcheckPath}\n`);
+                writeFileSync(resolve(timerDir, 'onkol-healthcheck.timer'), `[Unit]\nDescription=Onkol healthcheck every 5min\n[Timer]\nOnBootSec=2min\nOnUnitActiveSec=5min\n[Install]\nWantedBy=timers.target\n`);
+                writeFileSync(resolve(timerDir, 'onkol-cleanup.service'), `[Unit]\nDescription=Onkol archive cleanup\n[Service]\nType=oneshot\nExecStart=/usr/bin/find ${resolve(dir, 'workers/.archive')} -maxdepth 1 -mtime +30 -exec rm -rf {} \\;\n`);
+                writeFileSync(resolve(timerDir, 'onkol-cleanup.timer'), `[Unit]\nDescription=Onkol archive cleanup daily\n[Timer]\nOnCalendar=*-*-* 04:00:00\n[Install]\nWantedBy=timers.target\n`);
+                execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+                execSync('systemctl --user enable --now onkol-healthcheck.timer', { stdio: 'pipe' });
+                execSync('systemctl --user enable --now onkol-cleanup.timer', { stdio: 'pipe' });
+            }
+            console.log(chalk.green(`✓ Systemd user timers installed (healthcheck every 5min, cleanup daily)`));
+            timersInstalled = true;
+        }
+        catch { /* systemd timers failed too */ }
+    }
+    if (!timersInstalled) {
+        console.log(chalk.yellow(`⚠ Could not install health check timers (no crontab or systemd --user).`));
+        console.log(chalk.yellow(`  You'll need to set up periodic health checks manually.`));
+    }
+    // Report pending setup prompts
+    if (pendingPrompts.length > 0) {
+        console.log(chalk.cyan('\nPending setup prompts saved. On first boot, the orchestrator will:'));
+        for (const p of pendingPrompts) {
+            console.log(chalk.cyan(`  - Generate ${p.target} from your ${p.target === 'CLAUDE.md' ? 'description' : 'prompt'}`));
+        }
+    }
+    // Start orchestrator
+    console.log(chalk.gray('\nStarting orchestrator...'));
+    try {
+        execSync(`bash "${resolve(dir, 'scripts/start-orchestrator.sh')}"`, { stdio: 'pipe' });
+        console.log(chalk.green(`✓ Orchestrator started in tmux session "onkol-${answers.nodeName}"`));
+    }
+    catch (err) {
+        console.log(chalk.yellow(`⚠ Could not start orchestrator automatically.`));
+        console.log(chalk.yellow(`  Start manually: ${dir}/scripts/start-orchestrator.sh`));
+    }
+    // Done
+    console.log(chalk.green.bold(`\n✓ Onkol node "${answers.nodeName}" is live!`));
+    console.log(chalk.green(`✓ Discord category "${answers.nodeName}" created with #orchestrator channel`));
+    if (allowedUsers.length > 0) {
+        console.log(chalk.green(`✓ Allowed Discord users: ${allowedUsers.join(', ')}`));
+    }
+    else {
+        console.log(chalk.yellow(`⚠ No Discord user ID configured. Add user IDs to config.json allowedUsers array.`));
+    }
+    console.log(chalk.gray(`\n  To attach to the session: tmux attach -t onkol-${answers.nodeName}`));
+    console.log(chalk.gray(`  To check status: systemctl status onkol-${answers.nodeName}`));
+});
+program.parse();

package/dist/cli/prompts.d.ts

@@ -0,0 +1,17 @@
+export interface SetupAnswers {
+    installDir: string;
+    nodeName: string;
+    botToken: string;
+    guildId: string;
+    discordUserId: string;
+    registryPath: string | null;
+    registryMode: 'import' | 'prompt' | 'skip';
+    registryPrompt: string | null;
+    serviceMode: 'import' | 'auto' | 'prompt' | 'skip';
+    serviceSummaryPath: string | null;
+    servicesPrompt: string | null;
+    claudeMdMode: 'prompt' | 'skip';
+    claudeMdPrompt: string | null;
+    plugins: string[];
+}
+export declare function runSetupPrompts(homeDir: string): Promise<SetupAnswers>;

package/dist/cli/prompts.js

@@ -0,0 +1,178 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+function printDiscordBotGuide() {
+    const separator = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
+    console.log(`
+${separator}
+  ${chalk.bold('How to create a Discord bot for Onkol')}
+${separator}
+
+${chalk.bold('Step 1: Create a Discord Application')}
+  → Go to ${chalk.cyan('https://discord.com/developers/applications')}
+  → Click "New Application"
+  → Name it (e.g., "onkol-bot" or your node name)
+  → Click "Create"
+
+${chalk.bold('Step 2: Create the Bot & Get Token')}
+  → In your application, click "Bot" in the left sidebar
+  → Click "Reset Token"
+  → Copy the token — you'll need it in a moment
+  → ${chalk.yellow('IMPORTANT: You can only see the token once. Save it.')}
+
+${chalk.bold('Step 3: Enable Required Intents')}
+  → Still on the Bot page, scroll down to "Privileged Gateway Intents"
+  → Enable: "Message Content Intent"
+  → Click "Save Changes"
+
+${chalk.bold('Step 4: Invite the Bot to Your Server')}
+  → Click "OAuth2" in the left sidebar
+  → Click "URL Generator"
+  → Under "Scopes", check: bot
+  → Under "Bot Permissions", check:
+      ${chalk.gray('✓ View Channels')}
+      ${chalk.gray('✓ Send Messages')}
+      ${chalk.gray('✓ Send Messages in Threads')}
+      ${chalk.gray('✓ Read Message History')}
+      ${chalk.gray('✓ Attach Files')}
+      ${chalk.gray('✓ Add Reactions')}
+      ${chalk.gray('✓ Manage Channels  (needed to create/delete worker channels)')}
+  → Copy the generated URL at the bottom
+  → Open it in your browser
+  → Select your Discord server and click "Authorize"
+
+${chalk.bold('Step 5: Get Your Server (Guild) ID')}
+  → In Discord, go to Settings → Advanced → Enable "Developer Mode"
+  → Right-click your server name → "Copy Server ID"
+  → You'll need this in the next question
+
+${chalk.bold('Step 6: Get Your Discord User ID')}
+  → In Discord, right-click your username → "Copy User ID"
+  → You'll need this to whitelist yourself
+${separator}
+`);
+}
+export async function runSetupPrompts(homeDir) {
+    const preDiscordAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'installDir',
+            message: 'Where should Onkol live?',
+            default: `${homeDir}/onkol`,
+        },
+        {
+            type: 'input',
+            name: 'nodeName',
+            message: 'What should this node be called? (shows up on Discord)',
+        },
+        {
+            type: 'list',
+            name: 'botTokenHelp',
+            message: 'Do you have a Discord bot token ready?',
+            choices: [
+                { name: 'Yes, I have my token', value: 'ready' },
+                { name: 'No, show me how to create one', value: 'help' },
+            ],
+        },
+    ]);
+    if (preDiscordAnswers.botTokenHelp === 'help') {
+        printDiscordBotGuide();
+    }
+    const discordAndRestAnswers = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'botToken',
+            message: 'Discord bot token:',
+            mask: '*',
+        },
+        {
+            type: 'input',
+            name: 'guildId',
+            message: 'Discord server (guild) ID:',
+        },
+        {
+            type: 'input',
+            name: 'discordUserId',
+            message: 'Your Discord user ID (right-click your name > Copy User ID):',
+        },
+        {
+            type: 'list',
+            name: 'registryMode',
+            message: 'Do you have a registry file for this VM? (secrets, endpoints, ports)',
+            choices: [
+                { name: 'Yes, import from file', value: 'import' },
+                { name: 'Write a prompt — tell Claude what to find', value: 'prompt' },
+                { name: 'Skip for now', value: 'skip' },
+            ],
+        },
+        {
+            type: 'input',
+            name: 'registryPath',
+            message: 'Path to registry file:',
+            when: (a) => a.registryMode === 'import',
+        },
+        {
+            type: 'input',
+            name: 'registryPrompt',
+            message: 'Describe what Claude should find for the registry (secrets, endpoints, ports):',
+            when: (a) => a.registryMode === 'prompt',
+        },
+        {
+            type: 'list',
+            name: 'serviceMode',
+            message: 'Service summary for this VM?',
+            choices: [
+                { name: 'Auto-discover (scan for running services)', value: 'auto' },
+                { name: 'Import from file', value: 'import' },
+                { name: 'Write a prompt — tell Claude what to discover', value: 'prompt' },
+                { name: 'Skip for now', value: 'skip' },
+            ],
+        },
+        {
+            type: 'input',
+            name: 'serviceSummaryPath',
+            message: 'Path to service summary file:',
+            when: (a) => a.serviceMode === 'import',
+        },
+        {
+            type: 'input',
+            name: 'servicesPrompt',
+            message: 'Describe what Claude should discover about services on this VM:',
+            when: (a) => a.serviceMode === 'prompt',
+        },
+        {
+            type: 'list',
+            name: 'claudeMdMode',
+            message: 'Want to describe this project in plain language? Claude will convert it to a structured CLAUDE.md.',
+            choices: [
+                { name: 'Yes, write a description', value: 'prompt' },
+                { name: 'Skip (use default template)', value: 'skip' },
+            ],
+        },
+        {
+            type: 'input',
+            name: 'claudeMdPrompt',
+            message: 'Describe this project in plain language:',
+            when: (a) => a.claudeMdMode === 'prompt',
+        },
+        {
+            type: 'checkbox',
+            name: 'plugins',
+            message: 'Which Claude Code plugins should workers have?',
+            choices: [
+                { name: 'context7', value: 'context7', checked: true },
+                { name: 'superpowers', value: 'superpowers', checked: true },
+                { name: 'code-simplifier', value: 'code-simplifier', checked: true },
+                { name: 'frontend-design', value: 'frontend-design', checked: false },
+            ],
+        },
+    ]);
+    const answers = { ...preDiscordAnswers, ...discordAndRestAnswers };
+    return {
+        ...answers,
+        registryPath: answers.registryPath || null,
+        registryPrompt: answers.registryPrompt || null,
+        serviceSummaryPath: answers.serviceSummaryPath || null,
+        servicesPrompt: answers.servicesPrompt || null,
+        claudeMdPrompt: answers.claudeMdPrompt || null,
+    };
+}

package/dist/cli/systemd.d.ts

@@ -0,0 +1,2 @@
+export declare function generateSystemdUnit(nodeName: string, user: string, onkolDir: string): string;
+export declare function generateCrontab(onkolDir: string): string;