pennyrouter 0.2.12 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/src/launch.js

@@ -257,6 +257,35 @@ export function renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth }) {
   ].join("\n");
 }
 
+/**
+ * Per-command settings for `penny codex`.
+ *
+ * A named Codex profile causes a second configuration/MCP refresh during startup on
+ * some Codex builds. Keep the same provider contract, but pass it as CLI overrides
+ * so it is part of the initial configuration load instead of a later profile layer.
+ * These values deliberately contain no PennyRouter secret: the key remains in the
+ * process environment and is read by Codex through env_key/env_http_headers.
+ */
+export function codexLaunchOverrides({ gatewayBaseUrl, subscriptionAuth }) {
+  const baseUrl = `${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1`;
+  const overrides = [
+    'model_provider="pennyrouter"',
+    'model_providers.pennyrouter.name="PennyRouter"',
+    `model_providers.pennyrouter.base_url=${JSON.stringify(baseUrl)}`,
+    'model_providers.pennyrouter.wire_api="responses"',
+    'model_providers.pennyrouter.supports_websockets=false',
+  ];
+  if (subscriptionAuth) {
+    overrides.push(
+      'model_providers.pennyrouter.requires_openai_auth=true',
+      'model_providers.pennyrouter.env_http_headers={ "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }',
+    );
+  } else {
+    overrides.push('model_providers.pennyrouter.env_key="PENNYROUTER_API_KEY"');
+  }
+  return overrides;
+}
+
 async function writeClaudeLaunchSettings() {
   const native = (await readJsonFile(join(homeDir(), ".claude", "settings.json"), null)) || {};
   const overlay = { disableClaudeAiConnectors: true };
@@ -449,7 +478,15 @@ export function buildPennyInvocation(harness, args, config) {
     };
   }
   if (harness === "codex") {
-    return { command: "codex", args: ["--profile", "pennyrouter", ...args], env };
+    const overrides = codexLaunchOverrides({
+      gatewayBaseUrl: config.gateway_base_url,
+      subscriptionAuth: Boolean(item.subscription_auth),
+    });
+    return {
+      command: "codex",
+      args: overrides.flatMap((override) => ["-c", override]).concat(args),
+      env,
+    };
   }
   throw new Error(`Unknown Penny harness "${harness}". Try penny claude or penny codex.`);
 }

package/src/launch.test.js

