@yuandc/aica 0.1.0

package/dist/core/heartbeat.js

@@ -0,0 +1,578 @@
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import { readJsonFile, writeJsonFile } from "./fs.js";
+import { getRuntimeStatePath } from "./paths.js";
+import { acaServerRequest } from "./aca-server-client.js";
+import { loadAcaConfig } from "./aca-config.js";
+import { providerHealthSnapshot } from "./provider-health.js";
+export const HEARTBEAT_INTERVAL_MS = 30_000;
+const MIMO_MODELS_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+const OPENCODE_MODELS_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+let mimoCapabilitiesCache = null;
+let openCodeCapabilitiesCache = null;
+export async function sendHeartbeat(config = loadAcaConfig()) {
+    if (!config.token) {
+        return { ok: false, skipped: true, reason: "not_logged_in" };
+    }
+    const response = await acaServerRequest("POST", "/api/heartbeat", {
+        machineId: config.machineId,
+        machineName: config.machineName,
+        machineInfo: {
+            platform: os.platform(),
+            architecture: os.arch(),
+            osRelease: os.release(),
+            acaVersion: acaVersion(),
+            hostname: os.hostname()
+        },
+        workspaceId: config.defaultWorkspaceId,
+        agentConfigs: buildHeartbeatAgentConfigs(config),
+        projects: config.projects.map((project) => ({
+            projectId: project.projectId,
+            workspaceId: project.workspaceId,
+            name: project.name,
+            rootPath: project.rootPath
+        }))
+    });
+    return response;
+}
+function buildHeartbeatAgentConfigs(config) {
+    const health = providerHealthSnapshot();
+    return [
+        {
+            agentId: `${config.machineId}:builtin:codex`,
+            workspaceId: config.defaultWorkspaceId,
+            name: "Codex",
+            agentType: "codex",
+            cliType: "builtin",
+            machineId: config.machineId,
+            model: "gpt-5.5",
+            mode: "agent-full-access",
+            raw: {
+                providerStatus: health.codex,
+                capabilities: codexStaticCapabilities()
+            }
+        },
+        {
+            agentId: `${config.machineId}:builtin:mimo`,
+            workspaceId: config.defaultWorkspaceId,
+            name: "MimoCode",
+            agentType: "mimo",
+            cliType: "builtin",
+            machineId: config.machineId,
+            model: "mimo/mimo-auto",
+            mode: "agent-full-access",
+            raw: {
+                providerStatus: health.mimo,
+                capabilities: mimoCapabilities()
+            }
+        },
+        {
+            agentId: `${config.machineId}:builtin:opencode`,
+            workspaceId: config.defaultWorkspaceId,
+            name: "OpenCode",
+            agentType: "opencode",
+            cliType: "builtin",
+            machineId: config.machineId,
+            // The server schema accepts an omitted/null model, but intentionally
+            // rejects an empty string. A worker can run without OpenCode configured.
+            model: process.env.ACA_OPENCODE_DEFAULT_MODEL || null,
+            mode: "agent-full-access",
+            raw: {
+                providerStatus: health.opencode,
+                capabilities: openCodeCapabilities()
+            }
+        }
+    ];
+}
+function acaVersion() {
+    return process.env.ACA_VERSION?.trim() || "0.1.0";
+}
+function codexStaticCapabilities() {
+    const modes = [
+        { id: "read-only", name: "Read-only", description: "Requires approval to edit files and run commands." },
+        { id: "agent", name: "Agent", description: "Read and edit files, and run commands." },
+        { id: "agent-full-access", name: "Agent (full access)", description: "Edit files and run commands with full access." }
+    ];
+    const models = [
+        { modelId: "gpt-5.5", name: "gpt-5.5", description: "Latest frontier Codex model" },
+        { modelId: "gpt-5.4", name: "gpt-5.4", description: "Frontier Codex model" },
+        { modelId: "gpt-5.4-mini", name: "gpt-5.4-mini", description: "Smaller, faster Codex model" }
+    ];
+    const reasoningOptions = [
+        { value: "low", name: "Low", description: "Fastest responses" },
+        { value: "medium", name: "Medium", description: "Balanced reasoning" },
+        { value: "high", name: "High", description: "More reasoning for difficult tasks" },
+        { value: "xhigh", name: "X High", description: "Extra reasoning for complex tasks" }
+    ];
+    return {
+        source: "aca-static",
+        fetchedAt: Date.now(),
+        contextUsage: true,
+        contextCompaction: true,
+        modes,
+        models,
+        configOptions: [
+            {
+                id: "mode",
+                name: "Mode",
+                category: "mode",
+                type: "select",
+                currentValue: "agent-full-access",
+                options: modes.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description }))
+            },
+            {
+                id: "model",
+                name: "Model",
+                category: "model",
+                type: "select",
+                currentValue: "gpt-5.5",
+                options: models.map((model) => ({ value: model.modelId, name: model.name, description: model.description }))
+            },
+            {
+                id: "reasoning_effort",
+                name: "Reasoning effort",
+                category: "thought_level",
+                type: "select",
+                currentValue: "medium",
+                options: reasoningOptions
+            }
+        ]
+    };
+}
+function mimoStaticCapabilities() {
+    const modes = [
+        { id: "agent", name: "Agent", description: "Run MimoCode with normal workspace permissions." },
+        { id: "agent-full-access", name: "Agent (full access)", description: "Run MimoCode and auto-approve supported local permissions." }
+    ];
+    const models = [
+        { modelId: "mimo/mimo-auto", name: "MiMo Auto (free)", description: "MiMo Auto free model" },
+        { modelId: "xiaomi/mimo-v2.5", name: "mimo-v2.5", description: "MimoCode v2.5" },
+        { modelId: "xiaomi/mimo-v2.5-pro", name: "mimo-v2.5-pro", description: "MimoCode v2.5 Pro" },
+        { modelId: "xiaomi/mimo-v2.5-pro-ultraspeed", name: "mimo-v2.5-pro-ultraspeed", description: "MimoCode v2.5 Pro UltraSpeed" }
+    ];
+    const variants = [
+        { value: "minimal", name: "Minimal", description: "Fastest responses" },
+        { value: "high", name: "High", description: "More reasoning for difficult tasks" },
+        { value: "max", name: "Max", description: "Maximum reasoning when supported" }
+    ];
+    return {
+        source: "aca-static",
+        fetchedAt: Date.now(),
+        contextUsage: true,
+        contextCompaction: false,
+        modes,
+        models,
+        configOptions: [
+            {
+                id: "mode",
+                name: "Mode",
+                category: "mode",
+                type: "select",
+                currentValue: "agent-full-access",
+                options: modes.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description }))
+            },
+            {
+                id: "model",
+                name: "Model",
+                category: "model",
+                type: "select",
+                currentValue: "mimo/mimo-auto",
+                options: models.map((model) => ({ value: model.modelId, name: model.name, description: model.description }))
+            },
+            {
+                id: "variant",
+                name: "Variant",
+                category: "thought_level",
+                type: "select",
+                currentValue: "high",
+                options: variants
+            }
+        ]
+    };
+}
+function mimoCapabilities() {
+    const now = Date.now();
+    if (mimoCapabilitiesCache && mimoCapabilitiesCache.expiresAtMs > now) {
+        return mimoCapabilitiesCache.capabilities;
+    }
+    const capabilities = mimoCapabilitiesFromCli() ?? mimoStaticCapabilities();
+    mimoCapabilitiesCache = {
+        expiresAtMs: now + MIMO_MODELS_CACHE_TTL_MS,
+        capabilities
+    };
+    return capabilities;
+}
+function openCodeStaticCapabilities() {
+    const modes = [
+        { id: "plan", name: "Plan", description: "Inspect the project and propose changes." },
+        { id: "build", name: "Build", description: "Read and edit files, and run commands when approved." },
+        { id: "agent-full-access", name: "Agent (full access)", description: "Run OpenCode with ACA full-access mode mapping." }
+    ];
+    const models = [
+        { modelId: "", name: "Default", description: "Use the model selected by OpenCode configuration." }
+    ];
+    return {
+        source: "aca-static",
+        fetchedAt: Date.now(),
+        contextUsage: true,
+        contextCompaction: false,
+        modes,
+        models,
+        configOptions: [
+            {
+                id: "mode",
+                name: "Mode",
+                category: "mode",
+                type: "select",
+                currentValue: "agent-full-access",
+                options: modes.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description }))
+            },
+            {
+                id: "model",
+                name: "Model",
+                category: "model",
+                type: "text",
+                currentValue: process.env.ACA_OPENCODE_DEFAULT_MODEL || "",
+                options: models.map((model) => ({ value: model.modelId, name: model.name, description: model.description }))
+            }
+        ]
+    };
+}
+function openCodeCapabilities() {
+    const now = Date.now();
+    if (openCodeCapabilitiesCache && openCodeCapabilitiesCache.expiresAtMs > now) {
+        return openCodeCapabilitiesCache.capabilities;
+    }
+    const capabilities = openCodeCapabilitiesFromCli() ?? openCodeStaticCapabilities();
+    openCodeCapabilitiesCache = {
+        expiresAtMs: now + OPENCODE_MODELS_CACHE_TTL_MS,
+        capabilities
+    };
+    return capabilities;
+}
+function openCodeCapabilitiesFromCli() {
+    try {
+        const command = process.env.ACA_OPENCODE_COMMAND || "opencode";
+        const output = execFileSync(command, ["models", "--verbose"], {
+            encoding: "utf8",
+            timeout: 15_000,
+            maxBuffer: 8 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        const models = parseOpenCodeVerboseModels(output);
+        if (!models.length)
+            return null;
+        const modes = [
+            { id: "plan", name: "Plan", description: "Inspect the project and propose changes." },
+            { id: "build", name: "Build", description: "Read and edit files, and run commands when approved." },
+            { id: "agent-full-access", name: "Agent (full access)", description: "Run OpenCode with ACA full-access mode mapping." }
+        ];
+        const defaultModel = openCodeDefaultModel(models);
+        return {
+            source: "opencode-cli",
+            fetchedAt: Date.now(),
+            contextUsage: true,
+            contextCompaction: false,
+            modes,
+            models: models.map((model) => ({
+                modelId: model.modelId,
+                name: model.displayName,
+                description: model.description,
+                metadata: model.metadata
+            })),
+            configOptions: [
+                {
+                    id: "mode",
+                    name: "Mode",
+                    category: "mode",
+                    type: "select",
+                    currentValue: "agent-full-access",
+                    options: modes.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description }))
+                },
+                {
+                    id: "model",
+                    name: "Model",
+                    category: "model",
+                    type: "select",
+                    currentValue: defaultModel,
+                    options: models.map((model) => ({ value: model.modelId, name: model.displayName, description: model.description }))
+                }
+            ]
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseOpenCodeVerboseModels(output) {
+    const lines = output.split(/\r?\n/);
+    const models = [];
+    let index = 0;
+    while (index < lines.length) {
+        const modelId = lines[index]?.trim() ?? "";
+        index += 1;
+        if (!/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(modelId))
+            continue;
+        const jsonLines = [];
+        let depth = 0;
+        let started = false;
+        while (index < lines.length) {
+            const line = lines[index] ?? "";
+            index += 1;
+            if (!started && !line.trim().startsWith("{"))
+                continue;
+            started = true;
+            jsonLines.push(line);
+            depth += countChar(line, "{") - countChar(line, "}");
+            if (started && depth <= 0)
+                break;
+        }
+        const metadata = parseJsonObject(jsonLines.join("\n"));
+        if (!metadata)
+            continue;
+        const rawName = firstString(metadata.name, metadata.id, modelId) ?? modelId;
+        models.push({
+            modelId,
+            displayName: formatOpenCodeModelName(rawName, metadata),
+            description: openCodeModelDescription(metadata),
+            metadata
+        });
+    }
+    return models;
+}
+function openCodeDefaultModel(models) {
+    const configured = process.env.ACA_OPENCODE_DEFAULT_MODEL?.trim();
+    if (configured && models.some((model) => model.modelId === configured))
+        return configured;
+    return models.find((model) => model.modelId === "opencode/big-pickle")?.modelId
+        || models.find((model) => /free$/i.test(model.modelId))?.modelId
+        || models[0]?.modelId
+        || "";
+}
+function formatOpenCodeModelName(name, metadata) {
+    if (isFreeOpenCodeModel(metadata) && !/\bfree\b/i.test(name))
+        return `${name} (free)`;
+    return name;
+}
+function isFreeOpenCodeModel(metadata) {
+    const cost = metadata.cost;
+    if (!cost || typeof cost !== "object" || Array.isArray(cost))
+        return false;
+    const record = cost;
+    const cache = record.cache && typeof record.cache === "object" && !Array.isArray(record.cache) ? record.cache : {};
+    return [record.input, record.output, cache.read, cache.write].every((value) => Number(value ?? 0) === 0);
+}
+function openCodeModelDescription(metadata) {
+    const limit = metadata.limit && typeof metadata.limit === "object" && !Array.isArray(metadata.limit) ? metadata.limit : {};
+    const context = Number(limit.context ?? 0);
+    const output = Number(limit.output ?? 0);
+    if (context > 0 && output > 0)
+        return `Context ${context}, output ${output}`;
+    if (context > 0)
+        return `Context ${context}`;
+    return "OpenCode model";
+}
+function mimoCapabilitiesFromCli() {
+    try {
+        const command = process.env.ACA_MIMO_COMMAND || "mimo";
+        const output = execFileSync(command, ["models", "--verbose"], {
+            encoding: "utf8",
+            timeout: 15_000,
+            maxBuffer: 2 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        const models = parseMimoVerboseModels(output);
+        if (!models.length)
+            return null;
+        const modes = [
+            { id: "agent", name: "Agent", description: "Run MimoCode with normal workspace permissions." },
+            { id: "agent-full-access", name: "Agent (full access)", description: "Run MimoCode and auto-approve supported local permissions." }
+        ];
+        const variants = collectMimoVariants(models);
+        return {
+            source: "mimo-cli",
+            fetchedAt: Date.now(),
+            contextUsage: true,
+            contextCompaction: false,
+            modes,
+            models: models.map((model) => ({
+                modelId: model.modelId,
+                name: model.displayName,
+                description: model.description,
+                metadata: model.metadata
+            })),
+            configOptions: [
+                {
+                    id: "mode",
+                    name: "Mode",
+                    category: "mode",
+                    type: "select",
+                    currentValue: "agent-full-access",
+                    options: modes.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description }))
+                },
+                {
+                    id: "model",
+                    name: "Model",
+                    category: "model",
+                    type: "select",
+                    currentValue: models.some((model) => model.modelId === "mimo/mimo-auto") ? "mimo/mimo-auto" : models[0]?.modelId,
+                    options: models.map((model) => ({ value: model.modelId, name: model.displayName, description: model.description }))
+                },
+                {
+                    id: "variant",
+                    name: "Variant",
+                    category: "thought_level",
+                    type: "select",
+                    currentValue: variants.some((variant) => variant.value === "high") ? "high" : variants[0]?.value,
+                    options: variants
+                }
+            ]
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseMimoVerboseModels(output) {
+    const lines = output.split(/\r?\n/);
+    const models = [];
+    let index = 0;
+    while (index < lines.length) {
+        const modelId = lines[index]?.trim() ?? "";
+        index += 1;
+        if (!/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(modelId))
+            continue;
+        const jsonLines = [];
+        let depth = 0;
+        let started = false;
+        while (index < lines.length) {
+            const line = lines[index] ?? "";
+            index += 1;
+            if (!started && !line.trim().startsWith("{"))
+                continue;
+            started = true;
+            jsonLines.push(line);
+            depth += countChar(line, "{") - countChar(line, "}");
+            if (started && depth <= 0)
+                break;
+        }
+        const metadata = parseJsonObject(jsonLines.join("\n"));
+        if (!metadata)
+            continue;
+        const rawName = firstString(metadata.name, metadata.id, modelId) ?? modelId;
+        models.push({
+            modelId,
+            displayName: formatMimoModelName(rawName, metadata),
+            description: mimoModelDescription(metadata),
+            metadata
+        });
+    }
+    return models;
+}
+function collectMimoVariants(models) {
+    const values = new Set();
+    for (const model of models) {
+        const variants = model.metadata.variants;
+        if (!variants || typeof variants !== "object" || Array.isArray(variants))
+            continue;
+        for (const value of Object.keys(variants))
+            values.add(value);
+    }
+    const ordered = ["minimal", "low", "medium", "high", "max"].filter((value) => values.has(value));
+    const finalValues = ordered.length ? ordered : ["minimal", "high", "max"];
+    return finalValues.map((value) => ({
+        value,
+        name: titleCase(value),
+        description: value === "high" ? "More reasoning for difficult tasks" : value === "max" ? "Maximum reasoning when supported" : "Fastest responses"
+    }));
+}
+function formatMimoModelName(name, metadata) {
+    if (isFreeMimoModel(metadata) && !/\bfree\b/i.test(name))
+        return `${name} (free)`;
+    return name;
+}
+function isFreeMimoModel(metadata) {
+    const cost = metadata.cost;
+    if (!cost || typeof cost !== "object" || Array.isArray(cost))
+        return false;
+    const record = cost;
+    const cache = record.cache && typeof record.cache === "object" && !Array.isArray(record.cache) ? record.cache : {};
+    return [record.input, record.output, cache.read, cache.write].every((value) => Number(value ?? 0) === 0);
+}
+function mimoModelDescription(metadata) {
+    const limit = metadata.limit && typeof metadata.limit === "object" && !Array.isArray(metadata.limit) ? metadata.limit : {};
+    const context = Number(limit.context ?? 0);
+    return context > 0 ? `Context ${context}` : "MimoCode model";
+}
+function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function titleCase(value) {
+    return value.slice(0, 1).toUpperCase() + value.slice(1);
+}
+function countChar(value, char) {
+    let count = 0;
+    for (const current of value) {
+        if (current === char)
+            count += 1;
+    }
+    return count;
+}
+export function startHeartbeatLoop(logger) {
+    const tick = async () => {
+        const sentAt = new Date().toISOString();
+        try {
+            const result = await sendHeartbeat();
+            if (result.skipped) {
+                updateRuntimeHeartbeat({
+                    lastHeartbeatAt: sentAt,
+                    lastHeartbeatStatus: "skipped",
+                    lastHeartbeatReason: result.reason ?? "unknown"
+                });
+                logger.debug(`heartbeat skipped: ${result.reason ?? "unknown"}`);
+                return;
+            }
+            updateRuntimeHeartbeat({
+                lastHeartbeatAt: sentAt,
+                lastHeartbeatStatus: "ok",
+                lastHeartbeatProjectCount: result.projectCount ?? null,
+                presenceExpiresAtMs: result.presenceExpiresAtMs ?? null
+            });
+            logger.debug(`heartbeat ok projects=${result.projectCount ?? 0}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            updateRuntimeHeartbeat({
+                lastHeartbeatAt: sentAt,
+                lastHeartbeatStatus: "error",
+                lastHeartbeatError: message
+            });
+            logger.warn(`heartbeat failed: ${message}`);
+        }
+    };
+    void tick();
+    return setInterval(() => {
+        void tick();
+    }, HEARTBEAT_INTERVAL_MS);
+}
+function updateRuntimeHeartbeat(patch) {
+    const current = readJsonFile(getRuntimeStatePath()) ?? {};
+    writeJsonFile(getRuntimeStatePath(), {
+        ...current,
+        heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+        ...patch
+    });
+}

package/dist/core/job-permission-policy.js

@@ -0,0 +1,42 @@
+export function resolveJobPermissionPolicy(input, request) {
+    const profile = asRecord(input.permissionProfile);
+    const mode = input.canExecuteTools === false
+        ? "deny"
+        : normalizeMode(profile.mode ?? profile.permissionMode ?? profile.toolMode);
+    if (mode === "ask")
+        return null;
+    const explicitOptionId = mode === "allow"
+        ? firstString(profile.allowOptionId, profile.allow_option_id)
+        : firstString(profile.denyOptionId, profile.deny_option_id);
+    const option = explicitOptionId
+        ? request.options.find((item) => item.optionId === explicitOptionId)
+        : request.options.find((item) => optionMatchesMode(item, mode));
+    if (option)
+        return { outcome: { outcome: "selected", optionId: option.optionId } };
+    // Provider 没有提供可明确识别的选项时保持保守，避免误把拒绝项当成允许项。
+    return { outcome: { outcome: "cancelled" } };
+}
+function normalizeMode(value) {
+    const mode = String(value || "ask").trim().toLowerCase();
+    if (["allow", "approve", "auto_allow", "auto-allow"].includes(mode))
+        return "allow";
+    if (["deny", "reject", "disabled", "forbid"].includes(mode))
+        return "deny";
+    return "ask";
+}
+function optionMatchesMode(option, mode) {
+    const text = `${option.optionId} ${option.kind} ${option.label || ""}`.toLowerCase();
+    return mode === "allow"
+        ? /(^|[^a-z])(allow|accept|approve|yes)([^a-z]|$)/.test(text)
+        : /(^|[^a-z])(deny|reject|decline|cancel|no)([^a-z]|$)/.test(text);
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return null;
+}