agent-kanban 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,78 @@
+import type { UsageInfo } from "./types.js";
+export declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    constructor();
+    private request;
+    createTask(input: Record<string, unknown>): Promise<unknown>;
+    listTasks(params?: Record<string, string>): Promise<unknown>;
+    getTask(id: string): Promise<unknown>;
+    claimTask(id: string, agentName?: string): Promise<unknown>;
+    completeTask(id: string, body: Record<string, unknown>): Promise<unknown>;
+    releaseTask(id: string): Promise<unknown>;
+    cancelTask(id: string, body?: Record<string, unknown>): Promise<unknown>;
+    reviewTask(id: string, body?: Record<string, unknown>): Promise<unknown>;
+    assignTask(id: string, agentId: string): Promise<unknown>;
+    addLog(taskId: string, detail: string, agentName?: string): Promise<unknown>;
+    registerMachine(info: {
+        name: string;
+        os: string;
+        version: string;
+        runtimes: string[];
+    }): Promise<{
+        id: string;
+        name: string;
+    }>;
+    heartbeat(machineId: string, info: {
+        version?: string;
+        runtimes?: string[];
+        usage_info?: UsageInfo | null;
+    }): Promise<unknown>;
+    registerAgent(agentId: string, publicKey?: string, runtime?: string, model?: string): Promise<unknown>;
+    listAgents(): Promise<unknown>;
+    createBoard(input: {
+        name: string;
+        description?: string;
+    }): Promise<unknown>;
+    listBoards(): Promise<any[]>;
+    getBoardByName(name: string): Promise<unknown>;
+    getBoard(boardId: string): Promise<unknown>;
+    createRepository(input: {
+        name: string;
+        url: string;
+    }): Promise<unknown>;
+    listRepositories(): Promise<any[]>;
+    updateAgentUsage(agentId: string, usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_tokens: number;
+        cache_creation_tokens: number;
+        cost_micro_usd: number;
+    }): Promise<unknown>;
+    sendMessage(taskId: string, body: {
+        agent_id: string;
+        role: string;
+        content: string;
+    }): Promise<unknown>;
+    getMessages(taskId: string, since?: string): Promise<any[]>;
+}
+export declare class AgentClient {
+    private baseUrl;
+    private agentId;
+    private privateKey;
+    constructor(baseUrl: string, agentId: string, privateKey: CryptoKey);
+    private request;
+    releaseTask(id: string): Promise<unknown>;
+    updateAgentUsage(usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_tokens: number;
+        cache_creation_tokens: number;
+        cost_micro_usd: number;
+    }): Promise<unknown>;
+    sendMessage(taskId: string, body: {
+        agent_id: string;
+        role: string;
+        content: string;
+    }): Promise<unknown>;
+}

package/dist/client.js

