@aliceshimada/mica 1.0.0

package/dist/src/bun/httpServer.js

@@ -0,0 +1,356 @@
+import { timingSafeEqual } from "node:crypto";
+import http from "node:http";
+import { renderDashboard } from "./dashboard.js";
+const JSON_BODY_LIMIT_BYTES = 1024 * 1024;
+const DEFAULT_VERSION = "0.1.0";
+export async function createBunHttpApp({ state, host = "127.0.0.1", port, authToken, version = DEFAULT_VERSION }) {
+    const runtimeInfo = {
+        host,
+        port,
+        authToken,
+        version,
+        startedAtMs: Date.now(),
+    };
+    const fetchHandler = createFetchHandler(state, runtimeInfo);
+    const bun = globalThis.Bun;
+    if (bun?.serve) {
+        const server = bun.serve({ hostname: host, port, fetch: fetchHandler });
+        runtimeInfo.port = server.port;
+        return {
+            port: server.port,
+            stop: async () => {
+                await server.stop();
+            },
+        };
+    }
+    const nodeServer = await startNodeFallbackServer(fetchHandler, host, port);
+    runtimeInfo.port = nodeServer.port;
+    return nodeServer;
+}
+export function createFetchHandler(state, options = {}) {
+    const runtimeInfo = {
+        host: options.host ?? "127.0.0.1",
+        port: options.port ?? 19_791,
+        authToken: options.authToken,
+        version: options.version ?? DEFAULT_VERSION,
+        startedAtMs: options.startedAtMs ?? Date.now(),
+    };
+    return async (request) => {
+        const url = new URL(request.url);
+        try {
+            if (request.method === "GET" && url.pathname === "/") {
+                return htmlResponse(renderDashboard());
+            }
+            if (!isAuthorized(request.headers.get("authorization"), options.authToken)) {
+                return jsonResponse({ error: { code: "UNAUTHORIZED" } }, 401);
+            }
+            if (request.method === "GET" && url.pathname === "/status") {
+                state.sweepLiveness(Date.now());
+                return jsonResponse({
+                    server: {
+                        state: "running",
+                        version: runtimeInfo.version,
+                        pid: process.pid,
+                        host: runtimeInfo.host,
+                        port: runtimeInfo.port,
+                        uptimeMs: Math.max(0, Date.now() - runtimeInfo.startedAtMs),
+                    },
+                    security: {
+                        authEnabled: Boolean(runtimeInfo.authToken),
+                        // The dashboard uses the same generated bearer token as protocol endpoints.
+                        // Keep this explicit so the UI can describe dashboard access without exposing it.
+                        dashboardTokenPresent: Boolean(runtimeInfo.authToken),
+                    },
+                    agents: state.agents.list(),
+                    notebooks: state.notebooks.listLive(),
+                    requests: summarizeRequests(state.queue.snapshot()),
+                });
+            }
+            if (request.method === "POST" && url.pathname === "/agents/register") {
+                const body = await readJsonObjectBody(request);
+                const agentSessionId = readRequiredString(body.agentSessionId, "agentSessionId");
+                const wolframVersion = readRequiredString(body.wolframVersion, "wolframVersion");
+                const platform = readRequiredString(body.platform, "platform");
+                const seenAt = readOptionalNumber(body.seenAt) ?? Date.now();
+                const machineId = readOptionalString(body.machineId);
+                const frontendSessionId = readOptionalString(body.frontendSessionId);
+                const wolframProcessId = readOptionalString(body.wolframProcessId);
+                const agent = state.agents.register({ agentSessionId, wolframVersion, platform, seenAt, machineId, frontendSessionId, wolframProcessId });
+                return jsonResponse({ agent });
+            }
+            const agentHeartbeatMatch = url.pathname.match(/^\/agents\/([^/]+)\/heartbeat$/);
+            if (request.method === "POST" && (url.pathname === "/agents/heartbeat" || agentHeartbeatMatch)) {
+                const body = await readJsonObjectBody(request);
+                const pathAgentSessionId = agentHeartbeatMatch ? decodeURIComponent(agentHeartbeatMatch[1]) : undefined;
+                const agentSessionId = readOptionalString(body.agentSessionId) ?? pathAgentSessionId;
+                if (!agentSessionId)
+                    throw new Error("BAD_REQUEST");
+                const seenAt = readOptionalNumber(body.seenAt) ?? Date.now();
+                const existingAgent = state.agents.get(agentSessionId);
+                const agent = state.agents.heartbeat(agentSessionId, seenAt);
+                if (!agent) {
+                    return jsonResponse(noLiveAgentPayload(existingAgent), 404);
+                }
+                return jsonResponse({ agent });
+            }
+            if (request.method === "POST" && url.pathname === "/notebooks/heartbeat") {
+                const body = await readJsonObjectBody(request);
+                const agentSessionId = readRequiredString(body.agentSessionId, "agentSessionId");
+                const liveAgent = state.agents.get(agentSessionId);
+                if (!liveAgent || liveAgent.offline || liveAgent.retired) {
+                    return jsonResponse(noLiveAgentPayload(liveAgent), 404);
+                }
+                const notebook = state.notebooks.upsertHeartbeat({
+                    agentSessionId,
+                    frontendObjectKey: readRequiredString(body.frontendObjectKey, "frontendObjectKey"),
+                    displayName: readRequiredString(body.displayName, "displayName"),
+                    windowTitle: readRequiredPossiblyEmptyString(body.windowTitle),
+                    wolframVersion: readRequiredString(body.wolframVersion, "wolframVersion"),
+                    platform: readRequiredString(body.platform, "platform"),
+                    permissions: readPermissions(body.permissions),
+                    seenAt: readOptionalNumber(body.seenAt) ?? Date.now(),
+                    notebookPath: readOptionalString(body.notebookPath),
+                    savedPath: readOptionalString(body.savedPath),
+                });
+                return jsonResponse({ notebook });
+            }
+            const notebookClosedMatch = url.pathname.match(/^\/notebooks\/([^/]+)\/closed$/);
+            if (request.method === "POST" && notebookClosedMatch) {
+                const body = await readJsonObjectBody(request);
+                const agentSessionId = readRequiredString(body.agentSessionId, "agentSessionId");
+                const notebookId = decodeURIComponent(notebookClosedMatch[1]);
+                const notebook = state.notebooks.get(notebookId);
+                if (!notebook) {
+                    return jsonResponse({ error: { code: "NOTEBOOK_NOT_FOUND" } }, 404);
+                }
+                if (notebook.agentSessionId !== agentSessionId) {
+                    return jsonResponse({ error: { code: "NOT_OWNER" } }, 403);
+                }
+                state.closeNotebook(notebookId, Date.now());
+                return jsonResponse({ ok: true });
+            }
+            if (request.method === "GET" && url.pathname === "/notebooks") {
+                state.sweepLiveness(Date.now());
+                return jsonResponse({ notebooks: state.notebooks.listLive(), activeNotebookId: state.activeNotebookId ?? null });
+            }
+            const nextRequestMatch = url.pathname.match(/^\/agents\/([^/]+)\/next-request$/);
+            if (request.method === "GET" && nextRequestMatch) {
+                const agentSessionId = decodeURIComponent(nextRequestMatch[1]);
+                state.sweepLiveness(Date.now());
+                state.queue.markTimedOut(Date.now());
+                const agent = state.agents.get(agentSessionId);
+                if (!agent || agent.offline || agent.retired) {
+                    return jsonResponse(noLiveAgentPayload(agent), 404);
+                }
+                const nextRequest = state.queue.claimNext(agentSessionId, Date.now());
+                return jsonResponse({ request: nextRequest ?? null, cancelRequests: state.queue.cancellationsForAgent(agentSessionId) });
+            }
+            const requestResultMatch = url.pathname.match(/^\/requests\/([^/]+)\/result$/);
+            const requestFailureMatch = url.pathname.match(/^\/requests\/([^/]+)\/failure$/);
+            if (request.method === "POST" && (requestResultMatch || requestFailureMatch)) {
+                const requestId = decodeURIComponent((requestResultMatch ?? requestFailureMatch)[1]);
+                const body = await readJsonObjectBody(request);
+                state.queue.markTimedOut(Date.now());
+                if (requestFailureMatch || body.ok === false || body.success === false || body.failed === true) {
+                    const existing = state.queue.get(requestId);
+                    const failed = state.queue.fail(requestId, body.error ?? body);
+                    return jsonResponse({ accepted: failed, late: existing?.status === "timed_out" || existing?.status === "cancelled" });
+                }
+                return jsonResponse(state.queue.resolve(requestId, body.result ?? body, Date.now()));
+            }
+            return jsonResponse({ error: { code: "NOT_FOUND" } }, 404);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === "BAD_REQUEST") {
+                return jsonResponse({ error: { code: "BAD_REQUEST" } }, 400);
+            }
+            if (message === "MALFORMED_JSON") {
+                return jsonResponse({ error: { code: "BAD_REQUEST" } }, 400);
+            }
+            if (message === "PAYLOAD_TOO_LARGE") {
+                return jsonResponse({ error: { code: "PAYLOAD_TOO_LARGE" } }, 413);
+            }
+            return jsonResponse({ error: { code: "INTERNAL_ERROR", message } }, 500);
+        }
+    };
+}
+function summarizeRequests(snapshot) {
+    const allRequests = Object.values(snapshot).flat().sort((a, b) => b.createdAt - a.createdAt);
+    return {
+        queued: snapshot.queued.length,
+        running: snapshot.running.length,
+        timed_out: snapshot.timed_out.length,
+        cancelled: snapshot.cancelled.length,
+        latestRequestIds: allRequests.slice(0, 5).map((request) => request.requestId),
+    };
+}
+function isAuthorized(authorizationHeader, authToken) {
+    if (!authToken)
+        return true;
+    const expected = Buffer.from(`Bearer ${authToken}`);
+    const actual = Buffer.from(authorizationHeader ?? "");
+    return actual.byteLength === expected.byteLength && timingSafeEqual(actual, expected);
+}
+async function startNodeFallbackServer(fetchHandler, host, port) {
+    const server = http.createServer(async (incoming, outgoing) => {
+        try {
+            const body = await readNodeBody(incoming, JSON_BODY_LIMIT_BYTES);
+            const request = new Request(`http://${host}${incoming.url ?? "/"}`, {
+                method: incoming.method ?? "GET",
+                headers: incoming.headers,
+                body: body.length > 0 ? Buffer.from(body) : undefined,
+            });
+            const response = await fetchHandler(request);
+            await writeNodeResponse(outgoing, response);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === "PAYLOAD_TOO_LARGE") {
+                await writeNodeResponse(outgoing, jsonResponse({ error: { code: "PAYLOAD_TOO_LARGE" } }, 413));
+                return;
+            }
+            await writeNodeResponse(outgoing, jsonResponse({ error: { code: "INTERNAL_ERROR", message } }, 500));
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    return {
+        port: address?.port ?? port,
+        stop: async () => {
+            await new Promise((resolve, reject) => {
+                server.close((error) => (error ? reject(error) : resolve()));
+            });
+        },
+    };
+}
+async function readNodeBody(request, limitBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limitBytes) {
+            throw new Error("PAYLOAD_TOO_LARGE");
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+async function writeNodeResponse(response, result) {
+    const headers = {};
+    result.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    const body = Buffer.from(await result.arrayBuffer());
+    response.writeHead(result.status, headers);
+    response.end(body);
+}
+async function readJsonObjectBody(request) {
+    const text = await readLimitedRequestText(request, JSON_BODY_LIMIT_BYTES);
+    if (!text.trim())
+        throw new Error("BAD_REQUEST");
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error("MALFORMED_JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("BAD_REQUEST");
+    }
+    return parsed;
+}
+async function readLimitedRequestText(request, limitBytes) {
+    const body = request.body;
+    if (!body)
+        return "";
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const parts = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            size += value.byteLength;
+            if (size > limitBytes) {
+                throw new Error("PAYLOAD_TOO_LARGE");
+            }
+            parts.push(decoder.decode(value, { stream: true }));
+        }
+        parts.push(decoder.decode());
+        return parts.join("");
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function readRequiredString(value, fieldName) {
+    const text = readOptionalString(value);
+    if (!text)
+        throw new Error("BAD_REQUEST");
+    return text;
+}
+function readRequiredPossiblyEmptyString(value) {
+    if (typeof value !== "string")
+        throw new Error("BAD_REQUEST");
+    return value.trim();
+}
+function readOptionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const text = value.trim();
+    return text ? text : undefined;
+}
+function readOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readPermissions(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("BAD_REQUEST");
+    const record = value;
+    const keys = ["ReadNotebook", "InsertCell", "ModifyCell", "DeleteCell", "RunCell", "SaveNotebook"];
+    const permissions = {};
+    for (const key of keys) {
+        if (typeof record[key] !== "boolean")
+            throw new Error("BAD_REQUEST");
+        permissions[key] = record[key];
+    }
+    return permissions;
+}
+function noLiveAgentPayload(agent) {
+    const error = { code: "NO_LIVE_AGENT" };
+    if (agent?.retiredReason)
+        error.reason = agent.retiredReason;
+    return { error };
+}
+function jsonResponse(payload, status = 200) {
+    return new Response(escapeJsonForWolfram(JSON.stringify(payload)), {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+function escapeJsonForWolfram(json) {
+    return json.replace(/[^\x00-\x7F]/g, (character) => {
+        return [...character]
+            .map((unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, "0")}`)
+            .join("");
+    });
+}
+function htmlResponse(body) {
+    return new Response(body, {
+        status: 200,
+        headers: { "content-type": "text/html; charset=utf-8" },
+    });
+}

package/dist/src/bun/index.js

@@ -0,0 +1,91 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { randomUUID } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { BackendState } from "../backend/backendState.js";
+import { registerBackendMcpTools } from "../mcp/backendTools.js";
+import { createMicaMcpServer, registerMicaPrompts } from "../mcp/prompts.js";
+import { loadRuntimeConfig } from "../runtime/config.js";
+import { writeSessionFile } from "../runtime/session.js";
+import { createBunHttpApp } from "./httpServer.js";
+const MCP_SERVER_NAME = "mica-bun";
+const MICA_PACKAGE_VERSION = "0.1.0";
+export async function startBunRuntime(deps = {}) {
+    const config = deps.runtimeConfig ?? loadRuntimeConfig();
+    const bridgeOnly = deps.bridgeOnly ?? config.bridgeOnly;
+    const state = deps.state ?? new BackendState(() => `notebook-${randomUUID()}`);
+    const createHttpApp = deps.createHttpApp ?? createBunHttpApp;
+    const createMcpServer = deps.createMcpServer ?? (() => createMicaMcpServer(MCP_SERVER_NAME));
+    const createTransport = deps.createTransport ?? (() => new StdioServerTransport());
+    const writeSession = deps.writeSessionFile ?? writeSessionFile;
+    const version = deps.version ?? MICA_PACKAGE_VERSION;
+    const installSignalHandlers = deps.installSignalHandlers ??
+        ((onSignal) => {
+            process.once("SIGINT", onSignal);
+            process.once("SIGTERM", onSignal);
+            return () => {
+                process.off("SIGINT", onSignal);
+                process.off("SIGTERM", onSignal);
+            };
+        });
+    const httpApp = await createHttpApp({ state, host: config.host, port: config.preferredPort, authToken: config.authToken, version });
+    let cleanupSignals = () => { };
+    let stopped = false;
+    let stopPromise;
+    const stop = async () => {
+        if (stopPromise)
+            return stopPromise;
+        stopPromise = (async () => {
+            if (stopped)
+                return;
+            stopped = true;
+            cleanupSignals();
+            await httpApp.stop();
+        })();
+        return stopPromise;
+    };
+    const onSignal = (signal) => {
+        void stop().finally(() => process.exit(0));
+    };
+    try {
+        cleanupSignals = installSignalHandlers(onSignal);
+        await writeSession(config.sessionFile, {
+            host: config.host,
+            port: httpApp.port,
+            authToken: config.authToken,
+            pid: process.pid,
+            version,
+            status: "running",
+        });
+        const server = createMcpServer();
+        registerBackendMcpTools(server, state);
+        registerMicaPrompts(server);
+        console.error(`Bun HTTP server listening on http://${config.host}:${httpApp.port}`);
+        console.error(`Dashboard: http://${config.host}:${httpApp.port}/#token=${config.authToken}`);
+        if (!bridgeOnly) {
+            console.error("Bun MCP mode enabled; connecting stdio transport.");
+            await server.connect(createTransport());
+        }
+    }
+    catch (error) {
+        await stop();
+        throw error;
+    }
+    return {
+        state,
+        httpApp,
+        stop,
+        keepAlive: new Promise(() => { })
+    };
+}
+async function main() {
+    const runtime = await startBunRuntime();
+    await runtime.keepAlive;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.stack ?? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+    });
+}
+export { MCP_SERVER_NAME };

package/dist/src/cli/doctor.js

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { defaultSessionFile } from "../runtime/config.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const AUTOLOAD_MARKER = "(* BEGIN MICA control-kernel autoload *)";
+// ---------------------------------------------------------------------------
+// runDoctor
+// ---------------------------------------------------------------------------
+export async function runDoctor(deps = {}) {
+    const lines = [];
+    let hasFailure = false;
+    const projectRoot = deps.projectRoot ?? process.cwd();
+    const env = deps.env ?? process.env;
+    const nodeVersion = deps.nodeVersion ?? process.version;
+    const _exists = deps.exists ?? existsSync;
+    const _readFile = deps.readFile ?? ((p) => readFileSync(p, "utf8"));
+    const _fetch = deps.fetch ??
+        (typeof globalThis.fetch === "function"
+            ? (url, init) => globalThis.fetch(url, init)
+            : undefined);
+    const _detectWolframUserBase = deps.detectWolframUserBase;
+    const ok = (label, detail) => {
+        const d = detail !== undefined ? `: ${detail}` : "";
+        lines.push(`OK   ${label}${d}`);
+    };
+    const fail = (label, detail) => {
+        hasFailure = true;
+        const d = detail !== undefined ? `: ${detail}` : "";
+        lines.push(`FAIL ${label}${d}`);
+    };
+    const fix = (msg) => {
+        lines.push(`FIX  ${msg}`);
+    };
+    // -----------------------------------------------------------------------
+    // Header
+    // -----------------------------------------------------------------------
+    lines.push("MICA doctor");
+    lines.push("");
+    // -----------------------------------------------------------------------
+    // 1. Node version
+    // -----------------------------------------------------------------------
+    const nodeMajor = Number.parseInt(nodeVersion.replace(/^v/, "").split(".")[0], 10);
+    if (Number.isFinite(nodeMajor) && nodeMajor >= 20) {
+        ok("Node version", nodeVersion);
+    }
+    else {
+        fail("Node version", `${nodeVersion} (Node >=20 required)`);
+        fix("Install Node.js 20 or newer");
+    }
+    // -----------------------------------------------------------------------
+    // 2. Package build
+    // -----------------------------------------------------------------------
+    const distCliIndex = path.join(projectRoot, "dist", "src", "cli", "index.js");
+    const distBunIndex = path.join(projectRoot, "dist", "src", "bun", "index.js");
+    const bridgeSource = path.join(projectRoot, "paclet", "Kernel", "MMAAgentBridge.wl");
+    const buildOk = _exists(distCliIndex) && _exists(distBunIndex);
+    if (buildOk) {
+        ok("Package build");
+    }
+    else {
+        const missing = [];
+        if (!_exists(distCliIndex))
+            missing.push("dist/src/cli/index.js");
+        if (!_exists(distBunIndex))
+            missing.push("dist/src/bun/index.js");
+        fail("Package build", `missing: ${missing.join(", ")}`);
+        fix("Run: npm run build");
+    }
+    if (_exists(bridgeSource)) {
+        ok("Bridge source path", bridgeSource);
+    }
+    else {
+        fail("Bridge source path", `${bridgeSource} (not found)`);
+        fix("Run: npm run build");
+    }
+    // -----------------------------------------------------------------------
+    // 3. Session file
+    // -----------------------------------------------------------------------
+    const sessionFile = env.MICA_SESSION_FILE ?? defaultSessionFile(env);
+    let sessionData = null;
+    let sessionBaseUrl;
+    if (!_exists(sessionFile)) {
+        fail("Session file", `${sessionFile} (not found)`);
+        fix("Run: mica start");
+    }
+    else {
+        try {
+            const raw = _readFile(sessionFile);
+            sessionData = JSON.parse(raw);
+            sessionBaseUrl =
+                sessionData?.baseUrl ??
+                    `http://${sessionData?.host ?? "127.0.0.1"}:${sessionData?.port ?? 19791}`;
+            ok("Session file", sessionFile);
+            ok("Session target", sessionBaseUrl);
+        }
+        catch (e) {
+            fail("Session file", `${sessionFile} (${e instanceof Error ? e.message : String(e)})`);
+            fix("Run: mica start");
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 4. Auth token
+    // -----------------------------------------------------------------------
+    if (sessionData && !sessionData.authToken) {
+        fail("Auth token", "missing in session file");
+    }
+    else if (!sessionData) {
+        fail("Auth token", "session file not available");
+    }
+    // -----------------------------------------------------------------------
+    // 5–7. Server checks (only when session data is available)
+    // -----------------------------------------------------------------------
+    if (sessionData && sessionData.authToken && _fetch) {
+        const statusUrl = `${sessionBaseUrl}/status`;
+        try {
+            const res = await _fetch(statusUrl, {
+                headers: { Authorization: `Bearer ${sessionData.authToken}` },
+            });
+            if (res.status === 401) {
+                fail("Auth token", "401 Unauthorized");
+                fail("Server /status reachable", "authentication failed");
+                fail("Live agent count", "server not reachable");
+                fail("Live notebook count", "server not reachable");
+            }
+            else if (res.status === 200) {
+                ok("Auth token");
+                ok("Server /status reachable");
+                const body = (await res.json());
+                // Live agent count
+                let agentCount;
+                if (typeof body.agentCount === "number") {
+                    agentCount = body.agentCount;
+                }
+                else if (Array.isArray(body.agents)) {
+                    agentCount = body.agents.filter((a) => a.status !== "offline" && a.status !== "retired").length;
+                }
+                else {
+                    agentCount = 0;
+                }
+                if (agentCount > 0) {
+                    ok("Live agent count", String(agentCount));
+                }
+                else {
+                    fail("Live agent count", "0");
+                }
+                // Live notebook count
+                let notebookCount;
+                if (typeof body.notebookCount === "number") {
+                    notebookCount = body.notebookCount;
+                }
+                else if (Array.isArray(body.notebooks)) {
+                    notebookCount = body.notebooks.length;
+                }
+                else {
+                    notebookCount = 0;
+                }
+                if (notebookCount > 0) {
+                    ok("Live notebook count", String(notebookCount));
+                }
+                else {
+                    fail("Live notebook count", "0");
+                }
+            }
+            else {
+                ok("Auth token");
+                fail("Server /status reachable", `HTTP ${res.status}`);
+                fail("Live agent count", "server not reachable");
+                fail("Live notebook count", "server not reachable");
+            }
+        }
+        catch (e) {
+            fail("Auth token", "server not reachable");
+            fail("Server /status reachable", e instanceof Error ? e.message : String(e));
+            fix("Run: mica start");
+            fail("Live agent count", "server not reachable");
+            fail("Live notebook count", "server not reachable");
+        }
+    }
+    else if (sessionData && sessionData.authToken && !_fetch) {
+        fail("Auth token", "fetch unavailable");
+        fail("Server /status reachable", "fetch unavailable");
+        fail("Live agent count", "server not reachable");
+        fail("Live notebook count", "server not reachable");
+    }
+    else {
+        // No valid session data
+        fail("Server /status reachable", "session file not available");
+        fail("Live agent count", "server not reachable");
+        fail("Live notebook count", "server not reachable");
+    }
+    // -----------------------------------------------------------------------
+    // 8. Wolfram user base
+    // -----------------------------------------------------------------------
+    if (_detectWolframUserBase) {
+        try {
+            const detection = _detectWolframUserBase();
+            ok("Wolfram user base", `${detection.userBase} (${detection.source})`);
+            // Kernel/init.m
+            const initPath = path.join(detection.userBase, "Kernel", "init.m");
+            if (_exists(initPath)) {
+                ok("Kernel/init.m", initPath);
+                // Autoload block
+                const content = _readFile(initPath);
+                if (content.includes(AUTOLOAD_MARKER)) {
+                    ok("Autoload block");
+                }
+                else {
+                    fail("Autoload block", `not found in ${initPath}`);
+                    fix("Run: mica install");
+                }
+            }
+            else {
+                fail("Kernel/init.m", `${initPath} (not found)`);
+                fix("Run: mica install");
+                fail("Autoload block", "Kernel/init.m not found");
+            }
+        }
+        catch (e) {
+            fail("Wolfram user base", e instanceof Error ? e.message : String(e));
+            fail("Kernel/init.m", "Wolfram user base detection failed");
+            fail("Autoload block", "Wolfram user base detection failed");
+        }
+    }
+    else {
+        fail("Wolfram user base", "detector unavailable");
+        fail("Kernel/init.m", "Wolfram user base detection failed");
+        fail("Autoload block", "Wolfram user base detection failed");
+    }
+    // -----------------------------------------------------------------------
+    // Result
+    // -----------------------------------------------------------------------
+    return { exitCode: hasFailure ? 1 : 0, output: `${lines.join("\n")}\n` };
+}