@4onstudios/iris-agent 0.1.0

package/dist/api/acp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./irisClient.js";
+export * from "./acpServer.js";

package/dist/api/acp/index.js

@@ -0,0 +1,2 @@
+export * from "./irisClient.js";
+export * from "./acpServer.js";

package/dist/api/acp/irisClient.d.ts

@@ -0,0 +1,58 @@
+import { type ChildProcessByStdio } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+export type IrisClientOptions = {
+    clientName?: string;
+    clientVersion?: string;
+    onSessionUpdate?: (notification: acp.SessionNotification) => void;
+    /**
+     * Called when the agent asks the client to approve or reject a tool call
+     * (e.g. a shell command) via `session/request_permission`. Return the
+     * outcome describing the user's decision. If omitted, IrisClient
+     * responds with `cancelled`, which the agent treats as a rejection.
+     */
+    onRequestPermission?: (params: acp.RequestPermissionRequest) => Promise<acp.RequestPermissionOutcome> | acp.RequestPermissionOutcome;
+};
+export type SpawnIrisClientOptions = IrisClientOptions & {
+    command?: string;
+    args?: string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+};
+export type IrisClientTransport = acp.Stream | acp.AgentApp;
+export type OpenSessionOptions = {
+    modelId?: string;
+    chatSessionId?: string;
+    mcpServers?: acp.McpServer[];
+    additionalDirectories?: string[];
+    meta?: Record<string, unknown>;
+};
+export type PromptOptions = {
+    modelId?: string;
+    maxSteps?: number;
+    meta?: Record<string, unknown>;
+};
+export declare class IrisClient {
+    private readonly connection;
+    private readonly context;
+    private closeTransport?;
+    private activeSession?;
+    private openingSession?;
+    private closed;
+    private constructor();
+    static connect(transport: IrisClientTransport, options?: IrisClientOptions): Promise<IrisClient>;
+    static spawn(options: SpawnIrisClientOptions): Promise<SpawnedIrisClient>;
+    openSession(cwd: string, options?: OpenSessionOptions): Promise<string>;
+    setModel(modelId: string): Promise<void>;
+    prompt(prompt: string | acp.ContentBlock[], options?: PromptOptions): Promise<acp.PromptResponse>;
+    cancel(): Promise<void>;
+    closeSession(): Promise<void>;
+    close(): Promise<void>;
+    private assertOpen;
+    private ownTransport;
+}
+export type SpawnedIrisClient = {
+    client: IrisClient;
+    process: ChildProcessByStdio<Writable, Readable, null>;
+};
+export declare function spawnIrisClient(options: SpawnIrisClientOptions): Promise<SpawnedIrisClient>;

