@bogyie/opencode-kiro-plugin 0.1.0

package/dist/acp-transport.js

@@ -0,0 +1,358 @@
+import { createAcpStdioClient, } from "./acp-client.js";
+import { promptForCli } from "./cli-transport.js";
+import { KiroPluginError } from "./errors.js";
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+export function acpPermissionResponse(params, trustAllTools = false) {
+    const options = arrayValue(record(params)?.options).map(record).filter((item) => item !== undefined);
+    const preferredKinds = trustAllTools ? ["allow_always", "allow_once"] : ["reject_once", "reject_always"];
+    const selected = preferredKinds
+        .map((kind) => options.find((option) => option.kind === kind))
+        .find((option) => option !== undefined) ?? options[0];
+    const optionId = stringValue(selected?.optionId);
+    if (!optionId) {
+        throw new KiroPluginError("ACP permission request did not include selectable options.", "KIRO_ACP_PROTOCOL_ERROR", 502);
+    }
+    return {
+        outcome: {
+            outcome: "selected",
+            optionId,
+        },
+    };
+}
+function unsupportedAcpRequest(method) {
+    throw new KiroPluginError(`Unsupported ACP client request: ${method}`, "KIRO_ACP_UNSUPPORTED_REQUEST", 502);
+}
+function sessionIdFrom(result) {
+    const item = record(result);
+    const session = record(item?.session);
+    const id = stringValue(item?.sessionId) ?? stringValue(item?.id) ?? stringValue(session?.id);
+    if (!id) {
+        throw new KiroPluginError("ACP session/new response did not include a session id.", "KIRO_ACP_PROTOCOL_ERROR", 502);
+    }
+    return id;
+}
+function notificationUpdate(notification) {
+    if (notification.method !== "session/notification" && notification.method !== "session/update")
+        return undefined;
+    const params = record(notification.params);
+    return record(params?.update) ?? record(params?.notification) ?? params;
+}
+function updateType(update) {
+    const nested = record(update.update);
+    return (stringValue(update.type) ??
+        stringValue(update.sessionUpdate) ??
+        stringValue(nested?.type) ??
+        stringValue(nested?.sessionUpdate) ??
+        stringValue(update.kind) ??
+        stringValue(nested?.kind));
+}
+function textFromContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(textFromContent).filter(Boolean).join("");
+    const item = record(value);
+    if (!item)
+        return "";
+    return stringValue(item.text) ?? stringValue(item.content) ?? stringValue(item.delta) ?? "";
+}
+function textFromUpdate(update) {
+    const type = updateType(update);
+    if (type !== "AgentMessageChunk")
+        return "";
+    return (textFromContent(update.content) ||
+        textFromContent(update.text) ||
+        textFromContent(update.chunk) ||
+        textFromContent(record(update.delta)?.text));
+}
+function isTurnEnd(update) {
+    return updateType(update) === "TurnEnd";
+}
+function normalizeToolName(input) {
+    const name = input.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+    return name || "tool";
+}
+function jsonArguments(value) {
+    if (value === undefined)
+        return "{}";
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+function firstDefined(...values) {
+    return values.find((value) => value !== undefined);
+}
+function toolCallDetail(update) {
+    const detail = record(update.update) ?? update;
+    return (record(detail.toolCall) ??
+        record(detail.tool_call) ??
+        record(detail.call) ??
+        record(record(detail.delta)?.toolCall) ??
+        record(record(detail.delta)?.tool_call) ??
+        detail);
+}
+function toolCallFromUpdate(update, modelId) {
+    const type = updateType(update);
+    if (type !== "ToolCall" && type !== "ToolCallUpdate" && type !== "tool_call" && type !== "tool_call_update")
+        return undefined;
+    const detail = toolCallDetail(update);
+    const id = stringValue(detail.toolCallId) ??
+        stringValue(detail.tool_call_id) ??
+        stringValue(detail.id) ??
+        stringValue(detail.callId) ??
+        `acp-tool-${crypto.randomUUID()}`;
+    const explicitName = stringValue(detail.name) ??
+        stringValue(detail.toolName) ??
+        stringValue(detail.tool_name);
+    const rawArguments = firstDefined(detail.rawInput, detail.input, detail.parameters, detail.params, detail.args, detail.arguments);
+    if ((type === "ToolCallUpdate" || type === "tool_call_update") && rawArguments === undefined && !explicitName) {
+        return undefined;
+    }
+    const rawName = explicitName ?? (rawArguments !== undefined ? stringValue(detail.kind) ?? stringValue(detail.title) : undefined) ?? "tool";
+    return {
+        type: "tool_call",
+        id,
+        name: normalizeToolName(rawName),
+        arguments: jsonArguments(rawArguments),
+        modelId,
+    };
+}
+function acpPromptContent(request) {
+    const content = [{ type: "text", text: promptForCli(request) }];
+    for (const image of request.images) {
+        content.push({
+            type: "image",
+            mimeType: `image/${image.format === "jpeg" ? "jpeg" : image.format}`,
+            data: Buffer.from(image.bytes).toString("base64"),
+        });
+    }
+    for (const document of request.documents) {
+        const mimeType = documentMimeType(document.format);
+        const uri = `attachment://${encodeURIComponent(document.name)}`;
+        if (document.format === "txt" || document.format === "md" || document.format === "csv" || document.format === "html") {
+            content.push({
+                type: "resource",
+                resource: {
+                    uri,
+                    mimeType,
+                    text: Buffer.from(document.bytes).toString("utf8"),
+                },
+            });
+            continue;
+        }
+        content.push({
+            type: "resource",
+            resource: {
+                uri,
+                mimeType,
+                blob: Buffer.from(document.bytes).toString("base64"),
+            },
+        });
+    }
+    return content;
+}
+function documentMimeType(format) {
+    if (format === "pdf")
+        return "application/pdf";
+    if (format === "txt")
+        return "text/plain";
+    if (format === "md")
+        return "text/markdown";
+    if (format === "csv")
+        return "text/csv";
+    if (format === "html")
+        return "text/html";
+    if (format === "doc")
+        return "application/msword";
+    if (format === "docx")
+        return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    if (format === "xls")
+        return "application/vnd.ms-excel";
+    return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+}
+function timeout(promise, ms, message) {
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new KiroPluginError(message, "KIRO_ACP_TIMEOUT", 504)), ms);
+    });
+    return Promise.race([promise, deadline]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+class AsyncQueue {
+    #values = [];
+    #waiting = [];
+    #closed = false;
+    #error;
+    push(value) {
+        if (this.#closed || this.#error)
+            return;
+        this.#values.push(value);
+        this.#wake();
+    }
+    close() {
+        this.#closed = true;
+        this.#wake();
+    }
+    fail(error) {
+        this.#error = error;
+        this.#wake();
+    }
+    #wake() {
+        for (const resolve of this.#waiting.splice(0))
+            resolve();
+    }
+    async *[Symbol.asyncIterator]() {
+        for (;;) {
+            if (this.#values.length > 0) {
+                const value = this.#values.shift();
+                if (value !== undefined)
+                    yield value;
+                continue;
+            }
+            if (this.#error)
+                throw this.#error;
+            if (this.#closed)
+                return;
+            await new Promise((resolve) => {
+                this.#waiting.push(resolve);
+            });
+        }
+    }
+}
+export class KiroAcpTransport {
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    #client() {
+        if (this.#options.client)
+            return { client: this.#options.client, owned: false };
+        const stdioOptions = {
+            ...(this.#options.command ? { command: this.#options.command } : {}),
+            ...(this.#options.args ? { args: this.#options.args } : {}),
+            ...(this.#options.cwd ? { cwd: this.#options.cwd } : {}),
+        };
+        return {
+            client: createAcpStdioClient({
+                ...stdioOptions,
+                requestHandler: this.#requestHandler(),
+            }),
+            owned: true,
+        };
+    }
+    #requestHandler() {
+        return (message) => {
+            if (message.method === "session/request_permission") {
+                return acpPermissionResponse(message.params, this.#options.trustAllTools === true);
+            }
+            return unsupportedAcpRequest(message.method);
+        };
+    }
+    async #startSession(client, request) {
+        await client.request("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: {
+                    readTextFile: false,
+                    writeTextFile: false,
+                },
+                terminal: false,
+            },
+            clientInfo: this.#options.clientInfo ?? {
+                name: "opencode-kiro-plugin",
+                version: "0.1.0",
+            },
+        });
+        const sessionId = sessionIdFrom(await client.request("session/new", {
+            cwd: this.#options.cwd ?? process.cwd(),
+            mcpServers: [],
+        }));
+        if (request.modelId !== "auto") {
+            await client.request("session/set_model", {
+                sessionId,
+                model: request.modelId,
+            });
+        }
+        return sessionId;
+    }
+    async generate(request) {
+        const chunks = [];
+        const toolCalls = new Map();
+        for await (const event of this.stream(request)) {
+            if (event.type === "tool_call") {
+                toolCalls.set(event.id, event);
+                continue;
+            }
+            chunks.push(event.text);
+        }
+        const collectedToolCalls = [...toolCalls.values()];
+        return {
+            text: chunks.join(""),
+            modelId: request.modelId,
+            ...(collectedToolCalls.length > 0 ? { toolCalls: collectedToolCalls } : {}),
+        };
+    }
+    async *stream(request) {
+        const { client, owned } = this.#client();
+        const promptTimeoutMs = this.#options.promptTimeoutMs ?? 120_000;
+        const queue = new AsyncQueue();
+        let sessionId;
+        let completed = false;
+        const seenToolCallPayloads = new Map();
+        const timer = setTimeout(() => {
+            queue.fail(new KiroPluginError("Timed out waiting for ACP TurnEnd notification.", "KIRO_ACP_TIMEOUT", 504));
+        }, promptTimeoutMs);
+        const unsubscribe = client.onNotification((notification) => {
+            const update = notificationUpdate(notification);
+            if (!update)
+                return;
+            const text = textFromUpdate(update);
+            if (text)
+                queue.push({ type: "text", text, modelId: request.modelId });
+            const toolCall = toolCallFromUpdate(update, request.modelId);
+            if (toolCall) {
+                const payload = `${toolCall.name}\n${toolCall.arguments}`;
+                if (seenToolCallPayloads.get(toolCall.id) !== payload) {
+                    seenToolCallPayloads.set(toolCall.id, payload);
+                    queue.push(toolCall);
+                }
+            }
+            if (isTurnEnd(update)) {
+                completed = true;
+                queue.close();
+            }
+        });
+        try {
+            sessionId = await this.#startSession(client, request);
+            const prompt = client.request("session/prompt", {
+                sessionId,
+                content: acpPromptContent(request),
+            }).catch((error) => {
+                queue.fail(error);
+            });
+            for await (const event of queue) {
+                yield event;
+            }
+            await timeout(prompt, promptTimeoutMs, "Timed out waiting for ACP prompt response.");
+        }
+        finally {
+            clearTimeout(timer);
+            unsubscribe();
+            if (sessionId && !completed) {
+                await client.request("session/cancel", { sessionId }).catch(() => undefined);
+            }
+            if (owned)
+                client.close?.();
+        }
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1,25 @@
+export type AuthMethod = "api-key" | "cli-session" | "none";
+export interface AuthDiagnostics {
+    readonly authenticated: boolean;
+    readonly method: AuthMethod;
+    readonly region: string;
+    readonly message: string;
+    readonly account?: string;
+}
+export interface CommandResult {
+    readonly ok: boolean;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly error?: unknown;
+}
+export interface CommandRunOptions {
+    readonly timeoutMs?: number;
+}
+export type CommandRunner = (command: string, args: ReadonlyArray<string>, options?: CommandRunOptions) => Promise<CommandResult>;
+export declare function runCommand(command: string, args: ReadonlyArray<string>, options?: CommandRunOptions): Promise<CommandResult>;
+export declare function redacted(value: string | undefined): string | undefined;
+export declare function detectAuth(env?: NodeJS.ProcessEnv, runner?: CommandRunner): Promise<AuthDiagnostics>;
+export declare function resolveApiKey(auth: () => Promise<{
+    type: string;
+    key?: string;
+}>, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/auth.js

@@ -0,0 +1,77 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function runCommand(command, args, options = {}) {
+    try {
+        const result = await execFileAsync(command, [...args], { timeout: options.timeoutMs ?? 5000 });
+        return { ok: true, stdout: result.stdout, stderr: result.stderr };
+    }
+    catch (error) {
+        const partial = error;
+        return {
+            ok: false,
+            stdout: partial.stdout ?? "",
+            stderr: partial.stderr ?? "",
+            error,
+        };
+    }
+}
+export function redacted(value) {
+    if (!value)
+        return undefined;
+    if (value.length <= 8)
+        return "***";
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+function parseWhoami(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        const account = parsed.email ?? parsed.username ?? parsed.account;
+        return typeof account === "string" ? account : undefined;
+    }
+    catch {
+        return trimmed.split(/\s+/)[0];
+    }
+}
+export async function detectAuth(env = process.env, runner = runCommand) {
+    const region = env.KIRO_REGION || env.AWS_REGION || "us-east-1";
+    if (env.KIRO_API_KEY) {
+        return {
+            authenticated: true,
+            method: "api-key",
+            region,
+            message: `Using KIRO_API_KEY (${redacted(env.KIRO_API_KEY)})`,
+        };
+    }
+    const whoami = await runner("kiro-cli", ["whoami"]);
+    if (whoami.ok) {
+        const account = parseWhoami(whoami.stdout);
+        return {
+            authenticated: true,
+            method: "cli-session",
+            region,
+            message: account ? `Using kiro-cli session for ${account}` : "Using active kiro-cli session",
+            ...(account ? { account } : {}),
+        };
+    }
+    return {
+        authenticated: false,
+        method: "none",
+        region,
+        message: "No KIRO_API_KEY or active kiro-cli session found. Run `kiro-cli login` or configure KIRO_API_KEY.",
+    };
+}
+export async function resolveApiKey(auth, env = process.env) {
+    if (env.KIRO_API_KEY)
+        return env.KIRO_API_KEY;
+    try {
+        const credential = await auth();
+        return credential.type === "api" && credential.key ? credential.key : "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/cli-transport.d.ts

@@ -0,0 +1,17 @@
+import type { CommandRunner } from "./auth.js";
+import type { KiroTransport } from "./fetch-adapter.js";
+import type { KiroGenerateRequest } from "./request-adapter.js";
+import type { KiroGenerateResponse } from "./response-adapter.js";
+export interface CliChatTransportOptions {
+    readonly runner?: CommandRunner;
+    readonly trustAllTools?: boolean;
+    readonly requestTimeoutMs?: number;
+}
+export declare function promptForCli(request: KiroGenerateRequest): string;
+export declare function cliChatArgs(request: KiroGenerateRequest, options?: Pick<CliChatTransportOptions, "trustAllTools">): string[];
+export declare function sanitizeCliChatOutput(output: string): string;
+export declare class KiroCliChatTransport implements KiroTransport {
+    #private;
+    constructor(options?: CliChatTransportOptions);
+    generate(request: KiroGenerateRequest): Promise<KiroGenerateResponse>;
+}

package/dist/cli-transport.js

@@ -0,0 +1,52 @@
+import { runCommand } from "./auth.js";
+import { KiroPluginError } from "./errors.js";
+export function promptForCli(request) {
+    const parts = [
+        request.system ? `System:\n${request.system}` : "",
+        ...request.history.map((turn) => `${turn.role}:\n${turn.content}`),
+        `user:\n${request.prompt}`,
+    ].filter(Boolean);
+    return parts.join("\n\n");
+}
+export function cliChatArgs(request, options = {}) {
+    return [
+        "chat",
+        "--no-interactive",
+        ...(options.trustAllTools ? ["--trust-all-tools"] : []),
+        promptForCli(request),
+    ];
+}
+export function sanitizeCliChatOutput(output) {
+    const text = output.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\r/g, "");
+    const lines = text
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => !line.includes("Credits:"));
+    if (lines[0]?.trimStart().startsWith(">")) {
+        lines[0] = lines[0].replace(/^\s*>\s*/, "");
+    }
+    return lines.join("\n").trim();
+}
+export class KiroCliChatTransport {
+    #runner;
+    #trustAllTools;
+    #requestTimeoutMs;
+    constructor(options = {}) {
+        this.#runner = options.runner ?? runCommand;
+        this.#trustAllTools = options.trustAllTools === true;
+        this.#requestTimeoutMs = options.requestTimeoutMs ?? 120_000;
+    }
+    async generate(request) {
+        const result = await this.#runner("kiro-cli", cliChatArgs(request, { trustAllTools: this.#trustAllTools }), {
+            timeoutMs: this.#requestTimeoutMs,
+        });
+        if (!result.ok) {
+            const authError = result.stderr.toLowerCase().includes("not logged in");
+            throw new KiroPluginError(result.stderr.trim() || "kiro-cli chat failed", authError ? "KIRO_AUTH_ERROR" : "KIRO_CLI_FAILED", authError ? 401 : 502);
+        }
+        return {
+            text: sanitizeCliChatOutput(result.stdout),
+            modelId: request.modelId,
+        };
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+export type BackendMode = "auto" | "fetch" | "cli-chat" | "acp";
+export type ModelDiscoveryMode = "auto" | "off";
+export interface KiroPluginOptions {
+    readonly providerID: string;
+    readonly region: string;
+    readonly endpoint?: string;
+    readonly backend: BackendMode;
+    readonly modelDiscovery: ModelDiscoveryMode;
+    readonly modelDiscoveryCommand: ReadonlyArray<string>;
+    readonly modelCacheTtlSeconds: number;
+    readonly requestTimeoutMs?: number;
+    readonly maxAttempts: number;
+    readonly profileArn?: string;
+    readonly userAgent?: string;
+    readonly agentMode?: string;
+    readonly modelAliases: Readonly<Record<string, string>>;
+    readonly extraModels: Readonly<Record<string, Record<string, unknown>>>;
+    readonly hiddenModels: Readonly<Record<string, string>>;
+    readonly disabledModels: ReadonlyArray<string>;
+    readonly disableModelPassThrough: boolean;
+    readonly trustAllTools: boolean;
+}
+export declare const DEFAULT_PROVIDER_ID = "kiro";
+export declare const DEFAULT_REGION = "us-east-1";
+export declare const DEFAULT_MODEL_CACHE_TTL_SECONDS: number;
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+export declare function loadOptions(raw?: unknown): KiroPluginOptions;

package/dist/config.js

@@ -0,0 +1,76 @@
+export const DEFAULT_PROVIDER_ID = "kiro";
+export const DEFAULT_REGION = "us-east-1";
+export const DEFAULT_MODEL_CACHE_TTL_SECONDS = 6 * 60 * 60;
+export const DEFAULT_MAX_ATTEMPTS = 3;
+const BACKENDS = new Set(["auto", "fetch", "cli-chat", "acp"]);
+const DISCOVERY_MODES = new Set(["auto", "off"]);
+function stringRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value)
+        .filter((entry) => typeof entry[1] === "string")
+        .map(([key, item]) => [key, item]));
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function objectRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => Boolean(entry[0]) && Boolean(entry[1]) && typeof entry[1] === "object" && !Array.isArray(entry[1])));
+}
+function positiveNumber(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return fallback;
+    return value;
+}
+function positiveInteger(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1)
+        return fallback;
+    return Math.max(1, Math.floor(value));
+}
+function optionalPositiveNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return undefined;
+    return value;
+}
+function optionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+export function loadOptions(raw = {}) {
+    const input = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    const backend = typeof input.backend === "string" && BACKENDS.has(input.backend) ? input.backend : "auto";
+    const modelDiscovery = typeof input.modelDiscovery === "string" && DISCOVERY_MODES.has(input.modelDiscovery)
+        ? input.modelDiscovery
+        : "auto";
+    const requestTimeoutMs = optionalPositiveNumber(input.requestTimeoutMs);
+    const endpoint = optionalString(input.endpoint);
+    const profileArn = optionalString(input.profileArn);
+    const userAgent = optionalString(input.userAgent);
+    const agentMode = optionalString(input.agentMode);
+    return {
+        providerID: typeof input.providerID === "string" && input.providerID ? input.providerID : DEFAULT_PROVIDER_ID,
+        region: typeof input.region === "string" && input.region ? input.region : DEFAULT_REGION,
+        ...(endpoint ? { endpoint } : {}),
+        backend,
+        modelDiscovery,
+        modelDiscoveryCommand: stringArray(input.modelDiscoveryCommand),
+        modelCacheTtlSeconds: positiveNumber(input.modelCacheTtlSeconds, DEFAULT_MODEL_CACHE_TTL_SECONDS),
+        ...(requestTimeoutMs ? { requestTimeoutMs } : {}),
+        maxAttempts: positiveInteger(input.maxAttempts, DEFAULT_MAX_ATTEMPTS),
+        ...(profileArn ? { profileArn } : {}),
+        ...(userAgent ? { userAgent } : {}),
+        ...(agentMode ? { agentMode } : {}),
+        modelAliases: stringRecord(input.modelAliases),
+        extraModels: objectRecord(input.extraModels),
+        hiddenModels: stringRecord(input.hiddenModels),
+        disabledModels: stringArray(input.disabledModels),
+        disableModelPassThrough: input.disableModelPassThrough === true,
+        trustAllTools: input.trustAllTools === true,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class KiroPluginError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code: string, status?: number);
+}
+export declare class UnsupportedBackendError extends KiroPluginError {
+    constructor(message?: string);
+}
+export declare function normalizeError(error: unknown): KiroPluginError;
+export declare function errorResponse(error: unknown): Response;