@sean.holung/minicode 0.3.5 → 0.3.6

package/dist/tests/graph-selection.test.js

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { buildFileFocusedSelection, buildGraphEdgeId, buildGraphEdgeIndex, } from "../src/shared/graph-selection.js";
+test("buildGraphEdgeIndex indexes edges by both source and target", () => {
+    const edges = [
+        { source: "Review#class", target: "Session.trim", kind: "references" },
+        { source: "renderReview", target: "Review#type", kind: "references" },
+    ];
+    const edgeIndex = buildGraphEdgeIndex(edges);
+    assert.deepEqual(edgeIndex.get("Review#class"), [edges[0]]);
+    assert.deepEqual(edgeIndex.get("Session.trim"), [edges[0]]);
+    assert.deepEqual(edgeIndex.get("renderReview"), [edges[1]]);
+    assert.deepEqual(edgeIndex.get("Review#type"), [edges[1]]);
+});
+test("buildFileFocusedSelection includes file symbols and touching neighbors", () => {
+    const fileIndex = new Map([
+        ["src/review.ts", ["Review#class", "Review#type"]],
+    ]);
+    const edges = [
+        { source: "Review#class", target: "Session.trim", kind: "references" },
+        { source: "renderReview", target: "Review#type", kind: "references" },
+        { source: "Review#class", target: "Review#type", kind: "references" },
+    ];
+    const selection = buildFileFocusedSelection({
+        filePath: "src/review.ts",
+        fileIndex,
+        edgeIndex: buildGraphEdgeIndex(edges),
+    });
+    assert.deepEqual(new Set(selection.nodeIds), new Set(["Review#class", "Review#type", "Session.trim", "renderReview"]));
+    assert.deepEqual(new Set(selection.edges.map((edge) => buildGraphEdgeId(edge))), new Set(edges.map((edge) => buildGraphEdgeId(edge))));
+});
+test("buildFileFocusedSelection excludes edges between external neighbors", () => {
+    const fileIndex = new Map([
+        ["src/review.ts", ["Review#class"]],
+    ]);
+    const reviewToSession = { source: "Review#class", target: "Session.trim", kind: "references" };
+    const reviewToRender = { source: "Review#class", target: "renderReview", kind: "references" };
+    const sessionToRender = { source: "Session.trim", target: "renderReview", kind: "references" };
+    const edges = [reviewToSession, reviewToRender, sessionToRender];
+    const selection = buildFileFocusedSelection({
+        filePath: "src/review.ts",
+        fileIndex,
+        edgeIndex: buildGraphEdgeIndex(edges),
+    });
+    assert.deepEqual(new Set(selection.nodeIds), new Set(["Review#class", "Session.trim", "renderReview"]));
+    assert.deepEqual(new Set(selection.edges.map((edge) => buildGraphEdgeId(edge))), new Set([
+        buildGraphEdgeId(reviewToSession),
+        buildGraphEdgeId(reviewToRender),
+    ]));
+});
+test("buildFileFocusedSelection returns an empty selection for unknown files", () => {
+    const selection = buildFileFocusedSelection({
+        filePath: "src/missing.ts",
+        fileIndex: new Map(),
+        edgeIndex: buildGraphEdgeIndex([]),
+    });
+    assert.deepEqual(selection, { nodeIds: [], edges: [] });
+});