package/dist/api/acp/irisClient.js

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+export class IrisClient {
+    connection;
+    context;
+    closeTransport;
+    activeSession;
+    openingSession;
+    closed = false;
+    constructor(connection, context) {
+        this.connection = connection;
+        this.context = context;
+    }
+    static async connect(transport, options = {}) {
+        const app = acp
+            .client({ name: options.clientName ?? "iris-client" })
+            .onNotification(acp.methods.client.session.update, (ctx) => {
+            options.onSessionUpdate?.(ctx.params);
+        })
+            .onRequest(acp.methods.client.session.requestPermission, async (ctx) => {
+            const outcome = options.onRequestPermission
+                ? await options.onRequestPermission(ctx.params)
+                : { outcome: "cancelled" };
+            return { outcome };
+        });
+        const connection = transport instanceof acp.AgentApp
+            ? app.connect(transport)
+            : app.connect(transport);
+        const context = connection.agent;
+        try {
+            await context.request(acp.methods.agent.initialize, {
+                protocolVersion: acp.PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: {
+                    name: options.clientName ?? "iris-client",
+                    version: options.clientVersion ?? "0.1.0",
+                },
+            });
+        }
+        catch (error) {
+            connection.close(error);
+            throw error;
+        }
+        return new IrisClient(connection, context);
+    }
+    static async spawn(options) {
+        const child = spawn(options.command ?? "iris-agent", options.args ?? ["--workspace", options.cwd, "--acp"], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ["pipe", "pipe", "inherit"],
+        });
+        const output = Writable.toWeb(child.stdin);
+        const input = Readable.toWeb(child.stdout);
+        let rejectProcessError = () => undefined;
+        const processError = new Promise((_, reject) => {
+            rejectProcessError = reject;
+        });
+        const onProcessError = (error) => rejectProcessError(error);
+        child.once("error", onProcessError);
+        try {
+            const client = await Promise.race([
+                IrisClient.connect(acp.ndJsonStream(output, input), options),
+                processError,
+            ]);
+            child.off("error", onProcessError);
+            client.ownTransport(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill();
+            });
+            return { client, process: child };
+        }
+        catch (error) {
+            child.off("error", onProcessError);
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill();
+            throw error;
+        }
+    }
+    async openSession(cwd, options) {
+        this.assertOpen();
+        if (this.activeSession) {
+            throw new Error("An ACP session is already open");
+        }
+        if (this.openingSession) {
+            throw new Error("An ACP session is already opening");
+        }
+        const openingSession = (async () => {
+            let builder = this.context.buildSession(cwd);
+            if (options?.additionalDirectories) {
+                builder = builder.withAdditionalDirectories(options.additionalDirectories);
+            }
+            if (options?.mcpServers) {
+                for (const server of options.mcpServers) {
+                    builder = builder.withMcpServer(server);
+                }
+            }
+            if (options?.modelId || options?.chatSessionId || options?.meta) {
+                const req = builder.request;
+                req._meta = {
+                    ...(options?.meta ?? {}),
+                    iris: {
+                        ...(typeof options?.meta?.iris === "object"
+                            ? options.meta.iris
+                            : {}),
+                        ...(options?.modelId ? { modelId: options.modelId } : {}),
+                        ...(options?.chatSessionId
+                            ? { chatSessionId: options.chatSessionId }
+                            : {}),
+                    },
+                    ...(options?.modelId ? { modelId: options.modelId } : {}),
+                };
+            }
+            const session = await builder.start();
+            this.activeSession = session;
+            return session.sessionId;
+        })();
+        this.openingSession = openingSession;
+        try {
+            return await openingSession;
+        }
+        finally {
+            if (this.openingSession === openingSession) {
+                this.openingSession = undefined;
+            }
+        }
+    }
+    async setModel(modelId) {
+        this.assertOpen();
+        if (!this.activeSession) {
+            throw new Error("Open an ACP session before setting configuration options");
+        }
+        await this.context.request(acp.methods.agent.session.setConfigOption, {
+            sessionId: this.activeSession.sessionId,
+            configId: "model",
+            value: modelId,
+        });
+    }
+    async prompt(prompt, options) {
+        this.assertOpen();
+        if (!this.activeSession) {
+            throw new Error("Open an ACP session before prompting");
+        }
+        if (options?.modelId || options?.maxSteps || options?.meta) {
+            const promptBlocks = typeof prompt === "string"
+                ? [{ type: "text", text: prompt }]
+                : Array.isArray(prompt)
+                    ? prompt
+                    : [prompt];
+            return this.context.request(acp.methods.agent.session.prompt, {
+                sessionId: this.activeSession.sessionId,
+                prompt: promptBlocks,
+                _meta: {
+                    ...(options?.meta ?? {}),
+                    iris: {
+                        ...(typeof options?.meta?.iris === "object"
+                            ? options.meta.iris
+                            : {}),
+                        ...(options?.modelId ? { modelId: options.modelId } : {}),
+                        ...(typeof options?.maxSteps === "number"
+                            ? { maxSteps: options.maxSteps }
+                            : {}),
+                    },
+                    ...(options?.modelId ? { modelId: options.modelId } : {}),
+                },
+            });
+        }
+        return this.activeSession.prompt(prompt);
+    }
+    async cancel() {
+        this.assertOpen();
+        if (!this.activeSession)
+            return;
+        await this.context.notify(acp.methods.agent.session.cancel, {
+            sessionId: this.activeSession.sessionId,
+        });
+    }
+    async closeSession() {
+        this.assertOpen();
+        if (!this.activeSession)
+            return;
+        const activeSession = this.activeSession;
+        const sessionId = activeSession.sessionId;
+        await this.context.request(acp.methods.agent.session.close, { sessionId });
+        activeSession.dispose();
+        if (this.activeSession === activeSession) {
+            this.activeSession = undefined;
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        try {
+            if (this.activeSession)
+                await this.closeSession();
+        }
+        finally {
+            this.closed = true;
+            this.connection.close();
+            this.closeTransport?.();
+            await this.connection.closed;
+        }
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error("ACP client is closed");
+    }
+    ownTransport(closeTransport) {
+        this.closeTransport = closeTransport;
+    }
+}
+export async function spawnIrisClient(options) {
+    return IrisClient.spawn(options);
+}

package/dist/api/agent.d.ts

@@ -0,0 +1,14 @@
+import express from "express";
+import type { Request, Response, NextFunction } from "express";
+declare const router: import("express-serve-static-core").Router;
+/**
+ * Reject with 403 unless ALL of:
+ *   1. The server was started as a Tauri desktop sidecar (TAURI_BUNDLED=1)
+ *   2. The request originates from the loopback interface
+ *   3. The X-Desktop-Token header matches the per-launch secret
+ *
+ * This gates the mutable /keys endpoint so arbitrary web pages or local
+ * processes cannot change API keys on behalf of the user.
+ */
+export declare function requireDesktopAuth(req: Request, res: Response, next: NextFunction): express.Response<any, Record<string, any>>;
+export default router;