min-agent 0.2.1 → 0.4.0

package/dist/serve/routes-meta.js

@@ -0,0 +1,205 @@
+import { fetchModels, getActiveProvider, getEffectiveConfig, getBudgetSnapshot, setBudgetMaxCost, setSandboxConfig, setPermissionMode, parsePermissionMode, } from "../config.js";
+import { parseNetworkPolicy, parseSandboxMode } from "../sandbox.js";
+import { readMemoryScope } from "../memory.js";
+import { getWorkingTreeDiff } from "../tui/diff-view.js";
+import { scanProject } from "../code-mode.js";
+import { getContextWindowInfo } from "../context-window.js";
+import { getModelPrice, estimateCost } from "../pricing.js";
+import { checkForUpdate } from "../updater.js";
+import { sendJson, sendJsonError, readJsonBody, readStringPathList, sandboxPayload, permissionPayload, } from "./common.js";
+export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
+    if (req.method === "GET" && pathname === "/health") {
+        sendJson(res, 200, { ok: true, service: "min-agent", version: ctx.version });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/meta") {
+        sendJson(res, 200, {
+            version: ctx.version,
+            cwd: process.cwd(),
+            instructions_chars: ctx.instructions.join("\n").length,
+            sandbox: sandboxPayload(),
+            permission: permissionPayload(),
+        });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/update") {
+        const check = await checkForUpdate({ currentVersion: ctx.version });
+        sendJson(res, 200, {
+            current: check.current,
+            latest: check.latest,
+            update_available: check.updateAvailable,
+            ...(check.latest === null ? { error: "registry_unavailable" } : {}),
+        });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/models") {
+        const config = getEffectiveConfig();
+        const provider = getActiveProvider(config);
+        const base = provider?.baseURL;
+        const key = provider?.apiKey;
+        if (!base || !key) {
+            sendJson(res, 500, { error: "provider_not_configured" });
+            return true;
+        }
+        const models = await fetchModels(base, key);
+        sendJson(res, 200, {
+            default_model: provider?.defaultModel ?? null,
+            models,
+        });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/budget") {
+        const snap = getBudgetSnapshot();
+        sendJson(res, 200, { maxCostUSD: snap.maxCostUSD ?? null, source: snap.source });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/budget") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const n = parsed.value.maxCostUSD;
+        if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) {
+            sendJson(res, 400, { error: "invalid_max_cost", detail: "maxCostUSD must be a positive number" });
+            return true;
+        }
+        const scopeParsed = readMemoryScope(parsed.value.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        setBudgetMaxCost(n, scope);
+        const snap = getBudgetSnapshot();
+        sendJson(res, 200, { ok: true, maxCostUSD: snap.maxCostUSD ?? n, source: snap.source, scope });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/sandbox") {
+        sendJson(res, 200, sandboxPayload());
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/permission") {
+        sendJson(res, 200, permissionPayload());
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/permission") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const mode = parsePermissionMode(parsed.value.permission);
+        if (!mode) {
+            sendJson(res, 400, { error: "invalid_permission", detail: "permission must be ask, accept-edits, or allow-all" });
+            return true;
+        }
+        const scopeParsed = readMemoryScope(parsed.value.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        setPermissionMode(mode, scope);
+        sendJson(res, 200, { ok: true, scope, ...permissionPayload() });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/sandbox") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        const mode = body.mode === undefined ? undefined : parseSandboxMode(body.mode);
+        if (body.mode !== undefined && !mode) {
+            sendJson(res, 400, { error: "invalid_sandbox", detail: "mode must be off, workspace, or strict" });
+            return true;
+        }
+        const network = body.network === undefined ? undefined : parseNetworkPolicy(body.network);
+        if (body.network !== undefined && !network) {
+            sendJson(res, 400, { error: "invalid_network", detail: "network must be allow or deny" });
+            return true;
+        }
+        const extraWrite = readStringPathList(body.extraWriteRoots);
+        const extraRead = readStringPathList(body.extraReadRoots);
+        if (!extraWrite.ok || !extraRead.ok) {
+            sendJson(res, 400, {
+                error: "invalid_roots",
+                detail: "extraWriteRoots and extraReadRoots must be arrays of non-empty strings",
+            });
+            return true;
+        }
+        if (!mode && !network && extraWrite.value === undefined && extraRead.value === undefined) {
+            sendJson(res, 400, { error: "invalid_body", detail: "Provide mode, network, extraWriteRoots, or extraReadRoots" });
+            return true;
+        }
+        const scopeParsed = readMemoryScope(body.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        setSandboxConfig({
+            ...(mode ? { mode } : {}),
+            ...(network ? { network } : {}),
+            ...(extraWrite.value ? { extraWriteRoots: extraWrite.value } : {}),
+            ...(extraRead.value ? { extraReadRoots: extraRead.value } : {}),
+        }, scope);
+        sendJson(res, 200, { ok: true, scope, ...sandboxPayload() });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/diff") {
+        const result = await getWorkingTreeDiff();
+        if (!result.ok) {
+            sendJson(res, 200, { ok: false, reason: result.reason, message: result.message });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, diff: result.diff });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/rules") {
+        sendJson(res, 200, {
+            count: ctx.instructions.length,
+            rules: ctx.instructions.map((inst) => {
+                const firstLine = inst.split("\n")[0] ?? "";
+                return { source: firstLine.replace("Instructions from: ", ""), chars: inst.length };
+            }),
+        });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/project") {
+        const project = scanProject();
+        sendJson(res, 200, { project });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/context") {
+        const config = getEffectiveConfig();
+        const provider = getActiveProvider(config);
+        const info = await getContextWindowInfo(provider?.defaultModel);
+        sendJson(res, 200, {
+            context_window: info.tokens,
+            source: info.source,
+            model: provider?.defaultModel ?? null,
+        });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/v1/cost") {
+        const config = getEffectiveConfig();
+        const provider = getActiveProvider(config);
+        const modelId = url.searchParams.get("model") ?? provider?.defaultModel ?? null;
+        const inputRaw = url.searchParams.get("input");
+        const outputRaw = url.searchParams.get("output");
+        const input = inputRaw ? parseInt(inputRaw, 10) : 0;
+        const output = outputRaw ? parseInt(outputRaw, 10) : 0;
+        if (Number.isNaN(input) || Number.isNaN(output) || input < 0 || output < 0) {
+            sendJson(res, 400, { error: "invalid_tokens", detail: "input/output must be non-negative integers" });
+            return true;
+        }
+        const price = modelId ? await getModelPrice(modelId) : null;
+        const cost = price ? estimateCost({ inputTokens: input, outputTokens: output }, price) : null;
+        sendJson(res, 200, { model: modelId, price, cost_usd: cost });
+        return true;
+    }
+    return false;
+};

