agiagent-dev 2026.1.30

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Peter Steinberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# AGIAgent
+
+AI assistant CLI.
+
+## Install
+
+```bash
+npm install -g agiagent
+```
+
+## Connect
+
+```bash
+agiagent connect --token <YOUR_TOKEN>
+```
+
+## License
+
+MIT

package/README.npm.md

@@ -0,0 +1,19 @@
+# AGIAgent
+
+AI assistant CLI.
+
+## Install
+
+```bash
+npm install -g agiagent
+```
+
+## Connect
+
+```bash
+agiagent connect --token <YOUR_TOKEN>
+```
+
+## License
+
+MIT

package/agiagent.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import module from "node:module";
+
+// https://nodejs.org/api/module.html#module-compile-cache
+if (module.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) {
+  try {
+    module.enableCompileCache();
+  } catch {
+    // Ignore errors
+  }
+}
+
+await import("./dist/entry.js");

package/dist/acp/client.d.ts

@@ -0,0 +1,16 @@
+import { ClientSideConnection } from "@agentclientprotocol/sdk";
+import { type ChildProcess } from "node:child_process";
+export type AcpClientOptions = {
+    cwd?: string;
+    serverCommand?: string;
+    serverArgs?: string[];
+    serverVerbose?: boolean;
+    verbose?: boolean;
+};
+export type AcpClientHandle = {
+    client: ClientSideConnection;
+    agent: ChildProcess;
+    sessionId: string;
+};
+export declare function createAcpClient(opts?: AcpClientOptions): Promise<AcpClientHandle>;
+export declare function runAcpClientInteractive(opts?: AcpClientOptions): Promise<void>;

package/dist/acp/client.js

@@ -0,0 +1,147 @@
+import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { spawn } from "node:child_process";
+import * as readline from "node:readline";
+import { Readable, Writable } from "node:stream";
+import { ensureAGIAgentCliOnPath } from "../infra/path-env.js";
+function toArgs(value) {
+    if (!value) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function buildServerArgs(opts) {
+    const args = ["acp", ...toArgs(opts.serverArgs)];
+    if (opts.serverVerbose && !args.includes("--verbose") && !args.includes("-v")) {
+        args.push("--verbose");
+    }
+    return args;
+}
+function printSessionUpdate(notification) {
+    const update = notification.update;
+    if (!("sessionUpdate" in update)) {
+        return;
+    }
+    switch (update.sessionUpdate) {
+        case "agent_message_chunk": {
+            if (update.content?.type === "text") {
+                process.stdout.write(update.content.text);
+            }
+            return;
+        }
+        case "tool_call": {
+            console.log(`\n[tool] ${update.title} (${update.status})`);
+            return;
+        }
+        case "tool_call_update": {
+            if (update.status) {
+                console.log(`[tool update] ${update.toolCallId}: ${update.status}`);
+            }
+            return;
+        }
+        case "available_commands_update": {
+            const names = update.availableCommands?.map((cmd) => `/${cmd.name}`).join(" ");
+            if (names) {
+                console.log(`\n[commands] ${names}`);
+            }
+            return;
+        }
+        default:
+            return;
+    }
+}
+export async function createAcpClient(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const verbose = Boolean(opts.verbose);
+    const log = verbose ? (msg) => console.error(`[acp-client] ${msg}`) : () => { };
+    ensureAGIAgentCliOnPath({ cwd });
+    const serverCommand = opts.serverCommand ?? "agiagent";
+    const serverArgs = buildServerArgs(opts);
+    log(`spawning: ${serverCommand} ${serverArgs.join(" ")}`);
+    const agent = spawn(serverCommand, serverArgs, {
+        stdio: ["pipe", "pipe", "inherit"],
+        cwd,
+    });
+    if (!agent.stdin || !agent.stdout) {
+        throw new Error("Failed to create ACP stdio pipes");
+    }
+    const input = Writable.toWeb(agent.stdin);
+    const output = Readable.toWeb(agent.stdout);
+    const stream = ndJsonStream(input, output);
+    const client = new ClientSideConnection(() => ({
+        sessionUpdate: async (params) => {
+            printSessionUpdate(params);
+        },
+        requestPermission: async (params) => {
+            console.log("\n[permission requested]", params.toolCall?.title ?? "tool");
+            const options = params.options ?? [];
+            const allowOnce = options.find((option) => option.kind === "allow_once");
+            const fallback = options[0];
+            return {
+                outcome: {
+                    outcome: "selected",
+                    optionId: allowOnce?.optionId ?? fallback?.optionId ?? "allow",
+                },
+            };
+        },
+    }), stream);
+    log("initializing");
+    await client.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {
+            fs: { readTextFile: true, writeTextFile: true },
+            terminal: true,
+        },
+        clientInfo: { name: "agiagent-acp-client", version: "1.0.0" },
+    });
+    log("creating session");
+    const session = await client.newSession({
+        cwd,
+        mcpServers: [],
+    });
+    return {
+        client,
+        agent,
+        sessionId: session.sessionId,
+    };
+}
+export async function runAcpClientInteractive(opts = {}) {
+    const { client, agent, sessionId } = await createAcpClient(opts);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log("AGIAgent ACP client");
+    console.log(`Session: ${sessionId}`);
+    console.log('Type a prompt, or "exit" to quit.\n');
+    const prompt = () => {
+        rl.question("> ", async (input) => {
+            const text = input.trim();
+            if (!text) {
+                prompt();
+                return;
+            }
+            if (text === "exit" || text === "quit") {
+                agent.kill();
+                rl.close();
+                process.exit(0);
+            }
+            try {
+                const response = await client.prompt({
+                    sessionId,
+                    prompt: [{ type: "text", text }],
+                });
+                console.log(`\n[${response.stopReason}]\n`);
+            }
+            catch (err) {
+                console.error(`\n[error] ${String(err)}\n`);
+            }
+            prompt();
+        });
+    };
+    prompt();
+    agent.on("exit", (code) => {
+        console.log(`\nAgent exited with code ${code ?? 0}`);
+        rl.close();
+        process.exit(code ?? 0);
+    });
+}

