openmausbot 0.1.55

package/dist-server/server/drivers/acp/opencode-go.js

@@ -0,0 +1,370 @@
+// The maintained OpenCode CLI through its ACP stdio interface. OpenCode is
+// the harness; Zen, Go, OpenRouter, and user-configured/local providers are
+// models discovered from that harness rather than separate OpenMaus drivers.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
+import { createAcpDriver } from "./core.js";
+import { execCli } from "../../procs.js";
+const STATIC_MODELS = {
+    default: "opencode/x-preview-f-free",
+    options: [
+        {
+            id: "opencode/x-preview-f-free",
+            label: "Zen · Ox Alpha Free",
+            contextWindow: 1_000_000,
+        },
+    ],
+};
+let lastSuccessfulCatalog = null;
+const MODEL_PROBE_TTL_MS = 30_000;
+const modelProbeCache = new Map();
+function labelForModel(id) {
+    return id
+        .split(/[-_.]+/g)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function providerLabel(id) {
+    if (id === "opencode")
+        return "Zen";
+    if (id === "opencode-go")
+        return "Go";
+    if (id === "openrouter")
+        return "OpenRouter";
+    return labelForModel(id);
+}
+function validModelSlug(value) {
+    const separator = value.indexOf("/");
+    if (separator <= 0 || separator >= value.length - 1 || /\s/u.test(value))
+        return false;
+    return [...value].every((character) => (character.codePointAt(0) ?? 0) > 0x1f);
+}
+function localModelRecord(record) {
+    const api = record.api && typeof record.api === "object" && !Array.isArray(record.api)
+        ? record.api
+        : {};
+    if (typeof api.url !== "string")
+        return false;
+    try {
+        const host = new URL(api.url).hostname.replace(/^\[|\]$/gu, "");
+        return host === "localhost" || host === "127.0.0.1" || host === "::1";
+    }
+    catch {
+        return false;
+    }
+}
+/** Parse the authoritative inventory printed by the installed OpenCode CLI.
+ *
+ * `models --verbose` is a sequence of `provider/model` header lines followed
+ * by one JSON object. Model IDs can themselves contain `/` (OpenRouter), so
+ * only the first separator identifies the provider. Older CLIs may print just
+ * the headers; those still produce a usable catalog without metadata. */
+export function parseOpenCodeModelsOutput(stdout) {
+    const options = [];
+    const seen = new Set();
+    let slug = null;
+    let jsonLines = [];
+    const flush = () => {
+        if (!slug || seen.has(slug))
+            return;
+        const separator = slug.indexOf("/");
+        const provider = slug.slice(0, separator);
+        const model = slug.slice(separator + 1);
+        let record = {};
+        const raw = jsonLines.join("\n").trim();
+        if (raw) {
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    record = parsed;
+                }
+            }
+            catch {
+                // A header-only/older CLI remains useful; fall back to the model id.
+            }
+        }
+        if (record.status === "deprecated")
+            return;
+        const name = typeof record.name === "string" && record.name.trim()
+            ? record.name.trim()
+            : labelForModel(model);
+        const limit = record.limit && typeof record.limit === "object" && !Array.isArray(record.limit)
+            ? record.limit
+            : {};
+        const contextWindow = typeof limit.context === "number" && Number.isFinite(limit.context) && limit.context > 0
+            ? Math.floor(limit.context)
+            : undefined;
+        seen.add(slug);
+        options.push({
+            id: slug,
+            label: `${providerLabel(provider)} · ${name}`,
+            ...(localModelRecord(record) ? { custom: true, loaded: true } : {}),
+            ...(contextWindow ? { contextWindow } : {}),
+        });
+    };
+    for (const line of stdout.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (line === trimmed && validModelSlug(trimmed)) {
+            flush();
+            slug = trimmed;
+            jsonLines = [];
+            continue;
+        }
+        if (slug)
+            jsonLines.push(line);
+    }
+    flush();
+    if (!options.length)
+        return null;
+    const preferred = options.find((option) => option.id === STATIC_MODELS.default);
+    return { default: (preferred ?? options[0]).id, options };
+}
+function runOpenCodeModels(cli, environment, verbose) {
+    return new Promise((resolve, reject) => {
+        execCli(cli, ["models", ...(verbose ? ["--verbose"] : [])], { timeout: 20_000, maxBuffer: 8 * 1024 * 1024, env: environment }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(stderr?.trim() || error.message, { cause: error }));
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+/** Ask the same OpenCode binary that will run ACP for its effective catalog.
+ * This automatically includes Zen, Go, other connected providers, custom
+ * config, and anonymous free models with the exact IDs the session accepts. */
+export async function discoverOpenCodeModels(environment, cli = "opencode") {
+    try {
+        const catalog = parseOpenCodeModelsOutput(await runOpenCodeModels(cli, environment, true));
+        if (!catalog)
+            throw new Error("OpenCode returned no usable models");
+        lastSuccessfulCatalog = catalog;
+        return catalog;
+    }
+    catch {
+        return lastSuccessfulCatalog ?? STATIC_MODELS;
+    }
+}
+export function resetOpenCodeModelCache() {
+    lastSuccessfulCatalog = null;
+    modelProbeCache.clear();
+}
+/** Compatibility export for older tests/imports while the product migrates
+ * from the Go-only name. */
+export const resetOpenCodeGoModelCache = resetOpenCodeModelCache;
+const stripForeignProviderKeys = (env) => {
+    for (const key of [
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "XAI_API_KEY",
+        "KIMI_API_KEY",
+        "MOONSHOT_API_KEY",
+    ])
+        delete env[key];
+};
+function opencodeConfigDir(env) {
+    const home = env.HOME || env.USERPROFILE || homedir();
+    return join(env.XDG_CONFIG_HOME || join(home, ".config"), "opencode");
+}
+/** Upsert an openai-compatible provider so OpenCode can select host/model. */
+export function ensureOpenCodeInjectModel(modelId, env = process.env) {
+    const inject = decodeInjectId(modelId);
+    if (!inject)
+        return modelId;
+    const host = localHost(inject.host);
+    if (!host)
+        return modelId;
+    const native = `${inject.host}/${inject.model}`;
+    const dir = opencodeConfigDir(env);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "opencode.json");
+    let config = { $schema: "https://opencode.ai/config.json" };
+    if (existsSync(path)) {
+        try {
+            config = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch {
+            // Malformed user config — inject into a fresh object rather than fail the turn.
+        }
+    }
+    const providers = config.provider && typeof config.provider === "object" && !Array.isArray(config.provider)
+        ? { ...config.provider }
+        : {};
+    const previous = providers[inject.host];
+    const existing = previous && typeof previous === "object" && !Array.isArray(previous)
+        ? { ...previous }
+        : {
+            npm: "@ai-sdk/openai-compatible",
+            name: host.label,
+            options: {},
+            models: {},
+        };
+    const options = existing.options && typeof existing.options === "object" && !Array.isArray(existing.options)
+        ? { ...existing.options }
+        : {};
+    options.baseURL = host.baseUrl;
+    if (!options.apiKey)
+        options.apiKey = hostApiKey(host, env);
+    const models = existing.models && typeof existing.models === "object" && !Array.isArray(existing.models)
+        ? { ...existing.models }
+        : {};
+    if (!models[inject.model]) {
+        models[inject.model] = { name: `${inject.model} (${host.label})` };
+    }
+    providers[inject.host] = {
+        ...existing,
+        npm: existing.npm || "@ai-sdk/openai-compatible",
+        name: existing.name || host.label,
+        options,
+        models,
+    };
+    config.provider = providers;
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
+    return native;
+}
+/** Every path the OpenCode CLI may keep auth.json at.
+ *
+ * The CLI is xdg-flavoured on EVERY platform — `opencode auth list` on macOS
+ * prints `~/.local/share/opencode/auth.json`, and that is where real logins
+ * land. The platform-conventional locations are kept as fallbacks in case a
+ * future CLI moves there, but the xdg path must come first: checking only
+ * Library/Application Support on macOS is exactly the bug that made the app
+ * demand a sign-in from users who were already signed in. */
+function storedAuthPaths(env) {
+    const home = env.HOME || env.USERPROFILE || homedir();
+    const roots = [
+        env.XDG_DATA_HOME || join(home, ".local", "share"),
+        process.platform === "darwin"
+            ? join(home, "Library", "Application Support")
+            : process.platform === "win32"
+                ? env.LOCALAPPDATA || join(home, "AppData", "Local")
+                : "",
+    ].filter(Boolean);
+    return [...new Set(roots)].map((root) => join(root, "opencode", "auth.json"));
+}
+/** True when auth.json contains any usable provider login managed by
+ * OpenCode. The generic harness can run all of them, including `opencode`
+ * (Zen), `opencode-go`, and third-party providers such as OpenRouter. */
+function usableAuthEntry(parsed) {
+    return Object.values(parsed).some((auth) => {
+        if (!auth || typeof auth !== "object" || Array.isArray(auth))
+            return false;
+        const entry = auth;
+        return Boolean(entry.key || entry.access || entry.refresh);
+    });
+}
+function hasStoredOpenCodeAuth(env) {
+    const candidates = [];
+    if (env.OPENCODE_AUTH_CONTENT)
+        candidates.push(env.OPENCODE_AUTH_CONTENT);
+    for (const path of storedAuthPaths(env)) {
+        try {
+            candidates.push(readFileSync(path, "utf8"));
+        }
+        catch {
+            // A missing or unreadable file simply means there is no ambient login.
+        }
+    }
+    return candidates.some((raw) => {
+        try {
+            return usableAuthEntry(JSON.parse(raw));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export async function canListOpenCodeModels(env, cli, runModels = runOpenCodeModels) {
+    const cached = modelProbeCache.get(cli);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.result;
+    const entry = {
+        expiresAt: Number.POSITIVE_INFINITY,
+        result: Promise.resolve(false),
+    };
+    entry.result = runModels(cli, env, false)
+        .then((stdout) => stdout
+        .split(/\r?\n/u)
+        .some((line) => validModelSlug(line.trim())))
+        .catch(() => false)
+        .finally(() => {
+        entry.expiresAt = Date.now() + MODEL_PROBE_TTL_MS;
+    });
+    modelProbeCache.set(cli, entry);
+    return entry.result;
+}
+/** Migrate the model name published during Ox Alpha's first preview. The
+ * current CLI calls the same model `x-preview-f-free`; prefer Go for an old
+ * Go bot with an explicit key, otherwise use Zen's anonymous/free route. */
+export function normalizeLegacyOpenCodeModel(model, env) {
+    if (model !== "opencode-go/ox-alpha-free")
+        return model;
+    return env.OPENCODE_API_KEY
+        ? "opencode-go/x-preview-f-free"
+        : "opencode/x-preview-f-free";
+}
+const support = (loadCatalog) => ({
+    driverKind: "opencodeGo",
+    // Keep the historical driver kind so existing bots and instance config do
+    // not break; only the product name/catalog expand from Go to OpenCode.
+    displayName: "OpenCode",
+    models: STATIC_MODELS,
+    defaultCli: "opencode",
+    nativeSource: "opencode.acp",
+    loginNote: "OpenCode has no usable models — run `opencode auth login` or connect a provider in the OpenCode app",
+    install: {
+        command: {
+            darwin: "npm install -g opencode-ai",
+            linux: "npm install -g opencode-ai",
+            win32: "npm install -g opencode-ai",
+        },
+        docsUrl: "https://opencode.ai/docs/",
+        signInCommand: "opencode auth login",
+        needsNode: true,
+    },
+    spawnArgs: () => ["acp"],
+    credentialEnv: ["OPENCODE_API_KEY"],
+    selectModel: { configId: "model" },
+    resolveTurnModel: (model, env) => model
+        ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model, env), env)
+        : model,
+    transformEnv: stripForeignProviderKeys,
+    pickAuthMethod: () => null,
+    authFailure: "continue",
+    isAuthenticated: async (env, config) => (Boolean(env.OPENCODE_API_KEY)
+        || hasStoredOpenCodeAuth(env)
+        || await canListOpenCodeModels(env, config.cli)),
+    requireAuthenticationBeforeSpawn: true,
+    classifyError: classifyOpenCodeError,
+    resolveModels: async (environment, config) => mergeLocalInject(await loadCatalog(environment, config.cli), environment),
+    buildPromptText: (turn) => turn.system ? `${turn.system}\n\n${turn.text}` : turn.text,
+});
+export function classifyOpenCodeError(error) {
+    const value = error && typeof error === "object" ? error : {};
+    const code = value.code;
+    if (code === -32000)
+        return "invalid_credentials";
+    if (code === "AUTH_REQUIRED" || code === "INVALID_API_KEY" || code === "UNAUTHORIZED")
+        return "invalid_credentials";
+    if (code === "SUBSCRIPTION_INACTIVE")
+        return "inactive_subscription";
+    if (code === "QUOTA_EXCEEDED" || code === "REGION_RESTRICTED")
+        return "quota_or_region_restriction";
+    if (code === "UPSTREAM_UNAVAILABLE" || code === "SERVICE_UNAVAILABLE")
+        return "upstream_outage";
+    if (code === "MODEL_CATALOG_UNAVAILABLE")
+        return "model_catalog_outage";
+    return undefined;
+}
+export const classifyOpenCodeGoError = classifyOpenCodeError;
+export function createOpenCodeDriver(loadCatalog = discoverOpenCodeModels) {
+    return createAcpDriver(support(loadCatalog));
+}
+export const createOpenCodeGoDriver = createOpenCodeDriver;
+export const OpenCodeDriver = createOpenCodeDriver();
+export const OpenCodeGoDriver = OpenCodeDriver;

package/dist-server/server/drivers/acp/qwen.js

@@ -0,0 +1,98 @@
+// Qwen Code — Alibaba's `qwen --acp` CLI. Custom-only in OpenMausBot:
+// the official pane has no Qwen Cloud catalog; live local hosts land in
+// Custom and are written into ~/.qwen/settings.json modelProviders.
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
+import { createAcpDriver } from "./core.js";
+const EMPTY = { default: "", options: [] };
+function qwenHome(env) {
+    return join(env.HOME || env.USERPROFILE || homedir(), ".qwen");
+}
+function envKeyFor(hostId) {
+    return `OPENMAUSBOT_QWEN_${hostId.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
+}
+/** Upsert an OpenAI-compatible provider row so `qwen -m` can reach the host. */
+export function ensureQwenInjectModel(modelId, env = process.env) {
+    const inject = decodeInjectId(modelId);
+    if (!inject)
+        return modelId;
+    const host = localHost(inject.host);
+    if (!host)
+        return modelId;
+    const dir = qwenHome(env);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "settings.json");
+    let settings = {};
+    if (existsSync(path)) {
+        try {
+            settings = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch {
+            // Malformed user config — inject into a fresh object rather than fail the turn.
+        }
+    }
+    const keyName = envKeyFor(inject.host);
+    const key = hostApiKey(host, env);
+    const envMap = settings.env && typeof settings.env === "object" && !Array.isArray(settings.env)
+        ? { ...settings.env }
+        : {};
+    envMap[keyName] = key;
+    settings.env = envMap;
+    const providers = settings.modelProviders && typeof settings.modelProviders === "object" && !Array.isArray(settings.modelProviders)
+        ? { ...settings.modelProviders }
+        : {};
+    const openai = Array.isArray(providers.openai) ? [...providers.openai] : [];
+    const match = openai.find((row) => row &&
+        typeof row === "object" &&
+        row.id === inject.model &&
+        row.baseUrl === host.baseUrl);
+    if (!match) {
+        openai.push({
+            id: inject.model,
+            name: `${inject.model} (${host.label})`,
+            baseUrl: host.baseUrl,
+            envKey: keyName,
+        });
+        providers.openai = openai;
+        settings.modelProviders = providers;
+    }
+    writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Windows ignores POSIX modes; keep the inject even if chmod is unsupported.
+    }
+    return inject.model;
+}
+async function resolveModels(env) {
+    const catalog = await mergeLocalInject(EMPTY, env);
+    return { default: catalog.options[0]?.id ?? "", options: catalog.options };
+}
+const support = {
+    driverKind: "qwenAgent",
+    displayName: "Qwen",
+    access: "custom",
+    models: EMPTY,
+    resolveModels,
+    resolveTurnModel: (model, env) => (model ? ensureQwenInjectModel(model, env) : model),
+    defaultCli: "qwen",
+    nativeSource: "qwen.acp",
+    loginNote: "Qwen Code CLI is not installed",
+    install: {
+        command: {
+            darwin: "curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh | bash",
+            linux: "curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh | bash",
+            win32: "irm https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1 | iex",
+        },
+        docsUrl: "https://qwenlm.github.io/qwen-code-docs/en/users/overview/",
+    },
+    spawnArgs: (_config, turn) => ["--acp", ...(turn.model ? ["-m", turn.model] : [])],
+    pickAuthMethod: () => null,
+    authFailure: "continue",
+    isAuthenticated: () => true,
+    buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+};
+export const QwenAgentDriver = createAcpDriver(support);