agent-dealer 1.2.0 → 1.2.2

package/bundle/server/dist/routes/repository-mappings.test.js

@@ -0,0 +1,110 @@
+// NOT-260: GET/PUT /api/settings/repository-mappings — normalized round
+// trip plus HTTP 400 with a readable error that preserves the last valid array.
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import Fastify from "fastify";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-repo-mappings-routes-"));
+const { migrate } = await import("../db/index.js");
+const { registerRepositoryMappingsRoutes } = await import("./repository-mappings.js");
+before(() => {
+    migrate();
+});
+async function buildApp() {
+    const app = Fastify();
+    await registerRepositoryMappingsRoutes(app);
+    return app;
+}
+test("GET returns { mappings: [] } on a fresh install", async () => {
+    const app = await buildApp();
+    const res = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.json(), { mappings: [] });
+});
+test("PUT persists and returns normalized mappings", async () => {
+    const app = await buildApp();
+    const res = await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/agent-dealer" }] },
+    });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/agent-dealer" }],
+    });
+    const get = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.deepEqual(get.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/agent-dealer" }],
+    });
+});
+test("PUT editing the repository overwrites the label's value", async () => {
+    const app = await buildApp();
+    await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/agent-dealer" }] },
+    });
+    const res = await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }] },
+    });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/other" }],
+    });
+});
+test("PUT with duplicate normalized labels returns 400 and preserves the array", async () => {
+    const app = await buildApp();
+    await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }] },
+    });
+    const res = await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: {
+            mappings: [
+                { label: "agent-dealer", repository: "not-so-fat/agent-dealer" },
+                { label: " AGENT-DEALER ", repository: "not-so-fat/other" },
+            ],
+        },
+    });
+    assert.equal(res.statusCode, 400);
+    const body = res.json();
+    assert.ok(body.error && body.error.length > 0, "readable error");
+    const get = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.deepEqual(get.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/other" }],
+    });
+});
+test("PUT with empty labels, invalid repos, or 101 rows returns 400 atomically", async () => {
+    const app = await buildApp();
+    await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "keep", repository: "a/b" }] },
+    });
+    const lastValid = { mappings: [{ label: "keep", repository: "github.com/a/b" }] };
+    for (const payload of [
+        { mappings: [{ label: "   ", repository: "a/b" }] },
+        { mappings: [{ label: "ok", repository: "not a repo!!" }] },
+        {
+            mappings: Array.from({ length: 101 }, (_, i) => ({ label: `l${i}`, repository: "a/b" })),
+        },
+        { mappings: "nope" },
+    ]) {
+        const res = await app.inject({
+            method: "PUT",
+            url: "/api/settings/repository-mappings",
+            payload,
+        });
+        assert.equal(res.statusCode, 400);
+        assert.ok(res.json().error, "readable error");
+    }
+    const get = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.deepEqual(get.json(), lastValid);
+});

package/bundle/server/dist/routes/runtime-capacity.test.js

@@ -17,12 +17,14 @@ process.env.AGENT_DEALER_SKIP_AGENT_HEALTH = "1";
 process.env.AGENT_DEALER_CODEX_CAPACITY_REFRESH = "off";
 const { migrate } = await import("../db/index.js");
 const { createAgent } = await import("../repository/agents.js");
-const { clearAllCapacitySnapshots, listCapacitySnapshots } = await import("../repository/runtime-capacity.js");
-const { fixtureMultiWindowAdapter } = await import("../capacity/adapter.js");
+const { clearAllCapacitySnapshots, listCapacitySnapshots, recordCapacitySnapshots } = await import("../repository/runtime-capacity.js");
+const { fixtureMultiWindowAdapter, normalizeAdapterWindow } = await import("../capacity/adapter.js");
 const { refreshCapacityFromAdapters } = await import("../capacity/service.js");
 const { resetMuseCapacityRefreshState } = await import("../capacity/muse.js");
+const { refreshCodexCapacityFromAppServer } = await import("../capacity/codex-app-server.js");
 const { registerRoutes } = await import("./index.js");
 const { RuntimeCapacityResponse } = await import("@agent-dealer/shared");