package/dist/acp/commands.d.ts

@@ -0,0 +1,2 @@
+import type { AvailableCommand } from "@agentclientprotocol/sdk";
+export declare function getAvailableCommands(): AvailableCommand[];

package/dist/acp/commands.js

@@ -0,0 +1,38 @@
+export function getAvailableCommands() {
+    return [
+        { name: "help", description: "Show help and common commands." },
+        { name: "commands", description: "List available commands." },
+        { name: "status", description: "Show current status." },
+        {
+            name: "context",
+            description: "Explain context usage (list|detail|json).",
+            input: { hint: "list | detail | json" },
+        },
+        { name: "whoami", description: "Show sender id (alias: /id)." },
+        { name: "id", description: "Alias for /whoami." },
+        { name: "subagents", description: "List or manage sub-agents." },
+        { name: "config", description: "Read or write config (owner-only)." },
+        { name: "debug", description: "Set runtime-only overrides (owner-only)." },
+        { name: "usage", description: "Toggle usage footer (off|tokens|full)." },
+        { name: "stop", description: "Stop the current run." },
+        { name: "restart", description: "Restart the gateway (if enabled)." },
+        { name: "dock-telegram", description: "Route replies to Telegram." },
+        { name: "dock-discord", description: "Route replies to Discord." },
+        { name: "dock-slack", description: "Route replies to Slack." },
+        { name: "activation", description: "Set group activation (mention|always)." },
+        { name: "send", description: "Set send mode (on|off|inherit)." },
+        { name: "reset", description: "Reset the session (/new)." },
+        { name: "new", description: "Reset the session (/reset)." },
+        {
+            name: "think",
+            description: "Set thinking level (off|minimal|low|medium|high|xhigh).",
+        },
+        { name: "verbose", description: "Set verbose mode (on|full|off)." },
+        { name: "reasoning", description: "Toggle reasoning output (on|off|stream)." },
+        { name: "elevated", description: "Toggle elevated mode (on|off)." },
+        { name: "model", description: "Select a model (list|status|<name>)." },
+        { name: "queue", description: "Adjust queue mode and options." },
+        { name: "bash", description: "Run a host command (if enabled)." },
+        { name: "compact", description: "Compact the session history." },
+    ];
+}

package/dist/acp/event-mapper.d.ts

