@kilnai/cli 0.23.1 → 1.0.0

package/dist/wrapper/opencode-session.d.ts

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+import type { SessionEvent, SessionCapabilities, SessionRunOptions, IKilnSession, KilnPermissionAction, KilnPermissionPolicy, KilnSandboxMode } from "./session.js";
+interface McpServer {
+    name: string;
+    url: string;
+}
+interface TranslationRuleMetadata {
+    readonly category: string;
+    readonly selector: string;
+    readonly action: string;
+    readonly reason?: string;
+}
+interface OpenCodeNativeRuleMetadata {
+    readonly tools: readonly {
+        readonly tool: string;
+        readonly action: KilnPermissionAction;
+    }[];
+    readonly commands: readonly {
+        readonly pattern: string;
+        readonly shell?: "bash" | "sh" | "zsh" | "any";
+        readonly action: KilnPermissionAction;
+    }[];
+    readonly fileGovernance: {
+        readonly denyGlobs: readonly string[];
+        readonly askGlobs: readonly string[];
+        readonly allowGlobs: readonly string[];
+    };
+}
+export interface OpenCodeSessionConfig {
+    readonly task: string;
+    readonly cwd: string;
+    readonly env?: Record<string, string>;
+    readonly mcpServers?: McpServer[];
+    readonly mcpServerEntryPath?: string;
+    readonly model?: string;
+    readonly port?: number;
+    readonly baseUrl?: string;
+    readonly permissionDefault?: "ask" | "allow" | "deny";
+    readonly sandboxMode?: KilnSandboxMode;
+    readonly nativeRules?: OpenCodeNativeRuleMetadata;
+    readonly representableRules?: readonly TranslationRuleMetadata[];
+    readonly unsupportedRules?: readonly TranslationRuleMetadata[];
+    readonly constraintInstructions?: readonly string[];
+    readonly translationWarnings?: readonly string[];
+    readonly permissionPolicy?: KilnPermissionPolicy;
+    readonly resumeSessionId?: string;
+}
+export declare class OpenCodeSession implements IKilnSession {
+    readonly sessionId: string;
+    serveProcess: ReturnType<typeof spawn> | null;
+    private readonly _config;
+    private readonly _capabilities;
+    private _remoteSessionId;
+    private _resolvedBaseUrl;
+    private _lastCostUsd;
+    private _abortController;
+    private _eventAbortController;
+    private _disposed;
+    constructor(config: OpenCodeSessionConfig);
+    get capabilities(): SessionCapabilities;
+    get providerSessionId(): string | undefined;
+    run(options: SessionRunOptions): AsyncIterable<SessionEvent>;
+    spawnAndWaitForServe(port: number, cwd: string, env?: Record<string, string>): Promise<number>;
+    private _findOpencodePath;
+    private _killServeProcess;
+    dispose(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=opencode-session.d.ts.map

package/dist/wrapper/opencode-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-session.d.ts","sourceRoot":"","sources":["../../src/wrapper/opencode-session.ts"],"names":[],"mappings":"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"}

package/dist/wrapper/opencode-session.js

@@ -0,0 +1,568 @@
+import { spawn, execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { appendExecutionIdentity, resolveExecutionIdentity } from "@kilnai/core";
+import { normalizeMcpSelector } from "./mcp-selector.js";
+import { debug } from "./debug.js";
+import { SessionStore } from "./session-store.js";
+function asOpencodeClient(value) {
+    if (value === null || value === undefined) {
+        throw new Error("SDK client is null or undefined");
+    }
+    const v = value;
+    if (typeof v.session?.create !== "function") {
+        throw new Error("SDK client missing session.create");
+    }
+    if (typeof v.global?.event !== "function") {
+        throw new Error("SDK client missing global.event");
+    }
+    if (typeof v.config?.update !== "function") {
+        throw new Error("SDK client missing config.update");
+    }
+    return value;
+}
+const OPENCODE_SANDBOX_WARNING = "OpenCode does not natively enforce Kiln sandbox modes; Kiln maps sandbox intent to permission prompting semantics only.";
+function derivePermissionPolicy(permissionDefault, sandboxMode, fallback) {
+    if (permissionDefault === "allow") {
+        return { approval: "never", sandbox: sandboxMode ?? "read-only" };
+    }
+    if (permissionDefault === "deny") {
+        return { approval: "untrusted", sandbox: "read-only" };
+    }
+    return fallback ?? { approval: "on-request", sandbox: "read-only" };
+}
+function collectRuntimeWarnings(config) {
+    const warnings = new Set(config.translationWarnings ?? []);
+    if (config.sandboxMode && config.sandboxMode !== "read-only") {
+        warnings.add(`OpenCode sandbox mode '${config.sandboxMode}' is not natively enforced; using permission prompting semantics only.`);
+    }
+    if (warnings.size === 0 && config.sandboxMode !== undefined) {
+        warnings.add(OPENCODE_SANDBOX_WARNING);
+    }
+    return [...warnings];
+}
+function toOpenCodePermissionValue(action) {
+    return action;
+}
+function mapToolToPermissionKey(tool) {
+    const normalized = tool.trim().toLowerCase();
+    if (normalized === "edit" || normalized === "write" || normalized === "multiedit" || normalized === "notebookedit") {
+        return "edit";
+    }
+    if (normalized === "bash" || normalized === "command_execution" || normalized === "command") {
+        return "bash";
+    }
+    if (normalized === "webfetch" || normalized === "web_fetch" || normalized === "fetch") {
+        return "webfetch";
+    }
+    return null;
+}
+function isGlobalCommandRule(pattern) {
+    const normalized = pattern.trim();
+    return normalized === "*" || normalized === "**" || normalized === "*:*";
+}
+function applyGranularPermissionOverrides(base, nativeRules) {
+    const next = { ...base };
+    if (!nativeRules)
+        return next;
+    for (const rule of nativeRules.tools) {
+        const permissionKey = mapToolToPermissionKey(rule.tool);
+        if (permissionKey !== null) {
+            next[permissionKey] = toOpenCodePermissionValue(rule.action);
+        }
+    }
+    for (const rule of nativeRules.commands) {
+        if (isGlobalCommandRule(rule.pattern)
+            && (rule.shell === undefined || rule.shell === "any" || rule.shell === "bash")) {
+            next.bash = toOpenCodePermissionValue(rule.action);
+        }
+    }
+    return next;
+}
+function buildFileGovernanceInstructions(nativeRules) {
+    if (!nativeRules)
+        return [];
+    const lines = [];
+    for (const glob of nativeRules.fileGovernance.denyGlobs) {
+        lines.push(`[file-governance] DENY ${glob}`);
+    }
+    for (const glob of nativeRules.fileGovernance.askGlobs) {
+        lines.push(`[file-governance] ASK ${glob}`);
+    }
+    for (const glob of nativeRules.fileGovernance.allowGlobs) {
+        lines.push(`[file-governance] ALLOW ${glob}`);
+    }
+    if (lines.length === 0)
+        return [];
+    return ["Kiln file governance constraints for opencode:", ...lines];
+}
+function appendConstraintInstructions(prompt, constraintInstructions, nativeRules) {
+    const sections = [prompt];
+    if (constraintInstructions && constraintInstructions.length > 0) {
+        sections.push(constraintInstructions.join("\n"));
+    }
+    const fileGovernanceInstructions = buildFileGovernanceInstructions(nativeRules);
+    if (fileGovernanceInstructions.length > 0) {
+        sections.push(fileGovernanceInstructions.join("\n"));
+    }
+    return sections.filter((section) => section.trim().length > 0).join("\n\n");
+}
+export class OpenCodeSession {
+    sessionId;
+    serveProcess = null;
+    _config;
+    _capabilities;
+    _remoteSessionId = null;
+    _resolvedBaseUrl = null;
+    _lastCostUsd = 0;
+    _abortController = null;
+    _eventAbortController = null;
+    _disposed = false;
+    constructor(config) {
+        this.sessionId = randomUUID();
+        this._config = config;
+        this._capabilities = {
+            mcp: true,
+            streaming: true,
+            resumable: config.resumeSessionId !== undefined,
+            resume: config.resumeSessionId !== undefined,
+            costTrackingMode: "native",
+            supportedTools: [],
+            maxContextTokens: null,
+            priority: 2,
+            fallbackTo: null,
+            permissionPolicy: derivePermissionPolicy(config.permissionDefault, config.sandboxMode, config.permissionPolicy),
+        };
+        for (const warning of collectRuntimeWarnings(config)) {
+            debug(`[opencode] ${warning}`);
+        }
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    get providerSessionId() {
+        return this._remoteSessionId ?? undefined;
+    }
+    async *run(options) {
+        if (this._disposed)
+            return;
+        const startTime = Date.now();
+        const abortController = new AbortController();
+        this._abortController = abortController;
+        const knownMcpToolNames = new Set();
+        const partTypes = new Map(); // partID → part type ("text" | "reasoning" | "tool" | ...)
+        const cwd = options.cwd ?? this._config.cwd;
+        if (options.abortSignal) {
+            if (options.abortSignal.aborted) {
+                abortController.abort();
+            }
+            else {
+                options.abortSignal.addEventListener("abort", () => {
+                    abortController.abort();
+                    this._killServeProcess();
+                }, { once: true });
+            }
+        }
+        try {
+            let baseUrl;
+            const isResumingTurn = this._resolvedBaseUrl !== null && this._remoteSessionId !== null;
+            let storedRemoteSessionId;
+            if (!isResumingTurn) {
+                if (this._config.resumeSessionId !== undefined) {
+                    try {
+                        const store = new SessionStore(this._config.cwd);
+                        const record = await store.find(this._config.resumeSessionId);
+                        if (record?.providerSessionId) {
+                            storedRemoteSessionId = record.providerSessionId;
+                        }
+                    }
+                    catch {
+                        console.error("[SessionStore] Resume lookup failed, continuing without resume");
+                    }
+                }
+                if (this._config.baseUrl) {
+                    baseUrl = this._config.baseUrl;
+                }
+                else {
+                    const port = this._config.port ?? 0;
+                    const actualPort = await this.spawnAndWaitForServe(port, cwd, this._config.env);
+                    baseUrl = `http://127.0.0.1:${actualPort}`;
+                }
+                this._resolvedBaseUrl = baseUrl;
+            }
+            else {
+                baseUrl = this._resolvedBaseUrl;
+            }
+            const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
+            const client = asOpencodeClient(createOpencodeClient({ baseUrl }));
+            if (!isResumingTurn) {
+                const approval = this._capabilities.permissionPolicy.approval;
+                const permValue = approval === "never" ? "allow" : approval === "untrusted" ? "deny" : "ask";
+                const permissionPayload = applyGranularPermissionOverrides({
+                    edit: permValue,
+                    bash: permValue,
+                    webfetch: permValue,
+                }, this._config.nativeRules);
+                await client.config
+                    .update({
+                    body: { permission: permissionPayload },
+                    query: { directory: cwd },
+                })
+                    .catch((err) => {
+                    console.debug(`[opencode] config.update failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                const mcpEntryPath = this._config.mcpServerEntryPath;
+                if (mcpEntryPath && existsSync(mcpEntryPath)) {
+                    const mcpEntry = {
+                        type: "local",
+                        command: ["node", mcpEntryPath],
+                        enabled: true,
+                    };
+                    await client.config
+                        .update({
+                        body: { mcp: { kiln: mcpEntry } },
+                        query: { directory: cwd },
+                    })
+                        .catch((err) => {
+                        console.debug(`[opencode] MCP config.update failed: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
+                else if (mcpEntryPath) {
+                    debug(`MCP server entry not found at ${mcpEntryPath}, skipping runtime MCP registration`);
+                }
+                await client.config
+                    .update({
+                    body: { experimental: { batch_tool: true } },
+                    query: { directory: cwd },
+                })
+                    .catch((err) => {
+                    console.debug(`[opencode] batch_tool config.update failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                if (this._config.model) {
+                    await client.config
+                        .update({
+                        body: { model: this._config.model },
+                        query: { directory: cwd },
+                    })
+                        .catch((err) => {
+                        console.debug(`[opencode] model config.update failed: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
+            }
+            if (!isResumingTurn) {
+                if (storedRemoteSessionId !== undefined) {
+                    const getResult = await client.session.get({ sessionID: storedRemoteSessionId, directory: cwd }, { throwOnError: true });
+                    this._remoteSessionId = getResult.data.id;
+                }
+                else {
+                    const createResult = await client.session.create({ directory: cwd }, { throwOnError: true });
+                    this._remoteSessionId = createResult.data.id;
+                }
+            }
+            this._eventAbortController = new AbortController();
+            const eventStreamPromise = client.global.event({
+                signal: this._eventAbortController.signal,
+            });
+            const eventQueue = [];
+            let eventYield = null;
+            const eventDone = new Set();
+            eventStreamPromise
+                .then(async ({ stream }) => {
+                try {
+                    for await (const event of stream) {
+                        if (this._eventAbortController?.signal.aborted)
+                            break;
+                        if (eventYield !== null) {
+                            const yieldFn = eventYield;
+                            eventYield = null;
+                            yieldFn(event);
+                        }
+                        else {
+                            eventQueue.push(event);
+                        }
+                    }
+                    for (const doneFn of eventDone)
+                        doneFn();
+                }
+                catch {
+                    for (const doneFn of eventDone)
+                        doneFn();
+                }
+            })
+                .catch(() => {
+                for (const doneFn of eventDone)
+                    doneFn();
+            });
+            const waitForEvent = () => {
+                if (eventQueue.length > 0)
+                    return Promise.resolve(eventQueue.shift());
+                return new Promise((resolve) => {
+                    eventYield = resolve;
+                    eventDone.add(() => resolve(null));
+                });
+            };
+            const promptWithExecutionIdentity = appendExecutionIdentity(options.prompt, resolveExecutionIdentity({
+                configuredProvider: "opencode",
+                configuredModel: this._config.model,
+            }));
+            const promptResult = await client.session
+                .prompt({
+                sessionID: this._remoteSessionId,
+                parts: [{
+                        type: "text",
+                        text: appendConstraintInstructions(promptWithExecutionIdentity, this._config.constraintInstructions, this._config.nativeRules),
+                    }],
+                directory: cwd,
+            }, { throwOnError: false })
+                .catch(() => ({ data: undefined }));
+            this._lastCostUsd = promptResult?.data?.info?.cost ?? this._lastCostUsd;
+            while (true) {
+                const event = await waitForEvent();
+                if (!event)
+                    break;
+                if (event.payload.type === "sessionUpdate") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    if (props?.type === "usage_update" && props?.cost?.amount !== undefined) {
+                        this._lastCostUsd = props.cost.amount;
+                        yield {
+                            type: "cost_update",
+                            usd: props.cost.amount,
+                            mode: "native",
+                            inputTokens: props.cost.inputTokens,
+                            outputTokens: props.cost.outputTokens,
+                            cacheReadTokens: props.cost.cacheReadTokens,
+                        };
+                    }
+                    continue;
+                }
+                if (event.payload.type === "message.part.delta") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    if (props?.field === "text" && props?.delta) {
+                        const partType = props.partID ? partTypes.get(props.partID) : undefined;
+                        if (partType === "reasoning") {
+                            yield { type: "text_delta", content: props.delta, isThinking: true };
+                        }
+                        else {
+                            yield { type: "text_delta", content: props.delta };
+                        }
+                    }
+                    continue;
+                }
+                if (event.payload.type === "message.part.updated") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    if (!props?.part)
+                        continue;
+                    const part = props.part;
+                    if (part.id && part.type)
+                        partTypes.set(part.id, part.type);
+                    if (part.type === "tool") {
+                        if (part.state?.status === "pending" || part.state?.status === "running") {
+                            const toolName = part.tool ?? "unknown";
+                            const isMcpTool = knownMcpToolNames.has(toolName);
+                            yield {
+                                type: "tool_use",
+                                toolName,
+                                input: part.state?.input ?? {},
+                                ...(isMcpTool
+                                    ? { source: "mcp", mcpSelector: normalizeMcpSelector(toolName) }
+                                    : {}),
+                            };
+                        }
+                        else if (part.state?.status === "completed") {
+                            const output = part.state?.output;
+                            const outputStr = output !== undefined
+                                ? output
+                                : part.state?.metadata?.output !== undefined
+                                    ? String(part.state.metadata.output)
+                                    : "";
+                            yield {
+                                type: "tool_result",
+                                toolName: part.tool ?? "unknown",
+                                output: outputStr,
+                            };
+                        }
+                        else if (part.state?.status === "error") {
+                            yield {
+                                type: "tool_result",
+                                toolName: part.tool ?? "unknown",
+                                output: part.state.error ?? "Tool failed",
+                            };
+                        }
+                    }
+                    continue;
+                }
+                if (event.payload.type === "session.status") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    if (props?.status?.type === "idle") {
+                        break;
+                    }
+                }
+                if (event.payload.type === "session.compacted") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    const output = props?.tokens !== undefined
+                        ? `Context compacted to approximately ${props.tokens} tokens`
+                        : "Context compacted";
+                    yield { type: "tool_result", toolName: "session.compacted", output };
+                    continue;
+                }
+                if (event.payload.type === "question.asked") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    if (props?.question) {
+                        yield { type: "text_delta", content: `[Question] ${props.question}` };
+                    }
+                    continue;
+                }
+                if (event.payload.type === "mcp.tools.changed") {
+                    const props = event.payload.properties;
+                    if (props?.sessionID !== this._remoteSessionId)
+                        continue;
+                    const nextMcpToolNames = new Set();
+                    for (const tool of props?.tools ?? []) {
+                        if (typeof tool?.name === "string" && tool.name.length > 0) {
+                            nextMcpToolNames.add(tool.name);
+                        }
+                    }
+                    knownMcpToolNames.clear();
+                    for (const toolName of nextMcpToolNames) {
+                        knownMcpToolNames.add(toolName);
+                    }
+                    const toolList = props?.tools?.map((t) => t.name).join(", ") ?? "";
+                    yield { type: "tool_result", toolName: "mcp.tools.changed", output: toolList };
+                    continue;
+                }
+            }
+            const stopReason = promptResult?.data?.info?.stopReason;
+            const isError = stopReason === "cancelled";
+            yield {
+                type: "completed",
+                totalUsd: this._lastCostUsd,
+                durationMs: Date.now() - startTime,
+                isError,
+                isPreflightCrash: false,
+            };
+            try {
+                const store = new SessionStore(this._config.cwd);
+                const completedAt = new Date().toISOString();
+                await store.append({
+                    sessionId: this._remoteSessionId ?? this.sessionId,
+                    provider: "opencode",
+                    task: this._config.task,
+                    completedAt,
+                    cost: this._lastCostUsd,
+                    projectPath: this._config.cwd,
+                    providerSessionId: this._remoteSessionId ?? undefined,
+                });
+            }
+            catch (err) {
+                console.error("[SessionStore] Failed to append session record:", err instanceof Error ? err.message : String(err));
+            }
+        }
+        catch (err) {
+            yield {
+                type: "error",
+                code: "OPENCODE_ERROR",
+                message: err instanceof Error ? err.message : String(err),
+                isRetryable: false,
+            };
+        }
+        finally {
+            this._abortController = null;
+            this._eventAbortController?.abort();
+            this._eventAbortController = null;
+        }
+    }
+    async spawnAndWaitForServe(port, cwd, env) {
+        const opencodePath = this._findOpencodePath();
+        const args = ["serve", "--port", String(port)];
+        const spawnEnv = { ...process.env, ...env };
+        debug(`[opencode] spawning: ${opencodePath} ${args.join(" ")}`);
+        debug(`[opencode] cwd: ${cwd}`);
+        const proc = spawn(opencodePath, args, {
+            cwd,
+            env: spawnEnv,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: false,
+        });
+        this.serveProcess = proc;
+        let actualPort = port;
+        let stderrOutput = "";
+        const portRegex = /listening on (?:http:\/\/)?[^:]*:(\d+)/i;
+        const portPromise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`opencode serve failed to start within 15 seconds\nStderr: ${stderrOutput}`));
+            }, 15_000);
+            const handleData = (data) => {
+                const line = data.toString();
+                debug(`[opencode] stdout/stderr: ${line.trim()}`);
+                const match = line.match(portRegex);
+                if (match?.[1]) {
+                    actualPort = parseInt(match[1], 10);
+                    clearTimeout(timeout);
+                    proc.stdout?.removeListener("data", handleData);
+                    resolve();
+                }
+            };
+            proc.stdout?.on("data", handleData);
+            proc.stderr?.on("data", (data) => {
+                stderrOutput += data.toString();
+                handleData(data);
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to spawn opencode serve: ${err.message}\nStderr: ${stderrOutput}`));
+            });
+            proc.on("exit", (code) => {
+                clearTimeout(timeout);
+                debug(`[opencode] serve exited with code ${code}`);
+                if (code !== 0 && code !== null) {
+                    reject(new Error(`opencode serve exited with code ${code}\nStderr: ${stderrOutput}`));
+                }
+            });
+        });
+        await portPromise;
+        return actualPort;
+    }
+    _findOpencodePath() {
+        const homedir = process.env.HOME ?? process.env.USERPROFILE ?? "";
+        const fallbackPaths = [
+            `${homedir}\\.bun\\bin\\opencode.exe`,
+            `${homedir}\\AppData\\Roaming\\npm\\opencode.cmd`,
+        ];
+        const candidates = ["opencode", "opencode.exe", ...fallbackPaths];
+        for (const candidate of candidates) {
+            try {
+                execSync(`"${candidate}" --version`, { stdio: "ignore" });
+                return candidate;
+            }
+            catch {
+                // try next
+            }
+        }
+        throw new Error("opencode binary not found in PATH. Ensure opencode is installed and accessible.");
+    }
+    _killServeProcess() {
+        if (this.serveProcess && !this.serveProcess.killed) {
+            this.serveProcess.kill("SIGTERM");
+        }
+    }
+    async dispose() {
+        this._disposed = true;
+        this._abortController?.abort();
+        this._eventAbortController?.abort();
+        this._killServeProcess();
+        this.serveProcess = null;
+    }
+}
+//# sourceMappingURL=opencode-session.js.map