pennyrouter 0.2.8 → 0.2.10

package/src/mcp.test.js

@@ -0,0 +1,182 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const binary = join(here, "..", "bin", "pennyrouter.js");
+
+const thread = {
+  schema_version: 1,
+  source: "perplexity_share",
+  title: "Kickplate removal",
+  origin_app: "Perplexity",
+  source_url: "https://www.perplexity.ai/search/x",
+  token_estimate: 892,
+  warnings: [],
+  messages: [
+    { key: "m0", ordinal: 0, role: "user", blocks: [{ type: "text", text: "UNIQUE-QUESTION" }] },
+    {
+      key: "m1",
+      ordinal: 1,
+      role: "assistant",
+      blocks: [{ type: "text", text: "UNIQUE-ANSWER" }],
+    },
+  ],
+};
+
+/** Stand in for the gateway so no scraping or network access is involved. */
+function stubGateway(handler) {
+  const server = createServer((req, res) => {
+    let body = "";
+    req.on("data", (c) => (body += c));
+    req.on("end", () => handler(req, body, res));
+  });
+  return new Promise((resolve) => {
+    server.listen(0, () => resolve({ server, port: server.address().port }));
+  });
+}
+
+/** Drive the server over stdio and collect the responses to `requests`. */
+function rpc(requests, { port, home }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [binary, "mcp", "--penny-key", "pr-test", "--gateway-base-url", `http://127.0.0.1:${port}`],
+      { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, HOME: home } },
+    );
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => (out += d));
+    child.stderr.on("data", (d) => (err += d));
+    child.on("error", reject);
+    child.on("close", () => {
+      const messages = out
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+      resolve({ messages, stderr: err });
+    });
+    for (const request of requests) child.stdin.write(JSON.stringify(request) + "\n");
+    setTimeout(() => child.stdin.end(), 900);
+  });
+}
+
+const home = mkdtempSync(join(tmpdir(), "pr-mcp-home-"));
+const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
+
+// -- happy path -----------------------------------------------------------
+{
+  let requestBody = null;
+  let authHeader = null;
+  const { server, port } = await stubGateway((req, body, res) => {
+    requestBody = body;
+    authHeader = req.headers.authorization;
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify(thread));
+  });
+
+  const { messages } = await rpc(
+    [
+      { jsonrpc: "2.0", id: 1, method: "initialize", params: {} },
+      { jsonrpc: "2.0", id: 2, method: "tools/list" },
+      {
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: { name: "thread_read", arguments: { url: "https://www.perplexity.ai/search/x" } },
+      },
+      {
+        jsonrpc: "2.0",
+        id: 4,
+        method: "tools/call",
+        params: {
+          name: "thread_resume",
+          arguments: { url: "https://www.perplexity.ai/search/x", directory: workspace },
+        },
+      },
+    ],
+    { port, home },
+  );
+  server.close();
+
+  const byId = new Map(messages.map((m) => [m.id, m]));
+
+  assert.equal(byId.get(1).result.protocolVersion, "2024-11-05");
+  assert.equal(byId.get(1).result.serverInfo.name, "pennyrouter");
+
+  assert.deepEqual(
+    byId.get(2).result.tools.map((t) => t.name),
+    ["thread_read", "thread_resume"],
+  );
+
+  // The URL is forwarded to the gateway under the caller's key; no provider logic runs here.
+  assert.equal(JSON.parse(requestBody).url, "https://www.perplexity.ai/search/x");
+  assert.equal(authHeader, "Bearer pr-test");
+
+  // thread_read puts the conversation in the caller's context — that is its whole purpose.
+  const read = byId.get(3).result.content[0].text;
+  assert.ok(read.includes("UNIQUE-QUESTION"));
+  assert.ok(read.includes("UNIQUE-ANSWER"));
+
+  // thread_resume must NOT: the asymmetry between the two tools is the reason both exist, and
+  // a regression here silently reintroduces the token cost the tool was built to avoid.
+  const resumed = byId.get(4).result.content[0].text;
+  assert.ok(!resumed.includes("UNIQUE-QUESTION"), "thread_resume must not return the transcript");
+  assert.ok(!resumed.includes("UNIQUE-ANSWER"), "thread_resume must not return the transcript");
+  assert.ok(resumed.includes("claude --resume"), "it must tell the user how to resume");
+  assert.ok(resumed.includes("Kickplate removal"));
+  assert.equal(byId.get(4).result.isError, undefined);
+}
+
+// -- gateway failures reach the model as readable text --------------------
+{
+  const { server, port } = await stubGateway((req, body, res) => {
+    res.statusCode = 400;
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify({ detail: "That link returned 404. It may be private or deleted." }));
+  });
+
+  const { messages } = await rpc(
+    [
+      {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "thread_read", arguments: { url: "https://chatgpt.com/share/gone" } },
+      },
+    ],
+    { port, home },
+  );
+  server.close();
+
+  const result = messages.find((m) => m.id === 1).result;
+  // Reported as an errored *result*, not a JSON-RPC error: the model should be able to relay
+  // what went wrong instead of the call vanishing inside the harness.
+  assert.equal(result.isError, true);
+  assert.ok(result.content[0].text.includes("may be private or deleted"));
+}
+
+// -- protocol hygiene -----------------------------------------------------
+{
+  const { server, port } = await stubGateway((req, body, res) => res.end("{}"));
+  const { messages } = await rpc(
+    [
+      { jsonrpc: "2.0", method: "notifications/initialized" }, // no id: must not be answered
+      { jsonrpc: "2.0", id: 7, method: "ping" },
+      { jsonrpc: "2.0", id: 8, method: "no/such/method" },
+    ],
+    { port, home },
+  );
+  server.close();
+
+  assert.equal(messages.length, 2, "a notification must never get a response");
+  assert.deepEqual(messages.find((m) => m.id === 7).result, {});
+  assert.equal(messages.find((m) => m.id === 8).error.code, -32601);
+}
+
+console.log("mcp tests passed");

