channels.tools 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "channels.tools",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Channels for the pi coding agent: connect channel servers that push events into a live session — wake it when idle, queue when busy — and proxy their tools. A client for the claude/channel convention.",
   "type": "module",
   "license": "MIT",

package/src/index.test.ts

@@ -30,7 +30,11 @@ function fakePi() {
     sendMessage(message: unknown, opts: unknown) { customs.push({ msg: message, opts }); },
     registerTool(def: ToolDef) { registered.push(def.name); tools.set(def.name, def); },
     unregisterTool(name: string) { unregistered.push(name); tools.delete(name); },
-    getAllTools() { return [{ name: "bash" }, { name: "read" }]; },
+    // Faithful to pi 0.84.4: getAllTools() reads the full _toolDefinitions
+    // registry, so a tool this extension registered on a prior pass is still
+    // returned here (there is no working unregisterTool to evict it). A static
+    // [bash, read] would hide the reload self-collision this guards against.
+    getAllTools() { return [{ name: "bash" }, { name: "read" }, ...[...tools.keys()].map((name) => ({ name }))]; },
     getActiveTools() { return ["bash", "read"]; },
     setActiveTools(_names: string[]) {},
   };
@@ -161,6 +165,38 @@ test("a tool still works after a resume re-registers it against a fresh connecti
   await fire("session_shutdown");
 });
 
+test("a reload does not self-collide: the second pass re-registers the bare name, dropping nothing", async () => {
+  // The reload self-collision: pi.getAllTools() returns this extension's own
+  // prior registration (no working unregisterTool in 0.84.4), so a naive
+  // builtins baseline mistakes the leaked fake_status for a builtin, prefixes
+  // to fake_fake_status, and after enough reloads even the prefixed name is
+  // taken and the tool is dropped — with a misleading "collides with a builtin"
+  // reason. The fix excludes the extension's own names from the baseline.
+  const { pi, fire, tools, registered } = fakePi();
+  createExtension(pi as never, {
+    env: {},
+    loadConfig: () => ({ fake: { command: process.execPath, args: [FAKE] } }),
+  });
+  await fire("session_start", { reason: "startup" });
+  await new Promise((r) => setTimeout(r, 300));
+  // Two more reloads: without the fix, getAllTools() now reports fake_status,
+  // so the second pass prefixes and the third drops the prefixed name too.
+  await fire("session_start", { reason: "resume" });
+  await new Promise((r) => setTimeout(r, 300));
+  await fire("session_start", { reason: "resume" });
+  await new Promise((r) => setTimeout(r, 300));
+  assert.ok(tools.has("fake_status"), "the bare name must survive every reload");
+  assert.ok(!tools.has("fake_fake_status"), "the extension must never prefix against its own prior registration");
+  assert.ok(
+    !registered.includes("fake_fake_status"),
+    `no reload may register a self-prefixed name; registered: ${registered.join(", ")}`,
+  );
+  const tool = tools.get("fake_status");
+  const result = (await tool!.execute("call-1", {})) as { content: Array<{ text: string }> };
+  assert.deepEqual(result.content, [{ type: "text", text: "fake ok" }], "the bare tool must still work after reloads");
+  await fire("session_shutdown");
+});
+
 test("a tool result with isError:true is signaled by throwing, not returned silently", async () => {
   const { pi, fire, tools } = fakePi();
   createExtension(pi as never, {

package/src/index.ts

@@ -77,6 +77,14 @@ export function createExtension(pi: any, deps: Deps = {}): void {
       }
     | undefined;
   const registeredNames = new Set<string>();
+  // Every name this extension has EVER registered, never cleared. pi 0.84.4
+  // has no working unregisterTool, so getAllTools() keeps returning our own
+  // prior registrations across reload/resume/fork. Without excluding them from
+  // the builtins baseline below, registerTools mistakes its own leaked tool
+  // for a builtin, prefixes it, and eventually drops it ("collides with a
+  // builtin"). registerTool replaces by name, so re-registering the bare
+  // self-namespaced name every reload is correct.
+  const ownNames = new Set<string>();
 
   function uiSetStatus(status: string): void {
     ui?.setStatus?.("channels", status === "" ? undefined : status);
@@ -91,7 +99,9 @@ export function createExtension(pi: any, deps: Deps = {}): void {
   }
 
   function registerTools(connections: Connection[]): void {
-    const builtins = (pi.getAllTools?.() ?? []).map((t: { name: string }) => t.name);
+    const builtins = (pi.getAllTools?.() ?? [])
+      .map((t: { name: string }) => t.name)
+      .filter((name: string) => !ownNames.has(name));
     const { resolved, dropped } = resolveToolNames(
       connections.map((c) => ({ name: c.name, tools: c.tools })),
       builtins,
@@ -143,6 +153,7 @@ export function createExtension(pi: any, deps: Deps = {}): void {
       // built from `connections.map(...)` above.
       const conn = connections.find((c) => c.name === entry.server)!;
       const def = conn.tools.find((t) => t.name === entry.original);
+      ownNames.add(entry.registered);
       registeredNames.add(entry.registered);
       pi.registerTool({
         name: entry.registered,