onkol 0.1.0

package/dist/cli/systemd.js

@@ -0,0 +1,22 @@
+export function generateSystemdUnit(nodeName, user, onkolDir) {
+    return `[Unit]
+Description=Onkol Node: ${nodeName}
+After=network.target
+
+[Service]
+Type=forking
+User=${user}
+ExecStart=${onkolDir}/scripts/start-orchestrator.sh
+ExecStop=/usr/bin/tmux kill-session -t onkol-${nodeName}
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+export function generateCrontab(onkolDir) {
+    return `*/5 * * * * ${onkolDir}/scripts/healthcheck.sh
+0 4 * * * find ${onkolDir}/workers/.archive -maxdepth 1 -mtime +30 -exec rm -rf {} \\;
+`;
+}

package/dist/cli/templates.d.ts

@@ -0,0 +1,7 @@
+export declare function renderOrchestratorClaude(data: {
+    nodeName: string;
+    maxWorkers: number;
+}): string;
+export declare function renderSettings(data: {
+    bashLogPath: string;
+}): string;

package/dist/cli/templates.js

@@ -0,0 +1,17 @@
+import Handlebars from 'handlebars';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = resolve(__dirname, '../../templates');
+function loadTemplate(name) {
+    const content = readFileSync(resolve(TEMPLATES_DIR, name), 'utf-8');
+    return Handlebars.compile(content);
+}
+Handlebars.registerHelper('eq', (a, b) => a === b);
+export function renderOrchestratorClaude(data) {
+    return loadTemplate('orchestrator-claude.md.hbs')(data);
+}
+export function renderSettings(data) {
+    return loadTemplate('settings.json.hbs')(data);
+}

package/dist/plugin/discord-client.d.ts

@@ -0,0 +1,13 @@
+import { Client, type Message } from 'discord.js';
+export interface DiscordClientConfig {
+    botToken: string;
+    channelId: string;
+    allowedUsers: string[];
+}
+export declare function shouldForwardMessage(messageChannelId: string, authorId: string, isBot: boolean, targetChannelId: string, allowedUsers: string[]): boolean;
+export declare function createDiscordClient(config: DiscordClientConfig, onMessage: (message: Message) => void): {
+    login: () => Promise<string>;
+    client: Client<boolean>;
+    sendMessage(channelId: string, text: string): Promise<void>;
+    sendMessageWithFile(channelId: string, text: string, filePath: string): Promise<void>;
+};

package/dist/plugin/discord-client.js

@@ -0,0 +1,43 @@
+import { Client, GatewayIntentBits } from 'discord.js';
+export function shouldForwardMessage(messageChannelId, authorId, isBot, targetChannelId, allowedUsers) {
+    if (isBot)
+        return false;
+    if (messageChannelId !== targetChannelId)
+        return false;
+    if (allowedUsers.length > 0 && !allowedUsers.includes(authorId))
+        return false;
+    return true;
+}
+export function createDiscordClient(config, onMessage) {
+    const client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+        ],
+    });
+    client.on('messageCreate', (message) => {
+        if (shouldForwardMessage(message.channel.id, message.author.id, message.author.bot, config.channelId, config.allowedUsers)) {
+            onMessage(message);
+        }
+    });
+    client.on('ready', () => {
+        console.error(`[discord-filtered] Connected as ${client.user?.tag}, filtering to channel ${config.channelId}`);
+    });
+    return {
+        login: () => client.login(config.botToken),
+        client,
+        async sendMessage(channelId, text) {
+            const channel = await client.channels.fetch(channelId);
+            if (channel?.isTextBased() && 'send' in channel) {
+                await channel.send(text);
+            }
+        },
+        async sendMessageWithFile(channelId, text, filePath) {
+            const channel = await client.channels.fetch(channelId);
+            if (channel?.isTextBased() && 'send' in channel) {
+                await channel.send({ content: text, files: [{ attachment: filePath }] });
+            }
+        },
+    };
+}

package/dist/plugin/index.d.ts

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

package/dist/plugin/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createMcpServer } from './mcp-server.js';
+import { createDiscordClient } from './discord-client.js';
+import { MessageBatcher } from './message-batcher.js';
+const BOT_TOKEN = process.env.DISCORD_BOT_TOKEN;
+const CHANNEL_ID = process.env.DISCORD_CHANNEL_ID;
+const ALLOWED_USERS = JSON.parse(process.env.DISCORD_ALLOWED_USERS || '[]');
+if (!BOT_TOKEN) {
+    console.error('[discord-filtered] DISCORD_BOT_TOKEN is required');
+    process.exit(1);
+}
+if (!CHANNEL_ID) {
+    console.error('[discord-filtered] DISCORD_CHANNEL_ID is required');
+    process.exit(1);
+}
+const discord = createDiscordClient({ botToken: BOT_TOKEN, channelId: CHANNEL_ID, allowedUsers: ALLOWED_USERS }, async (message) => {
+    await mcpServer.notification({
+        method: 'notifications/claude/channel',
+        params: {
+            content: message.content,
+            meta: {
+                channel_id: message.channel.id,
+                sender: message.author.username,
+                sender_id: message.author.id,
+                message_id: message.id,
+            },
+        },
+    });
+});
+const batcher = new MessageBatcher(async (text) => {
+    await discord.sendMessage(CHANNEL_ID, text);
+});
+const mcpServer = createMcpServer({
+    async reply(_channelId, text) {
+        batcher.enqueue(text);
+    },
+    async replyWithFile(_channelId, text, filePath) {
+        await discord.sendMessageWithFile(CHANNEL_ID, text, filePath);
+    },
+});
+async function main() {
+    await mcpServer.connect(new StdioServerTransport());
+    await discord.login();
+    console.error(`[discord-filtered] Ready. Listening to channel ${CHANNEL_ID}`);
+}
+main().catch((err) => {
+    console.error('[discord-filtered] Fatal error:', err);
+    process.exit(1);
+});

package/dist/plugin/mcp-server.d.ts

@@ -0,0 +1,39 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export interface McpToolHandlers {
+    reply: (channelId: string, text: string) => Promise<void>;
+    replyWithFile: (channelId: string, text: string, filePath: string) => Promise<void>;
+}
+export declare function createMcpServer(handlers?: McpToolHandlers): Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>;

package/dist/plugin/mcp-server.js

@@ -0,0 +1,60 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+export function createMcpServer(handlers) {
+    const server = new Server({ name: 'discord-filtered', version: '0.1.0' }, {
+        capabilities: {
+            experimental: { 'claude/channel': {} },
+            tools: {},
+        },
+        instructions: 'Messages arrive as <channel source="discord-filtered">. Reply using the reply tool. Use reply_with_file to attach files.',
+    });
+    const channelId = process.env.DISCORD_CHANNEL_ID || '';
+    const tools = [
+        {
+            name: 'reply',
+            description: 'Send a text message back to the Discord channel',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    text: { type: 'string', description: 'The message text to send' },
+                },
+                required: ['text'],
+            },
+        },
+        {
+            name: 'reply_with_file',
+            description: 'Send a text message with a file attachment to the Discord channel',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    text: { type: 'string', description: 'The message text to send' },
+                    file_path: { type: 'string', description: 'Absolute path to the file to attach' },
+                },
+                required: ['text', 'file_path'],
+            },
+        },
+    ];
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const { name, arguments: args } = req.params;
+        if (name === 'reply' && handlers) {
+            await handlers.reply(channelId, args.text);
+            return { content: [{ type: 'text', text: 'sent' }] };
+        }
+        if (name === 'reply_with_file' && handlers) {
+            await handlers.replyWithFile(channelId, args.text, args.file_path);
+            return { content: [{ type: 'text', text: 'sent' }] };
+        }
+        return { content: [{ type: 'text', text: `unknown tool: ${name}` }] };
+    });
+    server.listTools = async () => {
+        const handler = server._requestHandlers.get('tools/list');
+        if (!handler)
+            return [];
+        const result = await handler({ method: 'tools/list', params: {} }, {});
+        return result?.tools || [];
+    };
+    return server;
+}

package/dist/plugin/message-batcher.d.ts

@@ -0,0 +1,9 @@
+export declare class MessageBatcher {
+    private buffer;
+    private timer;
+    private sendFn;
+    private delayMs;
+    constructor(sendFn: (text: string) => Promise<void>, delayMs?: number);
+    enqueue(text: string): void;
+    private flush;
+}

package/dist/plugin/message-batcher.js

@@ -0,0 +1,29 @@
+const DISCORD_MAX_LENGTH = 2000;
+const TRUNCATION_SUFFIX = '\n... (truncated)';
+export class MessageBatcher {
+    buffer = [];
+    timer = null;
+    sendFn;
+    delayMs;
+    constructor(sendFn, delayMs = 3000) {
+        this.sendFn = sendFn;
+        this.delayMs = delayMs;
+    }
+    enqueue(text) {
+        this.buffer.push(text);
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.flush(), this.delayMs);
+    }
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        let combined = this.buffer.join('\n');
+        this.buffer = [];
+        this.timer = null;
+        if (combined.length > DISCORD_MAX_LENGTH) {
+            combined = combined.slice(0, DISCORD_MAX_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
+        }
+        await this.sendFn(combined);
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "onkol",
+  "version": "0.1.0",
+  "description": "Decentralized on-call agent system powered by Claude Code",
+  "type": "module",
+  "bin": {
+    "onkol": "dist/cli/index.js"
+  },
+  "files": [
+    "dist/",
+    "scripts/",
+    "templates/",
+    "src/plugin/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "dev:plugin": "bun run src/plugin/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "discord.js": "^14.0.0",
+    "handlebars": "^4.7.0",
+    "inquirer": "^12.0.0",
+    "chalk": "^5.0.0",
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "bun-types": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/check-worker.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --name) WORKER_NAME="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+: "${WORKER_NAME:?--name is required}"
+
+ONKOL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+STATUS_FILE="$ONKOL_DIR/workers/$WORKER_NAME/status.json"
+
+if [ ! -f "$STATUS_FILE" ]; then
+  echo "Worker '$WORKER_NAME' not found or has no status file."
+  exit 1
+fi
+
+jq '.' "$STATUS_FILE"

package/scripts/dissolve-worker.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+set -euo pipefail
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --name) WORKER_NAME="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+: "${WORKER_NAME:?--name is required}"
+
+ONKOL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$ONKOL_DIR/config.json"
+BOT_TOKEN=$(jq -r '.botToken' "$CONFIG")
+NODE_NAME=$(jq -r '.nodeName' "$CONFIG")
+TMUX_SESSION="onkol-${NODE_NAME}"
+WORKER_DIR="$ONKOL_DIR/workers/$WORKER_NAME"
+TRACKING="$ONKOL_DIR/workers/tracking.json"
+
+# Get channel ID from tracking
+CHANNEL_ID=$(jq -r ".[] | select(.name == \"$WORKER_NAME\") | .channelId" "$TRACKING")
+
+# Check learnings file
+if [ ! -s "$WORKER_DIR/learnings.md" ]; then
+  echo "WARNING: No learnings found at $WORKER_DIR/learnings.md"
+  echo "Worker should write learnings before dissolution."
+fi
+
+# Copy learnings to knowledge base
+DATE=$(date +%Y-%m-%d)
+KNOWLEDGE_DIR="$ONKOL_DIR/knowledge"
+mkdir -p "$KNOWLEDGE_DIR"
+
+if [ -s "$WORKER_DIR/learnings.md" ]; then
+  cp "$WORKER_DIR/learnings.md" "$KNOWLEDGE_DIR/${DATE}-${WORKER_NAME}.md"
+
+  # Update index.json
+  INDEX="$KNOWLEDGE_DIR/index.json"
+  if [ ! -f "$INDEX" ]; then
+    echo '[]' > "$INDEX"
+  fi
+  TASK_DESC=$(jq -r ".[] | select(.name == \"$WORKER_NAME\") | .intent" "$TRACKING" 2>/dev/null || echo "unknown")
+  WORK_DIR=$(jq -r ".[] | select(.name == \"$WORKER_NAME\") | .workDir" "$TRACKING" 2>/dev/null || echo "unknown")
+  UPDATED_INDEX=$(jq ". + [{
+    \"file\": \"${DATE}-${WORKER_NAME}.md\",
+    \"date\": \"$DATE\",
+    \"tags\": [],
+    \"project\": \"$WORK_DIR\",
+    \"summary\": \"Learnings from worker $WORKER_NAME ($TASK_DESC)\"
+  }]" "$INDEX")
+  echo "$UPDATED_INDEX" > "$INDEX"
+  echo "Learnings saved to $KNOWLEDGE_DIR/${DATE}-${WORKER_NAME}.md"
+fi
+
+# Kill tmux window (if exists)
+tmux kill-window -t "${TMUX_SESSION}:${WORKER_NAME}" 2>/dev/null || true
+
+# Delete Discord channel (if exists)
+if [ -n "$CHANNEL_ID" ] && [ "$CHANNEL_ID" != "null" ]; then
+  curl -s -X DELETE \
+    "https://discord.com/api/v10/channels/${CHANNEL_ID}" \
+    -H "Authorization: Bot ${BOT_TOKEN}" > /dev/null 2>&1 || true
+  echo "Discord channel deleted."
+fi
+
+# Archive worker directory
+ARCHIVE_DIR="$ONKOL_DIR/workers/.archive/${DATE}-${WORKER_NAME}"
+mkdir -p "$ONKOL_DIR/workers/.archive"
+mv "$WORKER_DIR" "$ARCHIVE_DIR"
+echo "Worker directory archived to $ARCHIVE_DIR"
+
+# Remove from tracking
+UPDATED=$(jq "[.[] | select(.name != \"$WORKER_NAME\")]" "$TRACKING")
+echo "$UPDATED" > "$TRACKING"
+
+echo "Worker '$WORKER_NAME' dissolved."

package/scripts/healthcheck.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Cron-based health check. Compares tracking.json against tmux windows.
+# If a worker is tracked but its tmux window is gone, sends alert to Discord.
+
+ONKOL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$ONKOL_DIR/config.json"
+TRACKING="$ONKOL_DIR/workers/tracking.json"
+
+if [ ! -f "$TRACKING" ] || [ "$(jq length "$TRACKING")" -eq 0 ]; then
+  exit 0
+fi
+
+BOT_TOKEN=$(jq -r '.botToken' "$CONFIG")
+ORCHESTRATOR_CHANNEL=$(jq -r '.orchestratorChannelId' "$CONFIG")
+NODE_NAME=$(jq -r '.nodeName' "$CONFIG")
+TMUX_SESSION="onkol-${NODE_NAME}"
+
+WINDOWS=$(tmux list-windows -t "$TMUX_SESSION" -F '#{window_name}' 2>/dev/null || echo "")
+
+jq -r '.[] | select(.status == "active") | .name' "$TRACKING" | while read -r WORKER; do
+  if ! echo "$WINDOWS" | grep -q "^${WORKER}$"; then
+    # Worker is tracked but tmux window is gone
+    curl -s -X POST \
+      "https://discord.com/api/v10/channels/${ORCHESTRATOR_CHANNEL}/messages" \
+      -H "Authorization: Bot ${BOT_TOKEN}" \
+      -H "Content-Type: application/json" \
+      -d "{\"content\": \"[healthcheck] Worker **${WORKER}** appears to have crashed. Its tmux window is gone but it's still tracked. Please check and decide: respawn or dissolve.\"}" \
+      > /dev/null 2>&1
+  fi
+done

package/scripts/list-workers.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+ONKOL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+TRACKING="$ONKOL_DIR/workers/tracking.json"
+
+if [ ! -f "$TRACKING" ] || [ "$(jq length "$TRACKING")" -eq 0 ]; then
+  echo "No active workers."
+  exit 0
+fi
+
+echo "Active workers:"
+jq -r '.[] | "  [\(.status)] \(.name) — intent: \(.intent), dir: \(.workDir), started: \(.started)"' "$TRACKING"