@netnodeag/kraftwerk 0.40.0 → 0.42.0

package/dist/inspector/channels.js

@@ -0,0 +1,130 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse, stringify } from "yaml";
+import { getProjectRoot } from "./context.js";
+import { resolveProject } from "../config.js";
+import { listAgents, safeAgentSlug, slugFromName } from "./agents.js";
+export const DEFAULT_MAX_HOPS = 3;
+const SLUG_RE = /^[a-z0-9][a-z0-9-]{0,48}$/;
+export async function channelsRoot() {
+    const project = await resolveProject(getProjectRoot());
+    return path.resolve(project.root, "channels");
+}
+export function safeChannelSlug(slug) {
+    if (!SLUG_RE.test(slug))
+        throw new Error(`invalid channel slug "${slug}"`);
+    return slug;
+}
+function normalize(slug, raw) {
+    const members = Array.isArray(raw.members) ? [...new Set(raw.members.map(String))] : [];
+    const responder = typeof raw.responder === "string" && members.includes(raw.responder) ? raw.responder : undefined;
+    const hops = typeof raw.maxHops === "number" && Number.isInteger(raw.maxHops) && raw.maxHops >= 0 ? raw.maxHops : DEFAULT_MAX_HOPS;
+    return {
+        slug,
+        name: String(raw.name ?? slug),
+        ...(raw.purpose ? { purpose: String(raw.purpose) } : {}),
+        members,
+        ...(responder ? { responder } : {}),
+        maxHops: hops,
+    };
+}
+export async function listChannels() {
+    const root = await channelsRoot();
+    let entries;
+    try {
+        entries = (await fs.readdir(root, { withFileTypes: true }))
+            .filter((e) => e.isDirectory() && SLUG_RE.test(e.name))
+            .map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+    const channels = await Promise.all(entries.map((slug) => getChannel(slug)));
+    return channels.filter(Boolean).sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function getChannel(slug) {
+    const file = path.join(await channelsRoot(), safeChannelSlug(slug), "channel.yml");
+    try {
+        const raw = parse(await fs.readFile(file, "utf8"));
+        return normalize(slug, (raw ?? {}));
+    }
+    catch {
+        return null;
+    }
+}
+/** Members must be existing, non-archived agents; returns them in the order given. */
+async function checkMembers(slugs) {
+    const agents = await listAgents();
+    return slugs.map((slug) => {
+        const a = agents.find((m) => m.slug === safeAgentSlug(slug));
+        if (!a)
+            throw new Error(`agent "${slug}" not found`);
+        if (a.archived)
+            throw new Error(`agent "${slug}" is archived`);
+        return a;
+    });
+}
+/** Create (no slug: derived from the name) or update a channel definition. */
+export async function saveChannel(input) {
+    const existing = input.slug ? await getChannel(safeChannelSlug(input.slug)) : null;
+    const name = (input.name ?? existing?.name ?? "").trim();
+    if (!name)
+        throw new Error("name is required");
+    const slug = input.slug ? safeChannelSlug(input.slug) : slugFromName(name);
+    if (!input.slug && (await getChannel(slug)))
+        throw new Error(`channel "${slug}" exists already`);
+    const members = input.members !== undefined ? [...new Set(input.members.map(String))] : existing?.members ?? [];
+    if (members.length === 0)
+        throw new Error("a channel needs at least one agent");
+    await checkMembers(members);
+    let responder = existing?.responder;
+    if (input.responder !== undefined)
+        responder = input.responder ? input.responder : undefined;
+    if (responder && !members.includes(responder))
+        responder = undefined;
+    const maxHops = input.maxHops !== undefined
+        ? Number.isInteger(input.maxHops) && input.maxHops >= 0
+            ? input.maxHops
+            : (() => {
+                throw new Error("maxHops must be a whole number");
+            })()
+        : existing?.maxHops ?? DEFAULT_MAX_HOPS;
+    const channel = {
+        slug,
+        name,
+        ...(input.purpose !== undefined
+            ? input.purpose.trim()
+                ? { purpose: input.purpose.trim() }
+                : {}
+            : existing?.purpose
+                ? { purpose: existing.purpose }
+                : {}),
+        members,
+        ...(responder ? { responder } : {}),
+        maxHops,
+    };
+    const dir = path.join(await channelsRoot(), slug);
+    await fs.mkdir(dir, { recursive: true });
+    const { slug: _s, ...body } = channel;
+    await fs.writeFile(path.join(dir, "channel.yml"), stringify(body));
+    return channel;
+}
+export async function deleteChannel(slug) {
+    await fs.rm(path.join(await channelsRoot(), safeChannelSlug(slug)), { recursive: true, force: true });
+}
+/**
+ * Who a channel message wakes. @mentions of members win (in text order, each
+ * once); a message that mentions nobody goes to the responder, or to nobody.
+ * `self` (the author, when an agent) never wakes itself.
+ */
+export function mentionTargets(text, channel, self) {
+    const out = [];
+    for (const m of text.matchAll(/(^|[^\w@])@([a-z0-9][a-z0-9-]*)/g)) {
+        const slug = m[2];
+        if (channel.members.includes(slug) && slug !== self && !out.includes(slug))
+            out.push(slug);
+    }
+    if (out.length === 0 && channel.responder && channel.responder !== self && !self)
+        return [channel.responder];
+    return out;
+}

package/dist/inspector/chat/acp.js

@@ -1,80 +1,18 @@
-import { spawn } from "node:child_process";
-import { Readable, Writable } from "node:stream";
-import { fileURLToPath } from "node:url";
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, RequestError, } from "@agentclientprotocol/sdk";
+import { RequestError } from "@agentclientprotocol/sdk";
+import { adapterEnv, connectAcp } from "../../acp.js";
 import { unattendedMode } from "./permissions.js";
 /**
  * ACP-backed chat: spawn an adapter (claude-agent-acp / codex-acp) as a
  * subprocess, speak Agent Client Protocol over its stdio, and translate
  * session/update notifications into chat events. One subprocess lives for
- * the whole chat; the ACP session id carries the conversation.
- *
- * Auth rides on the local CLI logins (Claude Code / Codex) via the
- * inherited environment — same story as the kraftwerk harnesses.
+ * the whole chat; the ACP session id carries the conversation. The
+ * adapter plumbing is shared with the workflow ACP harness (src/acp.ts).
  */
-const ADAPTERS = {
-    claude: "@agentclientprotocol/claude-agent-acp/dist/index.js",
-    codex: "@agentclientprotocol/codex-acp/dist/index.js",
-};
-/** Effort tier -> Claude thinking budget (the adapter reads MAX_THINKING_TOKENS). */
-const CLAUDE_THINKING_BUDGET = {
-    low: 2048,
-    medium: 8192,
-    high: 16384,
-    xhigh: 32000,
-    max: 63999,
-};
-/**
- * Model/effort overrides ride on adapter-specific channels: the claude
- * adapter takes the model via session `_meta.claudeCode.options` and the
- * thinking budget via env; codex-acp merges a CODEX_CONFIG env JSON into
- * the session config it hands to `codex app-server`.
- */
-function tuningEnv(agent, tuning) {
-    const env = { ...process.env };
-    if (agent === "claude" && tuning.effort && CLAUDE_THINKING_BUDGET[tuning.effort]) {
-        env.MAX_THINKING_TOKENS = String(CLAUDE_THINKING_BUDGET[tuning.effort]);
-    }
-    if (agent === "codex" && (tuning.model || tuning.effort)) {
-        env.CODEX_CONFIG = JSON.stringify({
-            ...(tuning.model ? { model: tuning.model } : {}),
-            ...(tuning.effort ? { model_reasoning_effort: tuning.effort } : {}),
-        });
-    }
-    return env;
-}
 function contentText(content) {
     return content.type === "text" ? content.text : "";
 }
 export async function startAcpBackend(agent, cwd, hooks, tuning = {}) {
-    const entry = fileURLToPath(import.meta.resolve(ADAPTERS[agent]));
-    const child = spawn(process.execPath, [entry], {
-        cwd,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: tuningEnv(agent, tuning),
-    });
-    let stderr = "";
-    child.stderr.on("data", (c) => {
-        stderr += c.toString("utf8");
-        if (stderr.length > 20_000)
-            stderr = stderr.slice(-20_000);
-    });
     let dead = false;
-    // Without a listener a failed spawn (cwd gone, node missing) is an
-    // unhandled 'error' event that takes the whole inspector down.
-    child.on("error", (err) => {
-        dead = true;
-        hooks.emit({ type: "error", message: `could not start the ${agent} agent: ${err.message}` });
-    });
-    child.on("close", (code) => {
-        dead = true;
-        if (code !== 0 && code !== null) {
-            hooks.emit({
-                type: "error",
-                message: `${agent} agent exited (code ${code})${stderr.trim() ? `: ${stderr.trim().slice(-500)}` : ""}`,
-            });
-        }
-    });
     const client = {
         sessionUpdate(params) {
             const u = params.update;
@@ -118,12 +56,24 @@ export async function startAcpBackend(agent, cwd, hooks, tuning = {}) {
                 : { outcome: { outcome: "cancelled" } };
         },
     };
-    const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
-    const conn = new ClientSideConnection(() => client, stream);
-    await conn.initialize({
-        protocolVersion: PROTOCOL_VERSION,
-        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
-        clientInfo: { name: "kraftwerk-inspector", version: "1.0.0" },
+    const { child, conn } = await connectAcp(agent, {
+        cwd,
+        env: adapterEnv(agent, tuning),
+        client,
+        clientName: "kraftwerk-inspector",
+        onError: (err) => {
+            dead = true;
+            hooks.emit({ type: "error", message: `could not start the ${agent} agent: ${err.message}` });
+        },
+        onClose: (code, stderr) => {
+            dead = true;
+            if (code !== 0 && code !== null) {
+                hooks.emit({
+                    type: "error",
+                    message: `${agent} agent exited (code ${code})${stderr ? `: ${stderr.slice(-500)}` : ""}`,
+                });
+            }
+        },
     });
     // Claude-only session options ride on _meta.claudeCode.options (the
     // adapter spreads them into the Agent SDK options): model override,

package/dist/inspector/chat/sessions.d.ts

@@ -1,4 +1,5 @@
 import type { ChatAgentId, ChatMeta, ChatScope, StoredChatEvent } from "./types.js";
+import { type Channel } from "../channels.js";
 /** Server shutdown: no agent subprocess may outlive the inspector. */
 export declare function disposeAllBackends(): void;
 /**
@@ -32,9 +33,24 @@ export declare function getChat(id: string): Promise<{
     events: StoredChatEvent[];
     busy: boolean;
 } | null>;
-export declare function postMessage(id: string, text: string): Promise<{
+export declare function postMessage(id: string, text: string, opts?: {
+    from?: string;
+}): Promise<{
     error?: string;
 }>;
+/** The chat that holds a channel's transcript; created on first use. */
+export declare function ensureChannelChat(channel: Channel): Promise<ChatMeta>;
+/**
+ * "Add a coworker" to an agent session: the chat becomes the channel's
+ * transcript. The agent keeps its process and memory — it has seen every
+ * message so far — and learns the channel rules with its next prompt.
+ */
+export declare function convertChatToChannel(chatId: string, channel: Channel): Promise<{
+    error?: string;
+    meta?: ChatMeta;
+}>;
+/** Members left the channel: their processes go, the transcript stays. */
+export declare function dropChannelSeats(chatId: string, keep: string[]): Promise<void>;
 /**
  * Open a vibeable in the chat (or close it with null). The agent's cwd
  * becomes the app folder, so the running subprocess is dropped and the next