@@ -0,0 +1,10 @@
+import type { ContentBlock, ToolKind } from "@agentclientprotocol/sdk";
+export type GatewayAttachment = {
+    type: string;
+    mimeType: string;
+    content: string;
+};
+export declare function extractTextFromPrompt(prompt: ContentBlock[]): string;
+export declare function extractAttachmentsFromPrompt(prompt: ContentBlock[]): GatewayAttachment[];
+export declare function formatToolTitle(name: string | undefined, args: Record<string, unknown> | undefined): string;
+export declare function inferToolKind(name?: string): ToolKind;

package/dist/acp/event-mapper.js

@@ -0,0 +1,81 @@
+export function extractTextFromPrompt(prompt) {
+    const parts = [];
+    for (const block of prompt) {
+        if (block.type === "text") {
+            parts.push(block.text);
+            continue;
+        }
+        if (block.type === "resource") {
+            const resource = block.resource;
+            if (resource?.text) {
+                parts.push(resource.text);
+            }
+            continue;
+        }
+        if (block.type === "resource_link") {
+            const title = block.title ? ` (${block.title})` : "";
+            const uri = block.uri ?? "";
+            const line = uri ? `[Resource link${title}] ${uri}` : `[Resource link${title}]`;
+            parts.push(line);
+        }
+    }
+    return parts.join("\n");
+}
+export function extractAttachmentsFromPrompt(prompt) {
+    const attachments = [];
+    for (const block of prompt) {
+        if (block.type !== "image") {
+            continue;
+        }
+        const image = block;
+        if (!image.data || !image.mimeType) {
+            continue;
+        }
+        attachments.push({
+            type: "image",
+            mimeType: image.mimeType,
+            content: image.data,
+        });
+    }
+    return attachments;
+}
+export function formatToolTitle(name, args) {
+    const base = name ?? "tool";
+    if (!args || Object.keys(args).length === 0) {
+        return base;
+    }
+    const parts = Object.entries(args).map(([key, value]) => {
+        const raw = typeof value === "string" ? value : JSON.stringify(value);
+        const safe = raw.length > 100 ? `${raw.slice(0, 100)}...` : raw;
+        return `${key}: ${safe}`;
+    });
+    return `${base}: ${parts.join(", ")}`;
+}
+export function inferToolKind(name) {
+    if (!name) {
+        return "other";
+    }
+    const normalized = name.toLowerCase();
+    if (normalized.includes("read")) {
+        return "read";
+    }
+    if (normalized.includes("write") || normalized.includes("edit")) {
+        return "edit";
+    }
+    if (normalized.includes("delete") || normalized.includes("remove")) {
+        return "delete";
+    }
+    if (normalized.includes("move") || normalized.includes("rename")) {
+        return "move";
+    }
+    if (normalized.includes("search") || normalized.includes("find")) {
+        return "search";
+    }
+    if (normalized.includes("exec") || normalized.includes("run") || normalized.includes("bash")) {
+        return "execute";
+    }
+    if (normalized.includes("fetch") || normalized.includes("http")) {
+        return "fetch";
+    }
+    return "other";
+}

package/dist/acp/index.d.ts

@@ -0,0 +1,4 @@
+export { serveAcpGateway } from "./server.js";
+export { createInMemorySessionStore } from "./session.js";
+export type { AcpSessionStore } from "./session.js";
+export type { AcpServerOptions } from "./types.js";

package/dist/acp/index.js

@@ -0,0 +1,2 @@
+export { serveAcpGateway } from "./server.js";
+export { createInMemorySessionStore } from "./session.js";

package/dist/acp/meta.d.ts

@@ -0,0 +1,3 @@
+export declare function readString(meta: Record<string, unknown> | null | undefined, keys: string[]): string | undefined;
+export declare function readBool(meta: Record<string, unknown> | null | undefined, keys: string[]): boolean | undefined;
+export declare function readNumber(meta: Record<string, unknown> | null | undefined, keys: string[]): number | undefined;

package/dist/acp/meta.js