package/src/session.js

@@ -1,157 +1,157 @@
-export const APP_URL = process.env.PENNYROUTER_APP_URL || "https://pennyrouter.com";
-
-export function maskKey(key) {
-  if (!key || key.length < 8) return "pr-...";
-  return `${key.slice(0, 3)}...${key.slice(-4)}`;
-}
-
-export async function createCliSession({ appUrl = APP_URL, harnesses, accountMode = "existing" }) {
-  const label = `${platformName()} / ${harnesses.join(",") || "PennyRouter"}`;
-  const response = await fetch(`${appUrl}/api/cli/session`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      harness: harnesses.join(","),
-      label,
-      account_mode: accountMode,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to create setup session: HTTP ${response.status}`);
-  }
-
-  return response.json();
-}
-
-export async function pollForKey(session) {
-  const interval = session.poll_interval_ms || 2000;
-  const deadline = Date.now() + (session.expires_in_s || 900) * 1000;
-
-  while (Date.now() < deadline) {
-    const response = await fetch(session.claim_url);
-    if (!response.ok) throw new Error(`Claim failed: HTTP ${response.status}`);
-    const body = await response.json();
-
-    if (body.status === "ready" && body.api_key) return body;
-    if (body.status === "expired") throw new Error("Setup session expired. Run install again.");
-    if (body.status === "claimed") throw new Error("Setup session was already claimed. Run install again.");
-    await sleep(interval);
-  }
-
-  throw new Error("Timed out waiting for authorization.");
-}
-
-export function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// Encrypt and store a user-owned upstream credential against the account server-side,
-// so the pr- key alone unlocks the selected harness and the provider secret is never
-// written to harness configuration.
-export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider, token }) {
-  const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({ provider, token }),
-  });
-  if (!response.ok) {
-    let detail = "";
-    try {
-      detail = (await response.json())?.detail || "";
-    } catch {
-      // non-JSON body; fall through to status-only message
-    }
-    throw new Error(`Storing ${provider} credential failed: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
-  }
-  return response.json();
-}
-
-export async function storeAnthropicToken({ gatewayBaseUrl, apiKey, token }) {
-  return storeUpstreamCredential({
-    gatewayBaseUrl, apiKey, provider: "anthropic_oauth", token,
-  });
-}
-
-// Exercise the exact modern Claude Code request feature that has historically broken at
-// proxy boundaries BEFORE changing ~/.claude/settings.json (a user-global redirect). This
-// is intentionally sent through /v1/messages rather than a generic /health endpoint, so it
-// proves the gateway can parse the modern beta/tool/context-management envelope. The exact
-// one-token install probe is answered locally by compatible gateways and costs nothing.
-export async function probeClaudeCodeGateway({ gatewayBaseUrl, apiKey }) {
-  const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/messages?beta=true`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 20_000);
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      signal: controller.signal,
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${apiKey}`,
-        "anthropic-beta": "compact-2026-01-12",
-      },
-      body: JSON.stringify({
-        model: "Sonnet 5 (PennyRouter)",
-        max_tokens: 1,
-        stream: false,
-        messages: [{ role: "user", content: "Reply OK." }],
-        tools: [{
-          name: "pennyrouter_install_probe",
-          description: "No-op compatibility probe; do not call it.",
-          input_schema: { type: "object", properties: {} },
-        }],
-        context_management: { edits: [{ type: "compact_20260112" }] },
-      }),
-    });
-  } catch (error) {
-    if (error?.name === "AbortError") {
-      throw new Error("Gateway compatibility check timed out; no Claude Code settings were changed.");
-    }
-    throw new Error(`Gateway compatibility check failed; no Claude Code settings were changed: ${error?.message || error}`);
-  } finally {
-    clearTimeout(timer);
-  }
-  if (!response.ok) {
-    let detail = "";
-    try {
-      detail = (await response.text()).slice(0, 500).replace(/\s+/g, " ").trim();
-    } catch {
-      // Status alone is enough for a safe failure.
-    }
-    throw new Error(
-      `Gateway compatibility check failed: HTTP ${response.status}${detail ? ` — ${detail}` : ""}. `
-      + "The PennyRouter gateway rejected a modern Claude Code request; deploy/fix the gateway "
-      + "before retrying. No Claude Code settings were changed.",
-    );
-  }
-  return true;
-}
-
-// Best-effort "forget my Claude token" on uninstall. Never throws — a cleanup that
-// can't reach the network shouldn't block removing the local integration.
-export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
-  if (!gatewayBaseUrl || !apiKey) return false;
-  try {
-    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/anthropic`;
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: { authorization: `Bearer ${apiKey}` },
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-
-function platformName() {
-  if (process.platform === "darwin") return "Mac";
-  if (process.platform === "win32") return "Windows";
-  if (process.platform === "linux") return "Linux";
-  return "Machine";
-}
+export const APP_URL = process.env.PENNYROUTER_APP_URL || "https://pennyrouter.com";
+
+export function maskKey(key) {
+  if (!key || key.length < 8) return "pr-...";
+  return `${key.slice(0, 3)}...${key.slice(-4)}`;
+}
+
+export async function createCliSession({ appUrl = APP_URL, harnesses, accountMode = "existing" }) {
+  const label = `${platformName()} / ${harnesses.join(",") || "PennyRouter"}`;
+  const response = await fetch(`${appUrl}/api/cli/session`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      harness: harnesses.join(","),
+      label,
+      account_mode: accountMode,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to create setup session: HTTP ${response.status}`);
+  }
+
+  return response.json();
+}
+
+export async function pollForKey(session) {
+  const interval = session.poll_interval_ms || 2000;
+  const deadline = Date.now() + (session.expires_in_s || 900) * 1000;
+
+  while (Date.now() < deadline) {
+    const response = await fetch(session.claim_url);
+    if (!response.ok) throw new Error(`Claim failed: HTTP ${response.status}`);
+    const body = await response.json();
+
+    if (body.status === "ready" && body.api_key) return body;
+    if (body.status === "expired") throw new Error("Setup session expired. Run install again.");
+    if (body.status === "claimed") throw new Error("Setup session was already claimed. Run install again.");
+    await sleep(interval);
+  }
+
+  throw new Error("Timed out waiting for authorization.");
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Encrypt and store a user-owned upstream credential against the account server-side,
+// so the pr- key alone unlocks the selected harness and the provider secret is never
+// written to harness configuration.
+export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider, token }) {
+  const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ provider, token }),
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.json())?.detail || "";
+    } catch {
+      // non-JSON body; fall through to status-only message
+    }
+    throw new Error(`Storing ${provider} credential failed: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
+  }
+  return response.json();
+}
+
+export async function storeAnthropicToken({ gatewayBaseUrl, apiKey, token }) {
+  return storeUpstreamCredential({
+    gatewayBaseUrl, apiKey, provider: "anthropic_oauth", token,
+  });
+}
+
+// Exercise the exact modern Claude Code request feature that has historically broken at
+// proxy boundaries BEFORE changing ~/.claude/settings.json (a user-global redirect). This
+// is intentionally sent through /v1/messages rather than a generic /health endpoint, so it
+// proves the gateway can parse the modern beta/tool/context-management envelope. The exact
+// one-token install probe is answered locally by compatible gateways and costs nothing.
+export async function probeClaudeCodeGateway({ gatewayBaseUrl, apiKey }) {
+  const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/messages?beta=true`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 20_000);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+        "anthropic-beta": "compact-2026-01-12",
+      },
+      body: JSON.stringify({
+        model: "Sonnet 5 (PennyRouter)",
+        max_tokens: 1,
+        stream: false,
+        messages: [{ role: "user", content: "Reply OK." }],
+        tools: [{
+          name: "pennyrouter_install_probe",
+          description: "No-op compatibility probe; do not call it.",
+          input_schema: { type: "object", properties: {} },
+        }],
+        context_management: { edits: [{ type: "compact_20260112" }] },
+      }),
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw new Error("Gateway compatibility check timed out; no Claude Code settings were changed.");
+    }
+    throw new Error(`Gateway compatibility check failed; no Claude Code settings were changed: ${error?.message || error}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).slice(0, 500).replace(/\s+/g, " ").trim();
+    } catch {
+      // Status alone is enough for a safe failure.
+    }
+    throw new Error(
+      `Gateway compatibility check failed: HTTP ${response.status}${detail ? ` — ${detail}` : ""}. `
+      + "The PennyRouter gateway rejected a modern Claude Code request; deploy/fix the gateway "
+      + "before retrying. No Claude Code settings were changed.",
+    );
+  }
+  return true;
+}
+
+// Best-effort "forget my Claude token" on uninstall. Never throws — a cleanup that
+// can't reach the network shouldn't block removing the local integration.
+export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
+  if (!gatewayBaseUrl || !apiKey) return false;
+  try {
+    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/anthropic`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${apiKey}` },
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+function platformName() {
+  if (process.platform === "darwin") return "Mac";
+  if (process.platform === "win32") return "Windows";
+  if (process.platform === "linux") return "Linux";
+  return "Machine";
+}

package/src/session.test.js

@@ -1,44 +1,44 @@
-import assert from "node:assert/strict";
-import { createCliSession, probeClaudeCodeGateway } from "./session.js";
-
-const originalFetch = globalThis.fetch;
-
-try {
-  let sessionRequest;
-  globalThis.fetch = async (url, options) => {
-    sessionRequest = { url, options };
-    return {
-      ok: true,
-      json: async () => ({ session_id: "session-test" }),
-    };
-  };
-  await createCliSession({ appUrl: "https://app.example", harnesses: ["claude-code"] });
-  assert.equal(sessionRequest.url, "https://app.example/api/cli/session");
-  assert.equal(JSON.parse(sessionRequest.options.body).account_mode, "existing");
-
-  let seen;
-  globalThis.fetch = async (url, options) => {
-    seen = { url, options };
-    return { ok: true, status: 200 };
-  };
-  assert.equal(await probeClaudeCodeGateway({
-    gatewayBaseUrl: "https://gateway.example/", apiKey: "pr-test",
-  }), true);
-  assert.equal(seen.url, "https://gateway.example/v1/messages?beta=true");
-  assert.equal(seen.options.headers.authorization, "Bearer pr-test");
-  assert.equal(seen.options.headers["anthropic-beta"], "compact-2026-01-12");
-  const body = JSON.parse(seen.options.body);
-  assert.equal(body.max_tokens, 1);
-  assert.equal(body.context_management.edits[0].type, "compact_20260112");
-  assert.equal(body.tools[0].name, "pennyrouter_install_probe");
-
-  globalThis.fetch = async () => ({
-    ok: false, status: 502, text: async () => "context_management rejected",
-  });
-  await assert.rejects(
-    probeClaudeCodeGateway({ gatewayBaseUrl: "https://gateway.example", apiKey: "pr-test" }),
-    /HTTP 502.*No Claude Code settings were changed/,
-  );
-} finally {
-  globalThis.fetch = originalFetch;
-}
+import assert from "node:assert/strict";
+import { createCliSession, probeClaudeCodeGateway } from "./session.js";
+
+const originalFetch = globalThis.fetch;
+
+try {
+  let sessionRequest;
+  globalThis.fetch = async (url, options) => {
+    sessionRequest = { url, options };
+    return {
+      ok: true,
+      json: async () => ({ session_id: "session-test" }),
+    };
+  };
+  await createCliSession({ appUrl: "https://app.example", harnesses: ["claude-code"] });
+  assert.equal(sessionRequest.url, "https://app.example/api/cli/session");
+  assert.equal(JSON.parse(sessionRequest.options.body).account_mode, "existing");
+
+  let seen;
+  globalThis.fetch = async (url, options) => {
+    seen = { url, options };
+    return { ok: true, status: 200 };
+  };
+  assert.equal(await probeClaudeCodeGateway({
+    gatewayBaseUrl: "https://gateway.example/", apiKey: "pr-test",
+  }), true);
+  assert.equal(seen.url, "https://gateway.example/v1/messages?beta=true");
+  assert.equal(seen.options.headers.authorization, "Bearer pr-test");
+  assert.equal(seen.options.headers["anthropic-beta"], "compact-2026-01-12");
+  const body = JSON.parse(seen.options.body);
+  assert.equal(body.max_tokens, 1);
+  assert.equal(body.context_management.edits[0].type, "compact_20260112");
+  assert.equal(body.tools[0].name, "pennyrouter_install_probe");
+
+  globalThis.fetch = async () => ({
+    ok: false, status: 502, text: async () => "context_management rejected",
+  });
+  await assert.rejects(
+    probeClaudeCodeGateway({ gatewayBaseUrl: "https://gateway.example", apiKey: "pr-test" }),
+    /HTTP 502.*No Claude Code settings were changed/,
+  );
+} finally {
+  globalThis.fetch = originalFetch;
+}