+const FAKE_CODEX = new URL("../capacity/fixtures/fake-codex-app-server.mjs", import.meta.url).pathname;
 migrate();
 async function buildApp() {
     const app = Fastify();
@@ -104,6 +106,74 @@ test("GET triggers the Muse refresh when muse_code is configured", async () => {
         resetMuseCapacityRefreshState();
     }
 });
+test("GET serves one logical Codex pair after a dedup refresh of legacy duplicates", async () => {
+    // NOT-263: databases written by older versions hold both the aggregate
+    // aliases (`codex_rate_limit_primary/secondary`) and the detailed rows for
+    // the same logical pair. One refresh against a mirroring payload must
+    // delete the aliases, and GET must serve each logical window once.
+    clearAllCapacitySnapshots();
+    createAgent({
+        name: "route-codex-dedup",
+        runtime: "codex_local",
+        deckId: "55555555-5555-4555-8555-555555555555",
+    });
+    const seedNow = Date.now();
+    const seedObserved = new Date(seedNow).toISOString();
+    const seed = (windowKey, providerBucket, durationMinutes) => normalizeAdapterWindow("codex_local", {
+        windowKey,
+        providerBucket,
+        durationMinutes,
+        providerLabel: providerBucket,
+        usedValue: 9,
+        usedUnit: "percent",
+        usedPercent: 9,
+        resetAt: new Date(seedNow + 2 * 3600_000).toISOString(),
+        observedAt: seedObserved,
+        source: "supported_protocol",
+    }, seedNow);
+    recordCapacitySnapshots("codex_local", [
+        seed("codex_rate_limit_primary", "primary", 300),
+        seed("codex_rate_limit_secondary", "secondary", 10080),
+        seed("codex_limit_main_primary", "main/primary", 300),
+        seed("codex_limit_main_secondary", "main/secondary", 10080),
+    ]);
+    assert.equal(listCapacitySnapshots("codex_local").length, 4);
+    const now = Date.now();
+    await refreshCodexCapacityFromAppServer({
+        command: process.execPath,
+        args: [FAKE_CODEX],
+        env: { FAKE_CODEX_MODE: "mirror", FAKE_CODEX_NOW_MS: String(now) },
+        timeoutMs: 10_000,
+        nowMs: now,
+    });
+    const app = await buildApp();
+    try {
+        const res = await app.inject({ method: "GET", url: "/api/runtime-capacity" });
+        assert.equal(res.statusCode, 200);
+        const body = RuntimeCapacityResponse.parse(res.json());
+        const codex = body.runtimes.find((r) => r.runtime === "codex_local");
+        assert.ok(codex, "codex_local entry served");
+        assert.equal(codex.unavailableReason, null);
+        const keys = codex.windows.map((w) => w.windowKey);
+        assert.ok(!keys.some((k) => k.startsWith("codex_rate_limit_")), `no aggregate aliases, got ${keys}`);
+        // Mirrored `main` pair renders once (5H + weekly); the genuinely
+        // distinct `extra` bucket renders as its own pair.
+        assert.deepEqual([...keys].sort(), [
+            "codex_limit_extra_primary",
+            "codex_limit_extra_secondary",
+            "codex_limit_main_primary",
+            "codex_limit_main_secondary",
+        ]);
+        const mainPrimary = codex.windows.find((w) => w.windowKey === "codex_limit_main_primary");
+        assert.equal(mainPrimary.displayLabel, "5H");
+        assert.equal(mainPrimary.remainingPercent, 30);
+        const raw = JSON.stringify(res.json());
+        assert.ok(!raw.includes("evidence"), "no evidence pointers leak to the browser");
+    }
+    finally {
+        await app.close();
+    }
+});
 test("GET /api/runtime-capacity serves a configured Codex account without spawning", async () => {
     clearAllCapacitySnapshots();
     createAgent({

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -22,7 +22,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agent-dealer/shared": "1.2.0",
+    "@agent-dealer/shared": "1.2.2",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",