agent-dealer 1.1.0 → 1.1.1

package/bundle/server/dist/runners/usage-cap.js

@@ -29,12 +29,11 @@ function fallbackUntil(nowMs = Date.now()) {
 function capReason(runtime, detail) {
     return `${runtime} usage capped — ${detail}`;
 }
+// `status` is the verdict on the plan window. `overageStatus` only says whether pay-as-you-go
+// overage is available: orgs with overage disabled report "rejected" on every event of a healthy
+// session (status "allowed", isUsingOverage false), so it must not open a deferral by itself.
 function isHardCapRateLimitInfo(info) {
-    if (info.status === "rejected")
-        return true;
-    if (info.overageStatus === "rejected")
-        return true;
-    return false;
+    return info.status === "rejected";
 }
 function signalFromRateLimitInfo(runtime, info, evidence, nowMs) {
     if (!isHardCapRateLimitInfo(info))

package/bundle/server/dist/runners/usage-cap.test.js

@@ -26,6 +26,15 @@ test("Claude rate_limit_event rejected writes runtime_availability with resetsAt
         assert.equal(avail.until, cap.unavailableUntil);
     }
 });
+test("allowed rate_limit_event with overage rejected (org disabled overage) is not a cap", () => {
+    const raw = [
+        '{"type":"rate_limit_event","rate_limit_info":{"status":"allowed","resetsAt":1784283600,"rateLimitType":"five_hour","overageStatus":"rejected","overageDisabledReason":"org_level_disabled_until","isUsingOverage":false,"unifiedWindows":{"five_hour":{"utilization":0.17,"resetsAt":1784283600}}}}',
+        '{"type":"result","is_error":false,"result":"done"}',
+    ].join("\n");
+    assert.equal(detectUsageCapFromNdjson(raw, "claude_code"), null);
+    assert.equal(recordUsageCapFromEvents(parseNdjson(raw), "claude_code"), null);
+    assert.equal(runtimeAvailability("claude_code").available, true);
+});
 test("allowed_warning rate_limit_event is ignored (hard cap only)", () => {
     const raw = [
         '{"type":"rate_limit_event","rate_limit_info":{"status":"allowed_warning","resetsAt":1784283600,"rateLimitType":"five_hour"}}',

package/bundle/server/package.json

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

package/bundle/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/shared",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/start.js

@@ -124,6 +124,24 @@ async function ensurePortAvailable(host, port, probe) {
     }
     return null;
 }
+/**
+ * `--force` restart: stop the existing instance, then require the port to actually be free.
+ * `runStop()` can return 0 while a listener survives (an explicit AGENT_DEALER_HOME without run.json
+ * refuses to sweep the port), and `ensurePortAvailable` treats a healthy agent-dealer as available —
+ * so without this check the replacement server would launch onto an occupied port.
+ */
+async function stopForForcedRestart(host, port) {
+    console.log("[agent-dealer] Restarting existing instance (--force) ...");
+    await runStop();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    if ((await probeAgentDealer(host, port)).up) {
+        console.error(`[agent-dealer] --force could not stop the agent-dealer still listening on ${host}:${port}.`);
+        console.error("[agent-dealer] It is not owned by this AGENT_DEALER_HOME, so it was left running.");
+        console.error(`[agent-dealer] Stop it from its own home, or kill it manually: lsof -ti :${port} -sTCP:LISTEN | xargs kill`);
+        return 1;
+    }
+    return null;
+}
 export async function runStart(options = {}) {
     const envFile = loadProdEnvFile();
     const home = prodHomeDir();
@@ -142,9 +160,10 @@ export async function runStart(options = {}) {
         const probe = await probeAgentDealer(host, port);
         if (probe.up) {
             if (options.force) {
-                console.log("[agent-dealer] Restarting existing instance (--force) ...");
-                await runStop();
-                await new Promise((resolve) => setTimeout(resolve, 500));
+                const stopError = await stopForForcedRestart(host, port);
+                if (stopError !== null) {
+                    return stopError;
+                }
             }
             else {
                 printRunningEndpoints(base, uiDist);
@@ -152,8 +171,7 @@ export async function runStart(options = {}) {
                 return 0;
             }
         }
-        const refreshedProbe = options.force ? await probeAgentDealer(host, port) : probe;
-        const portError = await ensurePortAvailable(host, port, refreshedProbe);
+        const portError = await ensurePortAvailable(host, port, options.force ? await probeAgentDealer(host, port) : probe);
         if (portError !== null) {
             return portError;
         }
@@ -163,9 +181,10 @@ export async function runStart(options = {}) {
     const probe = await probeAgentDealer(host, port);
     if (probe.up) {
         if (options.force) {
-            console.log("[agent-dealer] Restarting existing instance (--force) ...");
-            await runStop();
-            await new Promise((resolve) => setTimeout(resolve, 500));
+            const stopError = await stopForForcedRestart(host, port);
+            if (stopError !== null) {
+                return stopError;
+            }
         }
         else {
             printRunningEndpoints(base, uiDist);
@@ -173,8 +192,7 @@ export async function runStart(options = {}) {
             return 0;
         }
     }
-    const refreshedProbe = options.force ? await probeAgentDealer(host, port) : probe;
-    const portError = await ensurePortAvailable(host, port, refreshedProbe);
+    const portError = await ensurePortAvailable(host, port, options.force ? await probeAgentDealer(host, port) : probe);
     if (portError !== null) {
         return portError;
     }

package/dist/stop.js

@@ -39,17 +39,25 @@ export async function runStop() {
         }
         clearRunState();
     }
+    // An explicit AGENT_DEALER_HOME means "only this home" (smoke tests, side-by-side installs).
+    // Its run.json is the sole proof of ownership, so never sweep the port: with no run state the
+    // port falls back to the bundled 2222, which belongs to the default install.
+    const isolatedHome = Boolean(process.env.AGENT_DEALER_HOME?.trim());
     let probe = await probeAgentDealer(host, port);
     if (probe.up) {
-        for (const pid of listListeningPids(port)) {
-            if (terminatePid(pid, `listener on :${port}`)) {
-                stopped += 1;
+        if (!isolatedHome) {
+            for (const pid of listListeningPids(port)) {
+                if (terminatePid(pid, `listener on :${port}`)) {
+                    stopped += 1;
+                }
             }
         }
-        await waitForShutdown(host, port);
-        probe = await probeAgentDealer(host, port);
+        if (!isolatedHome || state) {
+            await waitForShutdown(host, port);
+            probe = await probeAgentDealer(host, port);
+        }
     }
-    if (probe.up) {
+    if (probe.up && (!isolatedHome || state)) {
         console.warn("[agent-dealer] agent-dealer still responds on configured port. Kill remaining processes manually:");
         console.warn(`  lsof -ti :${port} -sTCP:LISTEN | xargs kill`);
         return 1;

package/dist/stop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/stop.test.js

@@ -0,0 +1,131 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { runStart } from "./start.js";
+import { runStop } from "./stop.js";
+const HEALTH_SERVER = `
+const http = require("node:http");
+const server = http.createServer((req, res) => {
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify({ ok: true }));
+});
+server.listen(0, "127.0.0.1", () => console.log(server.address().port));
+`;
+/** A separate process answering /health, standing in for an agent-dealer server. */
+async function startFakeServer() {
+    const child = spawn(process.execPath, ["-e", HEALTH_SERVER], { stdio: ["ignore", "pipe", "inherit"] });
+    const port = await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.stdout.once("data", (chunk) => resolve(Number(String(chunk).trim())));
+    });
+    return { child, port };
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitUntilDead(pid) {
+    for (let i = 0; i < 25; i += 1) {
+        if (!isAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+}
+async function withEnv(env, fn) {
+    const saved = Object.fromEntries(Object.keys(env).map((key) => [key, process.env[key]]));
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    try {
+        await fn();
+    }
+    finally {
+        for (const [key, value] of Object.entries(saved)) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+    }
+}
+function tempHome() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "agent-dealer-stop-"));
+}
+test("stop with an explicit AGENT_DEALER_HOME and no run state never kills a listener on the fallback port", async () => {
+    const { child, port } = await startFakeServer();
+    const home = tempHome();
+    try {
+        await withEnv({ AGENT_DEALER_HOME: home, PORT: String(port), WEB_PORT: undefined }, async () => {
+            assert.equal(await runStop(), 0);
+        });
+        assert.equal(isAlive(child.pid), true, "the unrelated listener must survive an isolated-home stop");
+    }
+    finally {
+        child.kill("SIGKILL");
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("stop with an explicit AGENT_DEALER_HOME still terminates the pids recorded in its run.json", async () => {
+    const { child, port } = await startFakeServer();
+    const home = tempHome();
+    fs.writeFileSync(path.join(home, "run.json"), JSON.stringify({ host: "127.0.0.1", port, serverPid: child.pid, cliPid: 2 ** 22, startedAt: new Date().toISOString() }));
+    try {
+        await withEnv({ AGENT_DEALER_HOME: home, PORT: undefined, WEB_PORT: undefined }, async () => {
+            assert.equal(await runStop(), 0);
+        });
+        assert.equal(await waitUntilDead(child.pid), true);
+    }
+    finally {
+        child.kill("SIGKILL");
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("stop on the default home keeps sweeping the port when run.json is lost", async () => {
+    const { child, port } = await startFakeServer();
+    const home = tempHome();
+    try {
+        await withEnv({ AGENT_DEALER_HOME: undefined, HOME: home, USERPROFILE: home, PORT: String(port), WEB_PORT: undefined }, async () => {
+            assert.equal(await runStop(), 0);
+        });
+        assert.equal(await waitUntilDead(child.pid), true);
+    }
+    finally {
+        child.kill("SIGKILL");
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+async function assertForcedStartRefusesUnownedListener(options) {
+    const { child, port } = await startFakeServer();
+    const home = tempHome();
+    try {
+        await withEnv({ AGENT_DEALER_HOME: home, PORT: String(port), WEB_PORT: undefined }, async () => {
+            // The isolated-home stop leaves the listener up (no run.json = no proof of ownership).
+            // Forced start must fail instead of launching a second server onto the occupied port.
+            assert.equal(await runStart({ force: true, daemon: options.daemon, port }), 1);
+        });
+        assert.equal(isAlive(child.pid), true, "the unrelated listener must survive a forced start");
+        assert.equal(fs.existsSync(path.join(home, "run.json")), false, "no run state may be written for a server that never launched");
+    }
+    finally {
+        child.kill("SIGKILL");
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+}
+test("start --force in the foreground fails when the isolated-home stop leaves a listener up", async () => {
+    await assertForcedStartRefusesUnownedListener({ daemon: false });
+});
+test("start --daemon --force fails when the isolated-home stop leaves a listener up", async () => {
+    await assertForcedStartRefusesUnownedListener({ daemon: true });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dealer",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Human control plane for agent execution — queue, plan approval, audit",
   "license": "MIT",
   "type": "module",