@@ -0,0 +1,36 @@
+export function readString(meta, keys) {
+    if (!meta) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = meta[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+export function readBool(meta, keys) {
+    if (!meta) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = meta[key];
+        if (typeof value === "boolean") {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function readNumber(meta, keys) {
+    if (!meta) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = meta[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}

package/dist/acp/server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import type { AcpServerOptions } from "./types.js";
+export declare function serveAcpGateway(opts?: AcpServerOptions): void;

package/dist/acp/server.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import { Readable, Writable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "../config/config.js";
+import { resolveGatewayAuth } from "../gateway/auth.js";
+import { buildGatewayConnectionDetails } from "../gateway/call.js";
+import { GatewayClient } from "../gateway/client.js";
+import { isMainModule } from "../infra/is-main.js";
+import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
+import { AcpGatewayAgent } from "./translator.js";
+export function serveAcpGateway(opts = {}) {
+    const cfg = loadConfig();
+    const connection = buildGatewayConnectionDetails({
+        config: cfg,
+        url: opts.gatewayUrl,
+    });
+    const isRemoteMode = cfg.gateway?.mode === "remote";
+    const remote = isRemoteMode ? cfg.gateway?.remote : undefined;
+    const auth = resolveGatewayAuth({ authConfig: cfg.gateway?.auth, env: process.env });
+    const token = opts.gatewayToken ??
+        (isRemoteMode ? remote?.token?.trim() : undefined) ??
+        process.env.AGIAGENT_GATEWAY_TOKEN ??
+        auth.token;
+    const password = opts.gatewayPassword ??
+        (isRemoteMode ? remote?.password?.trim() : undefined) ??
+        process.env.AGIAGENT_GATEWAY_PASSWORD ??
+        auth.password;
+    let agent = null;
+    const gateway = new GatewayClient({
+        url: connection.url,
+        token: token || undefined,
+        password: password || undefined,
+        clientName: GATEWAY_CLIENT_NAMES.CLI,
+        clientDisplayName: "ACP",
+        clientVersion: "acp",
+        mode: GATEWAY_CLIENT_MODES.CLI,
+        onEvent: (evt) => {
+            void agent?.handleGatewayEvent(evt);
+        },
+        onHelloOk: () => {
+            agent?.handleGatewayReconnect();
+        },
+        onClose: (code, reason) => {
+            agent?.handleGatewayDisconnect(`${code}: ${reason}`);
+        },
+    });
+    const input = Writable.toWeb(process.stdout);
+    const output = Readable.toWeb(process.stdin);
+    const stream = ndJsonStream(input, output);
+    new AgentSideConnection((conn) => {
+        agent = new AcpGatewayAgent(conn, gateway, opts);
+        agent.start();
+        return agent;
+    }, stream);
+    gateway.start();
+}
+function parseArgs(args) {
+    const opts = {};
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--url" || arg === "--gateway-url") {
+            opts.gatewayUrl = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--token" || arg === "--gateway-token") {
+            opts.gatewayToken = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--password" || arg === "--gateway-password") {
+            opts.gatewayPassword = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--session") {
+            opts.defaultSessionKey = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--session-label") {
+            opts.defaultSessionLabel = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--require-existing") {
+            opts.requireExistingSession = true;
+            continue;
+        }
+        if (arg === "--reset-session") {
+            opts.resetSession = true;
+            continue;
+        }
+        if (arg === "--no-prefix-cwd") {
+            opts.prefixCwd = false;
+            continue;
+        }
+        if (arg === "--verbose" || arg === "-v") {
+            opts.verbose = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+    return opts;
+}
+function printHelp() {
+    console.log(`Usage: agiagent acp [options]
+
+Gateway-backed ACP server for IDE integration.
+
+Options:
+  --url <url>             Gateway WebSocket URL
+  --token <token>         Gateway auth token
+  --password <password>   Gateway auth password
+  --session <key>         Default session key (e.g. "agent:main:main")
+  --session-label <label> Default session label to resolve
+  --require-existing      Fail if the session key/label does not exist
+  --reset-session         Reset the session key before first use
+  --no-prefix-cwd         Do not prefix prompts with the working directory
+  --verbose, -v           Verbose logging to stderr
+  --help, -h              Show this help message
+`);
+}
+if (isMainModule({ currentFile: fileURLToPath(import.meta.url) })) {
+    const opts = parseArgs(process.argv.slice(2));
+    serveAcpGateway(opts);
+}

package/dist/acp/session-mapper.d.ts

@@ -0,0 +1,22 @@
+import type { GatewayClient } from "../gateway/client.js";
+import type { AcpServerOptions } from "./types.js";
+export type AcpSessionMeta = {
+    sessionKey?: string;
+    sessionLabel?: string;
+    resetSession?: boolean;
+    requireExisting?: boolean;
+    prefixCwd?: boolean;
+};
+export declare function parseSessionMeta(meta: unknown): AcpSessionMeta;
+export declare function resolveSessionKey(params: {
+    meta: AcpSessionMeta;
+    fallbackKey: string;
+    gateway: GatewayClient;
+    opts: AcpServerOptions;
+}): Promise<string>;
+export declare function resetSessionIfNeeded(params: {
+    meta: AcpSessionMeta;
+    sessionKey: string;
+    gateway: GatewayClient;
+    opts: AcpServerOptions;
+}): Promise<void>;

package/dist/acp/session-mapper.js

@@ -0,0 +1,69 @@
+import { readBool, readString } from "./meta.js";
+export function parseSessionMeta(meta) {
+    if (!meta || typeof meta !== "object") {
+        return {};
+    }
+    const record = meta;
+    return {
+        sessionKey: readString(record, ["sessionKey", "session", "key"]),
+        sessionLabel: readString(record, ["sessionLabel", "label"]),
+        resetSession: readBool(record, ["resetSession", "reset"]),
+        requireExisting: readBool(record, ["requireExistingSession", "requireExisting"]),
+        prefixCwd: readBool(record, ["prefixCwd"]),
+    };
+}
+export async function resolveSessionKey(params) {
+    const requestedLabel = params.meta.sessionLabel ?? params.opts.defaultSessionLabel;
+    const requestedKey = params.meta.sessionKey ?? params.opts.defaultSessionKey;
+    const requireExisting = params.meta.requireExisting ?? params.opts.requireExistingSession ?? false;
+    if (params.meta.sessionLabel) {
+        const resolved = await params.gateway.request("sessions.resolve", {
+            label: params.meta.sessionLabel,
+        });
+        if (!resolved?.key) {
+            throw new Error(`Unable to resolve session label: ${params.meta.sessionLabel}`);
+        }
+        return resolved.key;
+    }
+    if (params.meta.sessionKey) {
+        if (!requireExisting) {
+            return params.meta.sessionKey;
+        }
+        const resolved = await params.gateway.request("sessions.resolve", {
+            key: params.meta.sessionKey,
+        });
+        if (!resolved?.key) {
+            throw new Error(`Session key not found: ${params.meta.sessionKey}`);
+        }
+        return resolved.key;
+    }
+    if (requestedLabel) {
+        const resolved = await params.gateway.request("sessions.resolve", {
+            label: requestedLabel,
+        });
+        if (!resolved?.key) {
+            throw new Error(`Unable to resolve session label: ${requestedLabel}`);
+        }
+        return resolved.key;
+    }
+    if (requestedKey) {
+        if (!requireExisting) {
+            return requestedKey;
+        }
+        const resolved = await params.gateway.request("sessions.resolve", {
+            key: requestedKey,
+        });
+        if (!resolved?.key) {
+            throw new Error(`Session key not found: ${requestedKey}`);
+        }
+        return resolved.key;
+    }
+    return params.fallbackKey;
+}
+export async function resetSessionIfNeeded(params) {
+    const resetSession = params.meta.resetSession ?? params.opts.resetSession ?? false;
+    if (!resetSession) {
+        return;
+    }
+    await params.gateway.request("sessions.reset", { key: params.sessionKey });
+}

package/dist/acp/session.d.ts

@@ -0,0 +1,16 @@
+import type { AcpSession } from "./types.js";
+export type AcpSessionStore = {
+    createSession: (params: {
+        sessionKey: string;
+        cwd: string;
+        sessionId?: string;
+    }) => AcpSession;
+    getSession: (sessionId: string) => AcpSession | undefined;
+    getSessionByRunId: (runId: string) => AcpSession | undefined;
+    setActiveRun: (sessionId: string, runId: string, abortController: AbortController) => void;
+    clearActiveRun: (sessionId: string) => void;
+    cancelActiveRun: (sessionId: string) => boolean;
+    clearAllSessionsForTest: () => void;
+};
+export declare function createInMemorySessionStore(): AcpSessionStore;
+export declare const defaultAcpSessionStore: AcpSessionStore;