@@ -0,0 +1,143 @@
+import { SignJWT } from "jose";
+import { randomUUID } from "crypto";
+import { getConfigValue } from "./config.js";
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    constructor() {
+        const url = getConfigValue("api-url");
+        const key = getConfigValue("api-key");
+        if (!url)
+            throw new Error("API URL not configured. Run: agent-kanban config set api-url <url>");
+        if (!key)
+            throw new Error("API key not configured. Run: agent-kanban config set api-key <key>");
+        this.baseUrl = url.replace(/\/$/, "");
+        this.apiKey = key;
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const res = await fetch(url, {
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: body ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(10000),
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            const msg = data.error?.message || `HTTP ${res.status}`;
+            throw new Error(msg);
+        }
+        return data;
+    }
+    // Tasks
+    createTask(input) { return this.request("POST", "/api/tasks", input); }
+    listTasks(params) {
+        const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+        return this.request("GET", `/api/tasks${qs}`);
+    }
+    getTask(id) { return this.request("GET", `/api/tasks/${id}`); }
+    claimTask(id, agentName) {
+        return this.request("POST", `/api/tasks/${id}/claim`, agentName ? { agent_id: agentName } : {});
+    }
+    completeTask(id, body) {
+        return this.request("POST", `/api/tasks/${id}/complete`, body);
+    }
+    releaseTask(id) {
+        return this.request("POST", `/api/tasks/${id}/release`);
+    }
+    cancelTask(id, body = {}) {
+        return this.request("POST", `/api/tasks/${id}/cancel`, body);
+    }
+    reviewTask(id, body = {}) {
+        return this.request("POST", `/api/tasks/${id}/review`, body);
+    }
+    assignTask(id, agentId) {
+        return this.request("POST", `/api/tasks/${id}/assign`, { agent_id: agentId });
+    }
+    addLog(taskId, detail, agentName) {
+        return this.request("POST", `/api/tasks/${taskId}/logs`, { detail, agent_id: agentName });
+    }
+    // Machines
+    registerMachine(info) {
+        return this.request("POST", "/api/machines", info);
+    }
+    heartbeat(machineId, info) {
+        return this.request("POST", `/api/machines/${machineId}/heartbeat`, info);
+    }
+    // Agents
+    registerAgent(agentId, publicKey, runtime, model) {
+        return this.request("POST", "/api/agents", { agent_id: agentId, public_key: publicKey, runtime, model });
+    }
+    listAgents() { return this.request("GET", "/api/agents"); }
+    // Boards
+    createBoard(input) {
+        return this.request("POST", "/api/boards", input);
+    }
+    listBoards() { return this.request("GET", "/api/boards"); }
+    getBoardByName(name) { return this.request("GET", `/api/boards?name=${encodeURIComponent(name)}`); }
+    getBoard(boardId) { return this.request("GET", `/api/boards/${boardId}`); }
+    // Repositories
+    createRepository(input) {
+        return this.request("POST", "/api/repositories", input);
+    }
+    listRepositories() { return this.request("GET", "/api/repositories"); }
+    // Agent usage
+    updateAgentUsage(agentId, usage) {
+        return this.request("PATCH", `/api/agents/${agentId}/usage`, usage);
+    }
+    // Messages
+    sendMessage(taskId, body) {
+        return this.request("POST", `/api/tasks/${taskId}/messages`, body);
+    }
+    getMessages(taskId, since) {
+        const qs = since ? `?since=${encodeURIComponent(since)}` : "";
+        return this.request("GET", `/api/tasks/${taskId}/messages${qs}`);
+    }
+}
+export class AgentClient {
+    baseUrl;
+    agentId;
+    privateKey;
+    constructor(baseUrl, agentId, privateKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.agentId = agentId;
+        this.privateKey = privateKey;
+    }
+    async request(method, path, body) {
+        const jwt = await new SignJWT({ sub: this.agentId, jti: randomUUID(), aud: this.baseUrl })
+            .setProtectedHeader({ alg: "EdDSA", typ: "agent+jwt" })
+            .setIssuedAt()
+            .setExpirationTime("60s")
+            .sign(this.privateKey);
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwt}`,
+            },
+            body: body ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(10000),
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            const msg = data.error?.message || `HTTP ${res.status}`;
+            throw new Error(msg);
+        }
+        return data;
+    }
+    // Tasks
+    releaseTask(id) {
+        return this.request("POST", `/api/tasks/${id}/release`);
+    }
+    // Agent usage
+    updateAgentUsage(usage) {
+        return this.request("PATCH", `/api/agents/${this.agentId}/usage`, usage);
+    }
+    // Messages
+    sendMessage(taskId, body) {
+        return this.request("POST", `/api/tasks/${taskId}/messages`, body);
+    }
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerLinkCommand(program: Command): void;

package/dist/commands/link.js

@@ -0,0 +1,57 @@
+import { execSync } from "child_process";
+import { basename } from "path";
+import { ApiClient } from "../client.js";
+import { setLink } from "../links.js";
+function getGitRepoRoot() {
+    return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+}
+function getGitRemoteUrl() {
+    try {
+        return execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function registerLinkCommand(program) {
+    program
+        .command("link")
+        .description("Register current repo and map local directory to it")
+        .action(async () => {
+        let repoRoot;
+        try {
+            repoRoot = getGitRepoRoot();
+        }
+        catch {
+            console.error("Not a git repository. Run this command from a git repo.");
+            process.exit(1);
+        }
+        const remoteUrl = getGitRemoteUrl();
+        if (!remoteUrl) {
+            console.error("No git remote found. Add an origin remote first.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        let repo;
+        try {
+            repo = await client.createRepository({
+                name: basename(repoRoot),
+                url: remoteUrl,
+            });
+            console.log(`Registered repository: ${remoteUrl}`);
+        }
+        catch (err) {
+            if (err.message?.includes("UNIQUE")) {
+                // Already exists — find it
+                const repos = await client.listRepositories();
+                repo = repos.find((r) => r.url === remoteUrl);
+                console.log(`Repository already registered: ${remoteUrl}`);
+            }
+            else {
+                throw err;
+            }
+        }
+        setLink(repo.id, repoRoot);
+        console.log(`Linked repository ${repo.id} → ${repoRoot}`);
+    });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerStartCommand(program: Command): void;

package/dist/commands/start.js

@@ -0,0 +1,50 @@
+import { createInterface } from "readline";
+import { startDaemon } from "../daemon.js";
+import { setConfigValue, getConfigValue, deleteConfigValue } from "../config.js";
+function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+}
+export function registerStartCommand(program) {
+    program
+        .command("start")
+        .description("Start the Machine daemon — auto-claim and execute tasks")
+        .option("--api-url <url>", "API server URL")
+        .option("--api-key <key>", "Machine API key")
+        .option("--max-concurrent <n>", "Max concurrent agents", "3")
+        .option("--agent-cli <cmd>", "Agent CLI command to spawn", "claude")
+        .option("--poll-interval <ms>", "Poll interval in ms", "10000")
+        .option("--task-timeout <ms>", "Task timeout in ms (0 to disable)", "7200000")
+        .action(async (opts) => {
+        if (opts.apiUrl)
+            setConfigValue("api-url", opts.apiUrl);
+        if (opts.apiKey) {
+            const oldKey = getConfigValue("api-key");
+            if (oldKey && oldKey !== opts.apiKey && getConfigValue("machine-id")) {
+                const machineId = getConfigValue("machine-id");
+                const yes = await confirm(`This machine is already registered (${machineId}) with a different API key.\nSwitch to the new key and re-register? [y/N] `);
+                if (!yes) {
+                    console.log("Aborted.");
+                    process.exit(0);
+                }
+                deleteConfigValue("machine-id");
+            }
+            setConfigValue("api-key", opts.apiKey);
+        }
+        if (!getConfigValue("api-url") || !getConfigValue("api-key")) {
+            console.error("API URL and key required. Pass --api-url and --api-key, or set via: ak config set api-url <url>");
+            process.exit(1);
+        }
+        await startDaemon({
+            maxConcurrent: parseInt(opts.maxConcurrent, 10),
+            agentCli: opts.agentCli,
+            pollInterval: parseInt(opts.pollInterval, 10),
+            taskTimeout: parseInt(opts.taskTimeout, 10),
+        });
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+interface Config {
+    "api-url"?: string;
+    "api-key"?: string;
+    "machine-id"?: string;
+}
+export declare function readConfig(): Config;
+export declare function writeConfig(config: Config): void;
+export declare function getConfigValue(key: string): string | undefined;
+export declare function setConfigValue(key: string, value: string): void;
+export declare function deleteConfigValue(key: string): void;
+export declare const PID_FILE: string;
+export {};

package/dist/config.js

@@ -0,0 +1,31 @@
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_DIR = join(homedir(), ".agent-kanban");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function readConfig() {
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+export function getConfigValue(key) {
+    return readConfig()[key];
+}
+export function setConfigValue(key, value) {
+    const config = readConfig();
+    config[key] = value;
+    writeConfig(config);
+}
+export function deleteConfigValue(key) {
+    const config = readConfig();
+    delete config[key];
+    writeConfig(config);
+}
+export const PID_FILE = join(CONFIG_DIR, "daemon.pid");

package/dist/daemon.d.ts

@@ -0,0 +1,7 @@
+export interface DaemonOptions {
+    maxConcurrent: number;
+    agentCli: string;
+    pollInterval?: number;
+    taskTimeout?: number;
+}
+export declare function startDaemon(opts: DaemonOptions): Promise<void>;

package/dist/daemon.js

@@ -0,0 +1,205 @@
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from "fs";
+import { join } from "path";
+import { hostname, platform, arch, release } from "os";
+import { execSync } from "child_process";
+import { randomUUID } from "crypto";
+import { ApiClient, AgentClient } from "./client.js";
+import { ProcessManager } from "./processManager.js";
+import { getLinks, findPathForRepository } from "./links.js";
+import { getConfigValue, setConfigValue, PID_FILE } from "./config.js";
+import { getUsage } from "./usage.js";
+export async function startDaemon(opts) {
+    // PID lock
+    if (existsSync(PID_FILE)) {
+        const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+        try {
+            process.kill(pid, 0);
+            console.error(`Daemon already running (PID ${pid}). Stop it first or remove ${PID_FILE}`);
+            process.exit(1);
+        }
+        catch {
+            unlinkSync(PID_FILE);
+        }
+    }
+    writeFileSync(PID_FILE, String(process.pid));
+    const client = new ApiClient();
+    const links = getLinks();
+    const linkedRepoCount = Object.keys(links).length;
+    if (linkedRepoCount === 0) {
+        console.warn("[WARN] No linked repositories. Run `ak link` in your repo directories.");
+    }
+    else {
+        console.log(`[INFO] Linked repositories: ${linkedRepoCount}`);
+    }
+    const pm = new ProcessManager(client, opts.agentCli, () => {
+        schedulePoll(0);
+    }, opts.taskTimeout);
+    let running = true;
+    let pollTimer = null;
+    let backoffMs = opts.pollInterval || 10000;
+    const baseInterval = opts.pollInterval || 10000;
+    const shutdown = async () => {
+        if (!running)
+            return;
+        running = false;
+        console.log("\n[INFO] Shutting down daemon...");
+        clearInterval(heartbeatInterval);
+        if (pollTimer)
+            clearTimeout(pollTimer);
+        await pm.killAll();
+        removePidFile();
+        console.log("[INFO] Daemon stopped.");
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    console.log(`[INFO] Daemon started (PID ${process.pid}, max_concurrent=${opts.maxConcurrent}, agent=${opts.agentCli})`);
+    // Register machine (first run) or reuse existing
+    const machineInfo = getMachineInfo();
+    let machineId = getConfigValue("machine-id");
+    if (!machineId) {
+        const machine = await client.registerMachine(machineInfo);
+        machineId = machine.id;
+        setConfigValue("machine-id", machineId);
+        console.log(`[INFO] Machine registered: ${machineId}`);
+    }
+    await client.heartbeat(machineId, { version: machineInfo.version, runtimes: machineInfo.runtimes });
+    console.log(`[INFO] Machine online: ${machineInfo.name} (${machineInfo.os}, runtimes: ${machineInfo.runtimes.join(", ") || "none"})`);
+    const heartbeatInterval = setInterval(async () => {
+        const usageInfo = await getUsage();
+        client.heartbeat(machineId, { version: machineInfo.version, runtimes: machineInfo.runtimes, usage_info: usageInfo }).catch((err) => console.error(`[WARN] Heartbeat failed: ${err.message}`));
+    }, 30000);
+    function schedulePoll(delayMs) {
+        if (!running)
+            return;
+        if (pollTimer)
+            clearTimeout(pollTimer);
+        pollTimer = setTimeout(poll, delayMs);
+    }
+    async function poll() {
+        if (!running)
+            return;
+        try {
+            if (pm.activeCount >= opts.maxConcurrent) {
+                schedulePoll(baseInterval);
+                return;
+            }
+            const tasks = await client.listTasks({ status: "todo" });
+            const available = tasks.filter((t) => {
+                if (t.blocked || t.assigned_to)
+                    return false;
+                if (pm.hasTask(t.id))
+                    return false;
+                if (!t.repository_id)
+                    return false;
+                if (!findPathForRepository(t.repository_id)) {
+                    console.warn(`[WARN] Skipping task ${t.id}: no linked directory for repository ${t.repository_id}`);
+                    return false;
+                }
+                return true;
+            });
+            if (available.length === 0) {
+                backoffMs = baseInterval;
+                schedulePoll(baseInterval);
+                return;
+            }
+            const task = available[0];
+            const repoDir = findPathForRepository(task.repository_id);
+            const sessionId = randomUUID();
+            const { publicKey, privateKey } = await crypto.subtle.generateKey({ name: "Ed25519" }, true, ["sign", "verify"]);
+            const pubKeyJwk = await crypto.subtle.exportKey("jwk", publicKey);
+            const pubKeyBase64 = pubKeyJwk.x;
+            try {
+                await client.registerAgent(sessionId, pubKeyBase64, opts.agentCli);
+                await client.assignTask(task.id, sessionId);
+            }
+            catch (err) {
+                if (err.message.includes("409") || err.message.includes("assigned") || err.message.includes("blocked")) {
+                    schedulePoll(1000);
+                    return;
+                }
+                throw err;
+            }
+            console.log(`[INFO] Assigned task ${task.id}: ${task.title} → agent ${sessionId}`);
+            if (!ensureSkill(repoDir)) {
+                console.error(`[ERROR] Skill install failed for task ${task.id}, releasing task`);
+                await client.releaseTask(task.id).catch((err) => console.error(`[ERROR] Failed to release task ${task.id} after skill failure: ${err.message}`));
+                schedulePoll(baseInterval);
+                return;
+            }
+            const agentClient = new AgentClient(getConfigValue("api-url"), sessionId, privateKey);
+            const prompt = `You have a new task assigned to you. Task ID: ${task.id}\nFollow the agent-kanban skill workflow: claim the task, do the work, create a PR with gh, then submit for review with ak task review --pr-url <url>. Do NOT call task complete — only humans can complete tasks.`;
+            await pm.spawnAgent(task.id, sessionId, repoDir, prompt, agentClient);
+            backoffMs = baseInterval;
+            schedulePoll(1000);
+        }
+        catch (err) {
+            console.error(`[WARN] Poll error: ${err.message}`);
+            backoffMs = Math.min(backoffMs * 2, 60000);
+            schedulePoll(backoffMs);
+        }
+    }
+    schedulePoll(0);
+}
+const SKILL_SOURCE = "bonaysoft/agent-kanban";
+const SKILL_NAME = "agent-kanban";
+function ensureSkill(repoDir) {
+    const skillFile = join(repoDir, `.claude/skills/${SKILL_NAME}/SKILL.md`);
+    try {
+        if (!existsSync(skillFile)) {
+            console.log(`[INFO] Installing skill "${SKILL_NAME}" in ${repoDir}`);
+            execSync(`npx skills add ${SKILL_SOURCE} --skill ${SKILL_NAME} --agent claude-code --agent universal -y`, {
+                cwd: repoDir,
+                stdio: "pipe",
+            });
+        }
+        else {
+            const result = execSync("npx skills update", { cwd: repoDir, stdio: "pipe" }).toString();
+            if (result.includes("up to date"))
+                return true;
+            console.log(`[INFO] Skill "${SKILL_NAME}" updated in ${repoDir}`);
+        }
+        execSync(`git add .claude/skills/ && git diff --cached --quiet || git commit -m "chore: update ${SKILL_NAME} skill"`, {
+            cwd: repoDir,
+            stdio: "pipe",
+        });
+        return true;
+    }
+    catch (err) {
+        console.error(`[ERROR] Failed to ensure skill: ${err.message}`);
+        return false;
+    }
+}
+function removePidFile() {
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch { /* ignore */ }
+}
+function detectRuntimes() {
+    const commands = [
+        ["claude", "Claude Code"],
+        ["codex", "Codex"],
+        ["gemini", "Gemini CLI"],
+    ];
+    const found = [];
+    for (const [cmd, label] of commands) {
+        try {
+            execSync(`which ${cmd}`, { stdio: "ignore" });
+            found.push(label);
+        }
+        catch { /* not installed */ }
+    }
+    return found;
+}
+function getMachineInfo() {
+    const os = `${platform()} ${arch()} ${release()}`;
+    const runtimes = detectRuntimes();
+    let version = "unknown";
+    try {
+        const pkg = JSON.parse(readFileSync(join(import.meta.dirname, "../package.json"), "utf-8"));
+        version = pkg.version;
+    }
+    catch { /* ignore */ }
+    return { name: hostname(), os, version, runtimes };
+}

package/dist/index.d.ts

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