@@ -8,6 +8,7 @@ import {
   claudeLaunchSettingsPath,
   claudeUserSkillPath,
   codexLaunchProfilePath,
+  codexLaunchOverrides,
   configurePennyHarness,
   fileMode,
   installPennyRuntime,
@@ -110,7 +111,16 @@ async function main() {
     assert.equal(claude.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, undefined);
 
     const codex = buildPennyInvocation("codex", ["resume", "--last"], config);
-    assert.deepEqual(codex.args, ["--profile", "pennyrouter", "resume", "--last"]);
+    assert.deepEqual(codex.args, [
+      "-c", 'model_provider="pennyrouter"',
+      "-c", 'model_providers.pennyrouter.name="PennyRouter"',
+      "-c", 'model_providers.pennyrouter.base_url="https://gateway.example/v1"',
+      "-c", 'model_providers.pennyrouter.wire_api="responses"',
+      "-c", 'model_providers.pennyrouter.supports_websockets=false',
+      "-c", 'model_providers.pennyrouter.requires_openai_auth=true',
+      "-c", 'model_providers.pennyrouter.env_http_headers={ "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }',
+      "resume", "--last",
+    ]);
     assert.equal(codex.env.PENNYROUTER_API_KEY, "pr-super-secret");
     assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
     assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
@@ -155,6 +165,9 @@ async function main() {
     });
     assert.ok(paid.includes('env_key = "PENNYROUTER_API_KEY"'));
     assert.ok(!paid.includes("requires_openai_auth"));
+    assert.deepEqual(codexLaunchOverrides({
+      gatewayBaseUrl: "https://gateway.example/", subscriptionAuth: false,
+    }).slice(-1), ['model_providers.pennyrouter.env_key="PENNYROUTER_API_KEY"']);
   } finally {
     for (const key of ENV_KEYS) {
       if (previous[key] === undefined) delete process.env[key];

package/src/mcp.js

@@ -38,7 +38,12 @@ const TOOLS = [
       "Fetch an AI conversation from a share link (ChatGPT, Claude, Gemini, Perplexity) and " +
       "return its transcript. Use when the user wants to discuss, summarize or ask about a " +
       "past conversation. The transcript enters your context — for long threads that are " +
-      "meant to be continued as work, prefer thread_resume.",
+      "meant to be continued as work, prefer thread_resume. " +
+      "This tool is the only supported way to read a share link: those pages are " +
+      "JavaScript-rendered shells that return markup, not conversation, to a plain fetch. Never " +
+      "fall back to fetching the URL directly, and never guess at the contents. If this call " +
+      "does not return a transcript it was blocked, still awaiting approval, or errored — say " +
+      "so plainly and stop, rather than inferring a reason such as a size or display limit.",
     inputSchema: {
       type: "object",
       properties: {
@@ -54,7 +59,10 @@ const TOOLS = [
       "session (Claude Code or Codex), so the user can resume into it and continue coding with " +
       "that conversation as history. Use when the user wants to CONTINUE or BUILD FROM a past " +
       "chat rather than talk about it. Returns a session id and path; the transcript is " +
-      "deliberately NOT returned, so importing a long thread costs you no context.",
+      "deliberately NOT returned, so importing a long thread costs you no context. That is by " +
+      "design and is not a failure — do not read the thread another way to 'check' it, and do " +
+      "not fetch the share URL directly. Report the resume command to the user. If this call " +
+      "does not return, it was blocked, still awaiting approval, or errored — say so and stop.",
     inputSchema: {
       type: "object",
       properties: {

package/src/mcp.test.js

@@ -114,6 +114,15 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
     ["thread_read", "thread_resume"],
   );
 
+  // Observed in a real session: a blocked tool call is indistinguishable from an empty one, so
+  // the model explained the silence as a "size/display limitation" and fell back to fetching
+  // the share URL directly — pulling 574KB of JS-shell markup into the context that
+  // thread_resume exists to protect. The descriptions have to rule that out explicitly.
+  for (const tool of byId.get(2).result.tools) {
+    assert.match(tool.description, /not fetch|Never fall back to fetching/i, tool.name);
+    assert.match(tool.description, /blocked/i, tool.name);
+  }
+
   // 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");

package/src/thread-session.js

@@ -126,6 +126,15 @@ export function buildRecords(thread, { cwd, sessionId, version, gitBranch = "" }
     parentUuid = uuid;
   };
 
+  // The resume picker labels a session with its `ai-title` and falls back to the first user
+  // message, which here is the orientation preamble — so without this every import reads as
+  // "This session was imported by PennyRouter from a…". The source thread already has a real
+  // title; use it. Deliberately outside the parentUuid chain: this record type carries no
+  // uuid/parentUuid in Claude Code's own sessions, and threading it would break the walk.
+  if (thread.title) {
+    records.push({ type: "ai-title", aiTitle: thread.title, sessionId });
+  }
+
   push("user", { role: "user", content: orientation(thread) });
   push("assistant", {
     role: "assistant",
@@ -160,7 +169,9 @@ export function buildRecords(thread, { cwd, sessionId, version, gitBranch = "" }
 export function assertChained(records) {
   const seen = new Set();
   let roots = 0;
-  for (const record of records) {
+  // Metadata records (`ai-title`) sit outside the conversation and carry no uuid, matching
+  // Claude Code's own sessions. Only the message chain is walked.
+  for (const record of records.filter((r) => r.uuid)) {
     if (record.parentUuid === null) roots += 1;
     else if (!seen.has(record.parentUuid)) {
       throw new Error(`session records are not chained (orphan ${record.uuid})`);

package/src/thread-session.test.js

@@ -59,21 +59,31 @@ const records = buildRecords(thread, {
   version: "2.1.226",
 });
 
-// Orientation pair, then one record per replayable turn. The empty user turn and the system
-// turn are dropped: neither is something a resumed agent should replay as its own.
+// A title record, then the orientation pair, then one record per replayable turn. The empty
+// user turn and the system turn are dropped: neither is something a resumed agent should
+// replay as its own.
 assert.deepEqual(
   records.map((r) => r.type),
-  ["user", "assistant", "user", "assistant"],
+  ["ai-title", "user", "assistant", "user", "assistant"],
 );
 
+// The resume picker labels a session with ai-title and otherwise falls back to the first user
+// message — which is the orientation preamble, so every import would read as "This session was
+// imported by PennyRouter from a…" instead of naming the conversation.
+const title = records.find((r) => r.type === "ai-title");
+assert.equal(title.aiTitle, "Kickplate removal");
+assert.equal(title.sessionId, "sid");
+assert.ok(!title.uuid && !("parentUuid" in title), "metadata sits outside the message chain");
+
 const serialized = JSON.stringify(records);
 assert.ok(!serialized.includes("REASONING-TRACE"), "thinking must never reach a handoff");
 assert.ok(!serialized.includes("SYSTEM-PREAMBLE"), "system turns are not replayed");
 assert.ok(serialized.includes("print('hi')"), "code blocks survive as fenced text");
-assert.ok(records[0].message.content.includes("Perplexity"), "orientation names the origin");
+const firstTurn = records.find((r) => r.type === "user");
+assert.ok(firstTurn.message.content.includes("Perplexity"), "orientation names the origin");
 assert.ok(orientation(thread).includes("Do not re-litigate"));
 
-for (const record of records) {
+for (const record of records.filter((r) => r.type !== "ai-title")) {
   assert.equal(record.sessionId, "sid");
   assert.equal(record.cwd, "/tmp/ws");
   assert.equal(record.isSidechain, false);
@@ -85,8 +95,9 @@ for (const record of records) {
 // A break in the parentUuid list truncates history silently, which reads as a working import
 // that lost half the conversation. That has to fail loudly instead.
 assertChained(records);
-assert.equal(records[0].parentUuid, null);
-assert.equal(records[1].parentUuid, records[0].uuid);
+const chain = records.filter((r) => r.uuid);
+assert.equal(chain[0].parentUuid, null);
+assert.equal(chain[1].parentUuid, chain[0].uuid);
 
 assert.throws(
   () => assertChained([{ uuid: "a", parentUuid: "nope" }]),