package/dist/serve/routes-sessions.js

@@ -0,0 +1,61 @@
+import { listSessions, loadSession, deleteSession, renameSession } from "../sessions.js";
+import { sendJson, sendJsonError, readJsonBody, decodePathSegment } from "./common.js";
+export const handleSessionRoutes = async (req, res, _ctx, _url, pathname) => {
+    if (req.method === "GET" && pathname === "/v1/sessions") {
+        const sessions = listSessions();
+        sendJson(res, 200, { sessions });
+        return true;
+    }
+    if (req.method === "DELETE" && pathname.startsWith("/v1/sessions/")) {
+        const id = decodePathSegment(pathname.slice("/v1/sessions/".length));
+        if (!id) {
+            sendJson(res, 400, { error: "missing_session_id" });
+            return true;
+        }
+        const ok = deleteSession(id);
+        if (!ok) {
+            sendJson(res, 404, { error: "session_not_found", session_id: id });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, deleted: id });
+        return true;
+    }
+    if (req.method === "GET" && pathname.startsWith("/v1/sessions/")) {
+        const id = decodePathSegment(pathname.slice("/v1/sessions/".length));
+        if (!id) {
+            sendJson(res, 400, { error: "missing_session_id" });
+            return true;
+        }
+        const session = loadSession(id);
+        if (!session) {
+            sendJson(res, 404, { error: "session_not_found", session_id: id });
+            return true;
+        }
+        sendJson(res, 200, { session });
+        return true;
+    }
+    if (req.method === "POST" && pathname.startsWith("/v1/sessions/") && pathname.endsWith("/rename")) {
+        const id = decodePathSegment(pathname.slice("/v1/sessions/".length, -"/rename".length));
+        if (!id) {
+            sendJson(res, 400, { error: "missing_session_id" });
+            return true;
+        }
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const title = parsed.value.title?.trim();
+        if (!title) {
+            sendJson(res, 400, { error: "missing_title" });
+            return true;
+        }
+        if (!renameSession(id, title)) {
+            sendJson(res, 404, { error: "session_not_found", session_id: id });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, session_id: id, title });
+        return true;
+    }
+    return false;
+};

