@yuandc/aica 0.1.0

package/dist/acp/providers/mimo/provider.js

@@ -0,0 +1,448 @@
+import fs from "node:fs";
+import path from "node:path";
+import { eventFromAcpSessionUpdate, statusFromAcpSessionUpdate } from "../../client/acp-events.js";
+import { contextUsageFromAcpSessionUpdate } from "../../client/context-usage.js";
+import { defaultAcpRuntimePool } from "../../client/acp-runtime-pool.js";
+export const mimoCodeCapabilities = {
+    sessionResume: true,
+    imageInput: true,
+    fileAttachment: true,
+    filesystem: true,
+    terminal: true,
+    permissionRequest: true,
+    configOptions: true,
+    usage: true,
+    contextUsage: true,
+    contextCompaction: false,
+    plan: true,
+    diff: false
+};
+export class MimoCodeProvider {
+    id = "mimocode";
+    name = "MimoCode";
+    capabilities = mimoCodeCapabilities;
+    async createSession(input) {
+        return new MimoCodeSession(input.cwd, input.providerSessionId ?? null, input.timeoutMs);
+    }
+}
+class MimoCodeSession {
+    cwd;
+    providerSessionId;
+    defaultTimeoutMs;
+    lease = null;
+    acpSessionResponse = null;
+    statusCallback = null;
+    updateCallback = null;
+    permissionCallback = null;
+    userInputCallback = null;
+    canExecuteTools = true;
+    abortHandler = null;
+    statusTimeline = [];
+    updates = [];
+    content = "";
+    latestContextUsage = null;
+    contextWindow = 0;
+    constructor(cwd, providerSessionId, defaultTimeoutMs = readMimoPromptTimeoutMs()) {
+        this.cwd = cwd;
+        this.providerSessionId = providerSessionId;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+    }
+    async sendPrompt(input) {
+        if (!fs.existsSync(input.cwd) || !fs.statSync(input.cwd).isDirectory()) {
+            throw new Error(`Project root does not exist or is not a directory: ${input.cwd}`);
+        }
+        const startedAt = Date.now();
+        this.statusCallback = input.onStatus ?? null;
+        this.updateCallback = input.onUpdate ?? null;
+        this.permissionCallback = input.onPermissionRequest ?? null;
+        this.userInputCallback = input.onUserInputRequest ?? null;
+        this.canExecuteTools = input.canExecuteTools !== false;
+        this.attachAbortSignal(input.signal);
+        this.content = "";
+        this.updates.length = 0;
+        this.statusTimeline.length = 0;
+        this.latestContextUsage = null;
+        this.contextWindow = positiveNumber(input.contextWindow);
+        let client = null;
+        let started = null;
+        let acpSessionId = this.providerSessionId;
+        let promptResponse;
+        try {
+            this.emitStatus("initializing", "MimoCode ACP 启动中", "mimo acp");
+            const lease = await this.acquireRuntime(input.cwd);
+            this.lease = lease;
+            client = lease.client;
+            started = lease.started;
+            await this.initialize(lease);
+            acpSessionId = await this.establishSession(lease, input.cwd);
+            await this.applyConfig(client, acpSessionId, input);
+            this.emitStatus("thinking", "思考中");
+            promptResponse = await client.prompt({
+                sessionId: acpSessionId,
+                prompt: promptBlocksToMimoAcpContent(input.prompt, input.promptBlocks)
+            }, input.timeoutMs ?? this.defaultTimeoutMs);
+        }
+        finally {
+            if (this.abortHandler && input.signal) {
+                input.signal.removeEventListener("abort", this.abortHandler);
+                this.abortHandler = null;
+            }
+            this.releaseLease();
+        }
+        this.emitStatus("completed", "已完成");
+        return {
+            providerSessionId: acpSessionId,
+            cliType: "builtin",
+            agentType: "mimo",
+            effectiveConfig: {
+                model: input.model || readMimoDefaultModel(),
+                mode: input.mode || null,
+                configOptionValues: input.configOptionValues ?? null,
+                command: started.command,
+                processPid: started.child.pid ?? null,
+                provider: "mimocode",
+                protocol: "acp"
+            },
+            command: started.command,
+            args: started.args,
+            cwd: input.cwd,
+            exitCode: started.child.exitCode,
+            signal: started.child.signalCode,
+            durationMs: Date.now() - startedAt,
+            stdout: client.rpc.stdout,
+            stderr: client.rpc.stderr,
+            content: this.content.trim(),
+            updates: [...this.updates],
+            statusTimeline: [...this.statusTimeline],
+            contextUsage: this.latestContextUsage,
+            promptResponse
+        };
+    }
+    async cancel() {
+        if (this.providerSessionId)
+            this.lease?.client.cancel(this.providerSessionId);
+    }
+    async close() {
+        this.statusCallback = null;
+        this.updateCallback = null;
+        this.permissionCallback = null;
+        this.userInputCallback = null;
+        this.canExecuteTools = true;
+        if (this.abortHandler)
+            this.abortHandler = null;
+        this.releaseLease();
+    }
+    async acquireRuntime(cwd) {
+        const command = process.env.ACA_MIMO_COMMAND || "mimo";
+        const args = ["acp", "--cwd", cwd];
+        return defaultAcpRuntimePool.acquire({
+            providerId: "mimocode",
+            cwd,
+            providerSessionId: this.providerSessionId,
+            command,
+            args,
+            onSessionUpdate: (params) => this.handleSessionUpdate(params),
+            onClientRequest: (method, params) => this.handleClientRequest(method, params)
+        });
+    }
+    async initialize(lease) {
+        if (lease.initialized)
+            return;
+        await lease.client.initialize(60_000);
+        lease.markInitialized();
+    }
+    async establishSession(lease, cwd) {
+        const client = lease.client;
+        if (lease.providerSessionId && lease.sessionEstablished) {
+            this.providerSessionId = lease.providerSessionId;
+            this.acpSessionResponse = lease.sessionResponse;
+            return lease.providerSessionId;
+        }
+        if (this.providerSessionId) {
+            try {
+                this.emitStatus("resuming", "MimoCode 会话恢复中", "session/resume");
+                const resumed = await client.resumeSession({ sessionId: this.providerSessionId, cwd }, 60_000);
+                this.acpSessionResponse = objectOrNull(resumed);
+                const sessionId = sessionIdFromResponse(resumed) || this.providerSessionId;
+                this.providerSessionId = sessionId;
+                lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.acpSessionResponse });
+                return sessionId;
+            }
+            catch (resumeError) {
+                try {
+                    this.emitStatus("resuming", "MimoCode 会话加载中", "session/load");
+                    const loaded = await client.loadSession({ sessionId: this.providerSessionId, cwd }, 60_000);
+                    this.acpSessionResponse = objectOrNull(loaded);
+                    const sessionId = sessionIdFromResponse(loaded) || this.providerSessionId;
+                    this.providerSessionId = sessionId;
+                    lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.acpSessionResponse });
+                    return sessionId;
+                }
+                catch {
+                    this.appendStderr(`MimoCode resume failed, creating new session: ${errorMessage(resumeError)}\n`);
+                    this.providerSessionId = null;
+                }
+            }
+        }
+        this.emitStatus("acp", "MimoCode 会话创建中", "session/new");
+        const created = await client.newSession({ cwd }, 120_000);
+        this.acpSessionResponse = objectOrNull(created);
+        const sessionId = sessionIdFromResponse(created);
+        if (!sessionId)
+            throw new Error("MimoCode ACP session/new did not return sessionId");
+        this.providerSessionId = sessionId;
+        lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.acpSessionResponse });
+        return sessionId;
+    }
+    async applyConfig(client, sessionId, input) {
+        const modelConfigId = configIdByCategory(this.acpSessionResponse, "model") || "model";
+        const modeConfigId = configIdByCategory(this.acpSessionResponse, "mode") || "mode";
+        const modelValue = selectMimoModelValue(input.model || readMimoDefaultModel(), input.configOptionValues, this.acpSessionResponse);
+        if (modelValue) {
+            await client.setSessionConfigOption({ sessionId, configId: modelConfigId, value: modelValue }, 60_000).catch((error) => {
+                this.appendStderr(`MimoCode model config failed: ${errorMessage(error)}\n`);
+            });
+        }
+        const modeValue = mimoModeValue(input.mode);
+        if (modeValue) {
+            await client.setSessionMode({ sessionId, modeId: modeValue }, 60_000).catch(async () => {
+                await client.setSessionConfigOption({ sessionId, configId: modeConfigId, value: modeValue }, 60_000).catch((error) => {
+                    this.appendStderr(`MimoCode mode config failed: ${errorMessage(error)}\n`);
+                });
+            });
+        }
+        for (const [configId, value] of Object.entries(input.configOptionValues ?? {})) {
+            if (["variant", "reasoning_effort", "effort", "model", "mode"].includes(configId))
+                continue;
+            await client.setSessionConfigOption({ sessionId, configId, value }, 60_000).catch((error) => {
+                this.appendStderr(`MimoCode config ${configId} failed: ${errorMessage(error)}\n`);
+            });
+        }
+    }
+    handleSessionUpdate(params) {
+        this.updates.push({ method: "session/update", params });
+        this.latestContextUsage = contextUsageFromAcpSessionUpdate(params, this.contextWindow) ?? this.latestContextUsage;
+        const event = eventFromAcpSessionUpdate(params);
+        if (event) {
+            if (event.type === "agent_message_chunk")
+                this.content += event.text ?? "";
+            this.updateCallback?.(event);
+        }
+        const status = statusFromAcpSessionUpdate(params);
+        if (status)
+            this.emitStatus(status.phase, status.label, status.detail, status.updateType);
+    }
+    async handleClientRequest(method, params) {
+        if (!this.canExecuteTools && (method === "fs/read_text_file" || method === "fs/write_text_file")) {
+            throw new Error(`Chat Room role policy disabled tool execution: ${method}`);
+        }
+        switch (method) {
+            case "fs/read_text_file":
+                return this.readTextFile(params);
+            case "fs/write_text_file":
+                return this.writeTextFile(params);
+            case "session/request_permission":
+                return this.requestPermission(params);
+            case "elicitation/create":
+            case "session/request_user_input":
+                return this.requestUserInput(params);
+            default:
+                throw new Error(`Unsupported ACP client request: ${method}`);
+        }
+    }
+    readTextFile(params) {
+        const filePath = resolveScopedPath(this.cwd, stringParam(params, "path") || stringParam(params, "filePath"));
+        return { content: fs.readFileSync(filePath, "utf8") };
+    }
+    writeTextFile(params) {
+        const filePath = resolveScopedPath(this.cwd, stringParam(params, "path") || stringParam(params, "filePath"));
+        const content = stringParam(params, "content") ?? stringParam(params, "text") ?? "";
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, "utf8");
+        return {};
+    }
+    async requestPermission(params) {
+        if (!this.permissionCallback)
+            return { outcome: { outcome: "cancelled" } };
+        const record = params && typeof params === "object" && !Array.isArray(params) ? params : {};
+        const rawOptions = Array.isArray(record.options) ? record.options : [];
+        const options = rawOptions.map((option, index) => {
+            const item = option && typeof option === "object" && !Array.isArray(option) ? option : {};
+            return {
+                optionId: String(item.optionId ?? item.id ?? index),
+                kind: String(item.kind ?? item.outcome ?? "choice"),
+                ...(typeof item.label === "string" ? { label: item.label } : {})
+            };
+        });
+        return this.permissionCallback({
+            requestId: String(record.requestId ?? record.id ?? `mimo-permission-${Date.now()}`),
+            params,
+            options
+        });
+    }
+    async requestUserInput(params) {
+        if (!this.userInputCallback)
+            return { outcome: { outcome: "cancelled" } };
+        const record = params && typeof params === "object" && !Array.isArray(params) ? params : {};
+        return this.userInputCallback({
+            requestId: String(record.requestId ?? record.id ?? `mimo-input-${Date.now()}`),
+            prompt: String(record.prompt ?? record.message ?? record.question ?? ""),
+            params,
+            ...(typeof record.defaultValue === "string" ? { defaultValue: record.defaultValue } : {})
+        });
+    }
+    attachAbortSignal(signal) {
+        if (!signal)
+            return;
+        this.abortHandler = () => {
+            void this.cancel();
+        };
+        if (signal.aborted)
+            throw new Error("MimoCode prompt cancelled");
+        signal.addEventListener("abort", this.abortHandler, { once: true });
+    }
+    emitStatus(phase, label, detail, updateType) {
+        const status = {
+            phase,
+            label,
+            ...(detail ? { detail } : {}),
+            ...(updateType ? { updateType } : {}),
+            atMs: Date.now()
+        };
+        const last = this.statusTimeline[this.statusTimeline.length - 1];
+        if (last && last.phase === status.phase && last.label === status.label && last.detail === status.detail && last.updateType === status.updateType)
+            return;
+        this.statusTimeline.push(status);
+        this.statusCallback?.(status);
+    }
+    requireClient() {
+        if (!this.lease)
+            throw new Error("MimoCode ACP client is not started");
+        return this.lease.client;
+    }
+    appendStderr(value) {
+        const client = this.lease?.client;
+        if (client)
+            client.rpc.stderr += value;
+    }
+    releaseLease() {
+        this.lease?.release();
+        this.lease = null;
+    }
+}
+function sessionIdFromResponse(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const sessionId = value.sessionId;
+    return typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : null;
+}
+function objectOrNull(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function positiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function configIdByCategory(response, category) {
+    const options = response?.configOptions;
+    if (!Array.isArray(options))
+        return null;
+    for (const option of options) {
+        if (!option || typeof option !== "object" || Array.isArray(option))
+            continue;
+        const record = option;
+        if (record.category === category && typeof record.id === "string" && record.id.trim())
+            return record.id.trim();
+    }
+    return null;
+}
+function selectMimoModelValue(model, values, response) {
+    const variant = firstConfigString(values?.variant, values?.reasoning_effort, values?.effort);
+    if (!variant || model.endsWith(`/${variant}`))
+        return model;
+    const candidate = `${model}/${variant}`;
+    return modelOptionExists(response, candidate) ? candidate : model;
+}
+function modelOptionExists(response, model) {
+    const options = response?.configOptions;
+    if (!Array.isArray(options))
+        return false;
+    for (const option of options) {
+        if (!option || typeof option !== "object" || Array.isArray(option))
+            continue;
+        const record = option;
+        if (record.category !== "model" || !Array.isArray(record.options))
+            continue;
+        if (record.options.some((item) => optionValue(item) === model))
+            return true;
+    }
+    return false;
+}
+function optionValue(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    for (const key of ["value", "id", "modelId", "model_id"]) {
+        const item = record[key];
+        if (typeof item === "string" && item.trim())
+            return item.trim();
+    }
+    return null;
+}
+function stringParam(params, key) {
+    if (!params || typeof params !== "object" || Array.isArray(params))
+        return null;
+    const value = params[key];
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function resolveScopedPath(root, filePath) {
+    if (!filePath)
+        throw new Error("ACP file request did not include a path");
+    const resolved = path.resolve(root, filePath);
+    const rootResolved = path.resolve(root);
+    if (resolved !== rootResolved && !resolved.startsWith(`${rootResolved}${path.sep}`)) {
+        throw new Error(`ACP file request is outside project root: ${filePath}`);
+    }
+    return resolved;
+}
+function mimoModeValue(mode) {
+    const normalized = String(mode || "").trim();
+    if (!normalized)
+        return null;
+    if (["agent", "agent-full-access", "full-access", "bypassPermissions", "danger-full-access"].includes(normalized))
+        return "build";
+    if (normalized === "read-only")
+        return "plan";
+    return normalized;
+}
+function firstConfigString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function readMimoDefaultModel() {
+    return process.env.ACA_MIMO_DEFAULT_MODEL || "mimo/mimo-auto";
+}
+/**
+ * Mimo ACP 不接受图片块中的本地 uri 字段，只接受 ACP 标准的 base64 data。
+ * 附件仍由 Job Worker 落到工作区，文本提示会保留可供工具读取的本地路径。
+ */
+function promptBlocksToMimoAcpContent(prompt, blocks) {
+    const inputBlocks = blocks?.length ? blocks : [{ type: "text", text: prompt }];
+    return inputBlocks.map((block) => {
+        if (block.type === "image") {
+            return { type: "image", data: block.data, mimeType: block.mimeType };
+        }
+        return { type: "text", text: block.text };
+    });
+}
+function readMimoPromptTimeoutMs() {
+    const parsed = Number.parseInt(process.env.ACA_MIMO_PROMPT_TIMEOUT_MS ?? process.env.ACA_ACP_PROMPT_TIMEOUT_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 30_000 ? parsed : 6 * 60 * 60 * 1000;
+}