package/dist/tests/home-env.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
+import { getHomeEnvPath, upsertHomeEnvValues } from "../src/agent/home-env.js";
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+test("upsertHomeEnvValues creates ~/.minicode/.env when missing", async () => {
+    const minicodeHome = await mkdtemp(path.join(os.tmpdir(), "minicode-home-env-"));
+    tempDirs.push(minicodeHome);
+    const result = await upsertHomeEnvValues({
+        minicodeHome,
+        values: {
+            MODEL_PROVIDER: "openai-compatible",
+            OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
+            OPENROUTER_API_KEY: "sk-or-v1-test",
+        },
+    });
+    assert.equal(result.path, getHomeEnvPath(minicodeHome));
+    const contents = await readFile(result.path, "utf8");
+    assert.match(contents, /^MODEL_PROVIDER=openai-compatible/m);
+    assert.match(contents, /^OPENAI_BASE_URL=https:\/\/openrouter\.ai\/api\/v1/m);
+    assert.match(contents, /^OPENROUTER_API_KEY=sk-or-v1-test/m);
+});
+test("upsertHomeEnvValues replaces existing keys and preserves unrelated lines", async () => {
+    const minicodeHome = await mkdtemp(path.join(os.tmpdir(), "minicode-home-env-"));
+    tempDirs.push(minicodeHome);
+    const envPath = getHomeEnvPath(minicodeHome);
+    await writeFile(envPath, [
+        "# Existing config",
+        "MODEL_PROVIDER=anthropic",
+        "OPENAI_BASE_URL=https://example.invalid/v1",
+        "OPENROUTER_API_KEY=old-key",
+        "OPENROUTER_API_KEY=older-key",
+        "MODEL=existing-model",
+        "",
+    ].join("\n"), "utf8");
+    await upsertHomeEnvValues({
+        minicodeHome,
+        values: {
+            MODEL_PROVIDER: "openai-compatible",
+            OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
+            OPENROUTER_API_KEY: "sk-or-v1-new",
+        },
+    });
+    const contents = await readFile(envPath, "utf8");
+    assert.match(contents, /^# Existing config/m);
+    assert.match(contents, /^MODEL_PROVIDER=openai-compatible$/m);
+    assert.match(contents, /^OPENAI_BASE_URL=https:\/\/openrouter\.ai\/api\/v1$/m);
+    assert.match(contents, /^OPENROUTER_API_KEY=sk-or-v1-new$/m);
+    assert.match(contents, /^MODEL=existing-model$/m);
+    assert.equal(contents.match(/^OPENROUTER_API_KEY=/gm)?.length, 1);
+});

package/dist/tests/serve.integration.test.js

@@ -1,9 +1,12 @@
 import assert from "node:assert/strict";
 import { test, afterEach } from "node:test";
 import { createServer } from "node:http";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { createRequestHandler, shutdownServe } from "../src/serve/server.js";
 import { AgentBridge } from "../src/serve/agent-bridge.js";
+import { Session } from "@minicode/agent-sdk";
 import { createTestAgentConfig } from "./test-utils.js";
 /**
  * Lightweight AgentBridge subclass for testing.
@@ -12,7 +15,11 @@ import { createTestAgentConfig } from "./test-utils.js";
 class MockBridge extends AgentBridge {
     _busy = false;
     _currentSessionId = "sess-1";
+    _baseConfig = createTestAgentConfig("/tmp/test-workspace");
+    _config = createTestAgentConfig("/tmp/test-workspace");
     turnHistory = [];
+    openRouterKey;
+    openRouterSessionActive = false;
     constructor() {
         super(() => { }, false);
     }
@@ -20,7 +27,7 @@ class MockBridge extends AgentBridge {
         return this._busy;
     }
     getConfig() {
-        return createTestAgentConfig("/tmp/test-workspace");
+        return this._config;
     }
     async runTurn(message) {
         if (this._busy)
@@ -65,11 +72,47 @@ class MockBridge extends AgentBridge {
     async loadSess(label) {
         if (label === "nonexistent")
             return null;
-        return { session: {}, label };
+        const session = new Session("sess-1");
+        session.addMessage({
+            role: "user",
+            content: "[Conversation Summary — earlier messages were compacted to save context]\nOlder summary",
+        });
+        for (let i = 1; i <= 11; i += 1) {
+            session.addMessage({
+                role: i % 2 === 0 ? "assistant" : "user",
+                content: `message-${i}`,
+            });
+        }
+        return { session, label };
     }
     getCurrentSessionId() {
         return this._currentSessionId;
     }
+    connectOpenRouter(apiKey) {
+        this.openRouterKey = apiKey;
+        this.openRouterSessionActive = true;
+        this._config.modelProvider = "openai-compatible";
+        this._config.openAiBaseUrl = "https://openrouter.ai/api/v1";
+        this._config.openAiApiKey = apiKey;
+    }
+    disconnectOpenRouter() {
+        if (!this.openRouterSessionActive) {
+            return false;
+        }
+        this.openRouterSessionActive = false;
+        this.openRouterKey = undefined;
+        this._config.modelProvider = this._baseConfig.modelProvider;
+        this._config.model = this._baseConfig.model;
+        this._config.openAiBaseUrl = this._baseConfig.openAiBaseUrl;
+        delete this._config.openAiApiKey;
+        return true;
+    }
+    isOpenRouterSessionConnected() {
+        return this.openRouterSessionActive;
+    }
+    switchModel(modelId) {
+        this._config.model = modelId;
+    }
     setBusy(busy) {
         this._busy = busy;
     }
@@ -310,8 +353,8 @@ class EmptySessionsBridge extends MockBridge {
 }
 // ── Test harness ──
 let activeServer;
-function startTestServer(bridge) {
-    const handler = createRequestHandler(bridge);
+function startTestServer(bridge, options = {}) {
+    const handler = createRequestHandler(bridge, undefined, options);
     const server = createServer(handler);
     activeServer = server;
     return new Promise((resolve) => {
@@ -367,7 +410,7 @@ test("GET /api/config returns formatted config plus structured settings", async
     assert.ok(body.config.includes("test-model"));
     assert.equal(body.restartRequired, true);
     assert.equal(body.secretsUiSupported, false);
-    assert.ok(body.settings.configPath.endsWith("/.minicode/agent.config.json"));
+    assert.ok(body.settings.configPath.endsWith("/.minicode/.env"));
     assert.ok(body.settings.entries.some((entry) => entry.key === "maxSteps"));
 });
 test("GET /api/sessions returns session list", async () => {
@@ -432,6 +475,10 @@ test("POST /api/sessions/load returns success for known session", async () => {
     assert.equal(res.status, 200);
     const body = (await res.json());
     assert.equal(body.label, "test-session");
+    assert.equal(body.messages.length, 10);
+    assert.equal(body.messages[0]?.content, "message-2");
+    assert.equal(body.messages[9]?.content, "message-11");
+    assert.ok(body.messages.every((message) => !message.content.startsWith("[Conversation Summary")));
 });
 test("POST /api/chat returns agent response", async () => {
     const bridge = new MockBridge();
@@ -468,6 +515,179 @@ test("POST /api/chat returns 429 when agent is busy", async () => {
     });
     assert.equal(res.status, 429);
 });
+test("POST /api/openrouter/connect exchanges code and stores a session-only key", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+        if (String(input) !== "https://openrouter.ai/api/v1/auth/keys") {
+            return originalFetch(input, init);
+        }
+        assert.equal(init?.method, "POST");
+        assert.equal((init?.headers)["Content-Type"], "application/json");
+        const body = JSON.parse(String(init?.body));
+        assert.equal(body.code, "oauth-code");
+        assert.equal(body.code_verifier, "pkce-verifier");
+        assert.equal(body.code_challenge_method, "S256");
+        return new Response(JSON.stringify({ key: "sk-or-v1-session-key" }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    try {
+        const res = await originalFetch(`${base}/api/openrouter/connect`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code: "oauth-code", codeVerifier: "pkce-verifier" }),
+        });
+        assert.equal(res.status, 200);
+        const body = await res.json();
+        assert.equal(body.ok, true);
+        assert.equal(body.sessionOnly, true);
+        assert.equal(body.persistedToEnv, false);
+        assert.equal(body.persistedEnvPath, null);
+        assert.equal(body.persistWarning, null);
+        assert.equal(body.baseUrl, "https://openrouter.ai/api/v1");
+        assert.equal(body.needsSetup, false);
+        assert.deepEqual(body.missing, []);
+        assert.equal(body.message, "OpenRouter connected for this serve session.");
+        assert.equal(bridge.openRouterKey, "sk-or-v1-session-key");
+        assert.equal(bridge.getConfig().modelProvider, "openai-compatible");
+        assert.equal(bridge.getConfig().openAiBaseUrl, "https://openrouter.ai/api/v1");
+        assert.equal(bridge.getConfig().openAiApiKey, "sk-or-v1-session-key");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+test("POST /api/openrouter/connect can persist OpenRouter setup to ~/.minicode/.env", async () => {
+    const bridge = new MockBridge();
+    const minicodeHome = mkdtempSync(path.join(os.tmpdir(), "minicode-openrouter-home-"));
+    const base = await startTestServer(bridge, { minicodeHome });
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+        if (String(input) !== "https://openrouter.ai/api/v1/auth/keys") {
+            return originalFetch(input, init);
+        }
+        return new Response(JSON.stringify({ key: "sk-or-v1-session-key" }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    try {
+        const res = await originalFetch(`${base}/api/openrouter/connect`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code: "oauth-code", codeVerifier: "pkce-verifier", persistToEnv: true }),
+        });
+        assert.equal(res.status, 200);
+        const body = await res.json();
+        assert.equal(body.persistedToEnv, true);
+        assert.equal(body.persistWarning, null);
+        assert.equal(body.persistedEnvPath, path.join(minicodeHome, ".env"));
+        assert.match(body.message, /saved to ~\/\.minicode\/\.env/);
+        const envContents = readFileSync(path.join(minicodeHome, ".env"), "utf8");
+        assert.match(envContents, /^MODEL_PROVIDER=openai-compatible$/m);
+        assert.match(envContents, /^OPENAI_BASE_URL=https:\/\/openrouter\.ai\/api\/v1$/m);
+        assert.match(envContents, /^OPENROUTER_API_KEY=sk-or-v1-session-key$/m);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        rmSync(minicodeHome, { recursive: true, force: true });
+    }
+});
+test("POST /api/model persists the selected model to ~/.minicode/.env", async () => {
+    const bridge = new MockBridge();
+    const minicodeHome = mkdtempSync(path.join(os.tmpdir(), "minicode-model-home-"));
+    const envPath = path.join(minicodeHome, ".env");
+    writeFileSync(envPath, [
+        "MODEL_PROVIDER=openai-compatible",
+        "OPENAI_BASE_URL=https://openrouter.ai/api/v1",
+        "OPENROUTER_API_KEY=sk-or-v1-session-key",
+        "",
+    ].join("\n"), "utf8");
+    const base = await startTestServer(bridge, { minicodeHome });
+    try {
+        const res = await fetch(`${base}/api/model`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: "openrouter/test-model" }),
+        });
+        assert.equal(res.status, 200);
+        const body = await res.json();
+        assert.equal(body.model, "openrouter/test-model");
+        assert.equal(body.persistedToEnv, true);
+        assert.equal(body.persistedEnvPath, envPath);
+        const envContents = readFileSync(envPath, "utf8");
+        assert.match(envContents, /^MODEL=openrouter\/test-model$/m);
+        assert.match(envContents, /^OPENROUTER_API_KEY=sk-or-v1-session-key$/m);
+        assert.equal(bridge.getConfig().model, "openrouter/test-model");
+    }
+    finally {
+        rmSync(minicodeHome, { recursive: true, force: true });
+    }
+});
+test("POST /api/openrouter/disconnect removes the session-only OpenRouter connection", async () => {
+    const bridge = new MockBridge();
+    bridge.connectOpenRouter("sk-or-v1-session-key");
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/openrouter/disconnect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+    });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.ok, true);
+    assert.equal(body.disconnected, true);
+    assert.equal(body.sessionOnly, true);
+    assert.equal(body.provider, "anthropic");
+    assert.equal(body.baseUrl, "http://localhost:1234/v1");
+    assert.equal(body.message, "Removed the session-only OpenRouter connection and restored your original provider settings.");
+    assert.equal(bridge.openRouterSessionActive, false);
+    assert.equal(bridge.getConfig().modelProvider, "anthropic");
+    assert.equal(bridge.getConfig().openAiBaseUrl, "http://localhost:1234/v1");
+    assert.equal(bridge.getConfig().openAiApiKey, undefined);
+});
+test("GET /api/status exposes OpenRouter session state and base URL", async () => {
+    const bridge = new MockBridge();
+    bridge.connectOpenRouter("sk-or-v1-session-key");
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/status`);
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.provider, "openai-compatible");
+    assert.equal(body.baseUrl, "https://openrouter.ai/api/v1");
+    assert.equal(body.sessionOpenRouterConnected, true);
+});
+test("POST /api/openrouter/connect returns 400 when code is missing", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/openrouter/connect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ codeVerifier: "pkce-verifier" }),
+    });
+    assert.equal(res.status, 400);
+});
+test("POST /api/openrouter/connect surfaces exchange failures", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+        if (String(input) !== "https://openrouter.ai/api/v1/auth/keys") {
+            return originalFetch(input, init);
+        }
+        return new Response("Invalid code", { status: 403 });
+    };
+    try {
+        const res = await originalFetch(`${base}/api/openrouter/connect`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code: "bad-code", codeVerifier: "pkce-verifier" }),
+        });
+        assert.equal(res.status, 403);
+        const body = await res.json();
+        assert.ok(body.error.includes("OpenRouter OAuth exchange failed"));
+        assert.ok(body.error.includes("Invalid code"));
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
 // ── OpenAI-compatible API tests ──
 test("GET /v1/models returns minicode-agent model", async () => {
     const bridge = new MockBridge();
@@ -576,6 +796,7 @@ test("GET / serves index.html", async () => {
     const res = await fetch(`${base}/`);
     assert.equal(res.status, 200);
     assert.equal(res.headers.get("content-type"), "text/html");
+    assert.equal(res.headers.get("cache-control"), "no-store");
     const html = await res.text();
     assert.ok(html.includes("minicode"));
 });
@@ -585,6 +806,7 @@ test("GET /style.css serves CSS file", async () => {
     const res = await fetch(`${base}/style.css`);
     assert.equal(res.status, 200);
     assert.equal(res.headers.get("content-type"), "text/css");
+    assert.equal(res.headers.get("cache-control"), "no-store");
 });
 test("GET /app.js serves JS file", async () => {
     const bridge = new MockBridge();
@@ -592,6 +814,7 @@ test("GET /app.js serves JS file", async () => {
     const res = await fetch(`${base}/app.js`);
     assert.equal(res.status, 200);
     assert.equal(res.headers.get("content-type"), "application/javascript");
+    assert.equal(res.headers.get("cache-control"), "no-store");
 });
 test("GET /nonexistent returns 404", async () => {
     const bridge = new MockBridge();

package/dist/tests/session-preview.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { buildSessionPreview, isCompactionSummaryMessage, } from "../src/session/session-preview.js";
+test("isCompactionSummaryMessage detects compacted summary stubs", () => {
+    assert.equal(isCompactionSummaryMessage({
+        role: "user",
+        content: "[Conversation Summary — earlier messages were compacted to save context]\nSummary text",
+    }), true);
+    assert.equal(isCompactionSummaryMessage({
+        role: "assistant",
+        content: "[Conversation Summary — earlier messages were compacted to save context]\nSummary text",
+    }), false);
+});
+test("buildSessionPreview filters compaction summaries and keeps the last ten messages", () => {
+    const preview = buildSessionPreview([
+        {
+            role: "user",
+            content: "[Conversation Summary — earlier messages were compacted using LLM summarization]\nSummary text",
+        },
+        { role: "user", content: "message-1" },
+        { role: "assistant", content: "message-2" },
+        { role: "user", content: "message-3" },
+        { role: "assistant", content: "message-4" },
+        { role: "user", content: "message-5" },
+        { role: "assistant", content: "message-6" },
+        { role: "user", content: "message-7" },
+        { role: "assistant", content: "message-8" },
+        { role: "user", content: "message-9" },
+        { role: "assistant", content: "message-10" },
+        { role: "user", content: "message-11" },
+    ]);
+    assert.equal(preview.length, 10);
+    assert.equal(preview[0]?.content, "message-2");
+    assert.equal(preview[9]?.content, "message-11");
+    assert.ok(preview.every((message) => !message.content.startsWith("[Conversation Summary")));
+});
+test("buildSessionPreview preserves tool messages in order", () => {
+    const preview = buildSessionPreview([
+        {
+            role: "assistant",
+            content: "Let me check that",
+            toolCalls: [{ id: "tool-1", name: "search", input: { query: "foo" } }],
+        },
+        {
+            role: "tool",
+            toolCallId: "tool-1",
+            toolName: "search",
+            content: "search output",
+        },
+        {
+            role: "assistant",
+            content: "Found it",
+        },
+    ]);
+    assert.deepEqual(preview.map((message) => message.role), ["assistant", "tool", "assistant"]);
+});

package/dist/tests/session-ui.test.js

@@ -20,4 +20,6 @@ test("built JS contains active saved session update logic", () => {
     assert.ok(js.includes("Session updated:"), "JS should emit the update confirmation message");
     assert.ok(js.includes("sessionRefreshTracker"), "JS should guard session list refreshes against stale responses");
     assert.ok(js.includes('saveBtn.setAttribute("disabled", "true")'), "JS should disable saving while the first save is in flight");
+    assert.ok(js.includes("renderLoadedSessionMessages"), "JS should render session previews after load");
+    assert.ok(js.includes("body.messages"), "JS should read preview messages from the load session response");
 });

package/dist/tests/settings-ui.test.js

@@ -7,6 +7,12 @@ test("built HTML contains settings entry point and modal shell", () => {
     const html = readFileSync(join(distWeb, "index.html"), "utf8");
     assert.ok(html.includes('id="settings-btn"'), "HTML should contain the settings button");
     assert.ok(html.includes('id="settings-modal"'), "HTML should contain the settings modal");
+    assert.ok(html.includes('id="connect-openrouter-btn"'), "HTML should contain the OpenRouter connect button");
+    assert.ok(html.includes('id="config-overlay-intro"'), "HTML should contain the setup overlay intro copy");
+    assert.ok(html.includes("Try minicode for free with OpenRouter"), "HTML should promote the free OpenRouter quick start");
+    assert.ok(html.includes('id="openrouter-connect-modal"'), "HTML should contain the OpenRouter consent modal");
+    assert.ok(html.includes('id="openrouter-persist-checkbox"'), "HTML should contain the OpenRouter persistence checkbox");
+    assert.ok(html.includes('id="disconnect-openrouter-btn"'), "HTML should contain the OpenRouter disconnect button");
     assert.ok(!html.includes('id="settings-scope"'), "HTML should no longer contain the settings scope selector");
     assert.ok(html.includes('id="settings-save"'), "HTML should contain the settings save action");
 });
@@ -16,11 +22,23 @@ test("built CSS contains modal and settings layout styles", () => {
     assert.ok(css.includes(".settings-list"), "CSS should contain settings list styles");
     assert.ok(css.includes(".settings-item-meta"), "CSS should contain settings metadata grid styles");
     assert.ok(css.includes(".settings-help-warning"), "CSS should contain warning styling for env overrides");
+    assert.ok(css.includes("align-items: flex-start;"), "CSS should top-align scrollable setup overlay content");
+    assert.ok(css.includes(".config-overlay-spotlight"), "CSS should style the OpenRouter quick-start spotlight");
+    assert.ok(css.includes(".openrouter-connect-body"), "CSS should style the OpenRouter consent modal body");
+    assert.ok(css.includes(".config-connect-status.success"), "CSS should style OpenRouter connect success state");
+    assert.ok(css.includes(".settings-session-banner"), "CSS should style the OpenRouter session banner");
     assert.ok(css.includes("body.modal-open"), "CSS should lock scroll while the settings modal is open");
 });
 test("built JS contains config loading and saving logic for settings", () => {
     const js = readFileSync(join(distWeb, "app.js"), "utf8");
     assert.ok(js.includes("/api/config"), "JS should fetch the config API");
+    assert.ok(js.includes("/api/openrouter/connect"), "JS should call the OpenRouter connect API");
+    assert.ok(js.includes("/api/openrouter/disconnect"), "JS should call the OpenRouter disconnect API");
+    assert.ok(js.includes("persistToHomeEnv"), "JS should support persisting the selected model after OpenRouter setup");
+    assert.ok(js.includes("code_challenge_method"), "JS should generate an OpenRouter PKCE auth request");
+    assert.ok(js.includes("sessionStorage"), "JS should persist the PKCE verifier for the OAuth callback");
+    assert.ok(js.includes("minicode:openrouter:persist-to-env"), "JS should persist the optional OpenRouter env-write choice across OAuth");
+    assert.ok(js.includes("sessionOpenRouterConnected"), "JS should track session-only OpenRouter state");
     assert.ok(js.includes("Save settings"), "JS should contain the settings save action text");
     assert.ok(js.includes("settingsPayload"), "JS should track settings payload state");
     assert.ok(js.includes("persistedValue"), "JS should wire persisted settings behavior");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sean.holung/minicode",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "workspaces": [
     "packages/*"
   ],