package/dist/serve/routes-skills.js

@@ -0,0 +1,70 @@
+import { discoverSkills, getAllSkills, getSkill, getStaleDisabledSkills, setSkillEnabled } from "../skills.js";
+import { sendJson, readJsonBody, decodePathSegment, skillPayload } from "./common.js";
+export const handleSkillRoutes = async (req, res, _ctx, _url, pathname) => {
+    if (req.method === "GET" && pathname === "/v1/skills") {
+        const all = getAllSkills();
+        sendJson(res, 200, {
+            count: all.length,
+            enabled_count: all.filter((s) => s.enabled).length,
+            stale_disabled: getStaleDisabledSkills(),
+            skills: all.map(skillPayload),
+        });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/skills/reload") {
+        discoverSkills({ silent: true });
+        const all = getAllSkills();
+        sendJson(res, 200, {
+            ok: true,
+            count: all.length,
+            enabled_count: all.filter((s) => s.enabled).length,
+            stale_disabled: getStaleDisabledSkills(),
+            skills: all.map(skillPayload),
+        });
+        return true;
+    }
+    const skillDetail = pathname.match(/^\/v1\/skills\/([^/]+)$/);
+    if (req.method === "GET" && skillDetail) {
+        const name = decodePathSegment(skillDetail[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "invalid_skill_name" });
+            return true;
+        }
+        const skill = getSkill(name);
+        if (!skill) {
+            sendJson(res, 404, { error: "skill_not_found", name, available: getAllSkills().map((s) => s.name) });
+            return true;
+        }
+        sendJson(res, 200, { skill: { ...skillPayload(skill), content: skill.content } });
+        return true;
+    }
+    const skillToggle = pathname.match(/^\/v1\/skills\/([^/]+)\/(enable|disable)$/);
+    if (req.method === "POST" && skillToggle) {
+        const name = decodePathSegment(skillToggle[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "invalid_skill_name" });
+            return true;
+        }
+        const enabled = skillToggle[2] === "enable";
+        if (!getSkill(name)) {
+            sendJson(res, 404, { error: "skill_not_found", name, available: getAllSkills().map((s) => s.name) });
+            return true;
+        }
+        const parsed = await readJsonBody(req);
+        const scope = parsed.ok ? parsed.value.scope : undefined;
+        if (scope !== undefined && scope !== "global" && scope !== "project") {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const [result] = setSkillEnabled([name], enabled, scope ?? "global");
+        sendJson(res, 200, {
+            ok: true,
+            name,
+            enabled: result.enabled,
+            scope: scope ?? "global",
+            ...(result.blockedBy ? { blocked_by: result.blockedBy } : {}),
+        });
+        return true;
+    }
+    return false;
+};