@openparachute/agent 0.2.0 → 0.2.3-rc.10

package/src/registry.test.ts

@@ -1,227 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import {
-  resolveChannelEntries,
-  instantiateTransport,
-  loadRegistry,
-  defaultStateDir,
-  type ChannelEntry,
-} from "./registry.ts";
-
-let dir: string;
-const savedToken = process.env.TELEGRAM_BOT_TOKEN;
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "channel-registry-"));
-  delete process.env.TELEGRAM_BOT_TOKEN;
-});
-
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-  if (savedToken === undefined) delete process.env.TELEGRAM_BOT_TOKEN;
-  else process.env.TELEGRAM_BOT_TOKEN = savedToken;
-});
-
-describe("no env synthesis — channels are always explicit", () => {
-  test("no channels.json + TELEGRAM_BOT_TOKEN set → [] (env is NOT a token source)", () => {
-    process.env.TELEGRAM_BOT_TOKEN = "dummy-token";
-    const entries = resolveChannelEntries({ stateDir: dir, loadEnv: false });
-    expect(entries).toEqual([]);
-  });
-
-  test("no channels.json + token only in state-dir .env → still [] after loadEnv", () => {
-    // .env is still loaded (generic vars may live there), but a TELEGRAM_BOT_TOKEN
-    // there no longer synthesizes a channel — per-channel config is required.
-    writeFileSync(join(dir, ".env"), "TELEGRAM_BOT_TOKEN=from-env-file\n");
-    const entries = resolveChannelEntries({ stateDir: dir, loadEnv: true });
-    expect(entries).toEqual([]);
-  });
-
-  test("no channels.json + no token → empty list (caller decides to error)", () => {
-    const entries = resolveChannelEntries({ stateDir: dir, loadEnv: false });
-    expect(entries).toEqual([]);
-  });
-});
-
-describe("explicit channels.json parsing", () => {
-  test("parses multiple named channels", () => {
-    const file = {
-      channels: [
-        { name: "tele-aaron", transport: "telegram", config: { token: "t1" } },
-        { name: "ops", transport: "telegram", config: { token: "t2" } },
-      ],
-    };
-    writeFileSync(join(dir, "channels.json"), JSON.stringify(file));
-    const entries = resolveChannelEntries({ stateDir: dir, loadEnv: false });
-    expect(entries).toHaveLength(2);
-    expect(entries[0]!.name).toBe("tele-aaron");
-    expect(entries[1]!.transport).toBe("telegram");
-  });
-
-  test("channels.json takes precedence over the token fallback", () => {
-    process.env.TELEGRAM_BOT_TOKEN = "dummy";
-    writeFileSync(
-      join(dir, "channels.json"),
-      JSON.stringify({ channels: [{ name: "explicit", transport: "telegram", config: { token: "x" } }] }),
-    );
-    const entries = resolveChannelEntries({ stateDir: dir, loadEnv: false });
-    expect(entries).toEqual([{ name: "explicit", transport: "telegram", config: { token: "x" } }]);
-  });
-
-  test("missing 'channels' array throws clearly", () => {
-    writeFileSync(join(dir, "channels.json"), JSON.stringify({ nope: true }));
-    expect(() => resolveChannelEntries({ stateDir: dir, loadEnv: false })).toThrow(/channels/);
-  });
-
-  test("entry missing name or transport throws clearly", () => {
-    writeFileSync(join(dir, "channels.json"), JSON.stringify({ channels: [{ name: "x" }] }));
-    expect(() => resolveChannelEntries({ stateDir: dir, loadEnv: false })).toThrow(/transport/);
-  });
-});
-
-describe("instantiateTransport", () => {
-  test("telegram entry yields a telegram transport", () => {
-    const entry: ChannelEntry = { name: "t", transport: "telegram", config: { token: "tok" } };
-    const t = instantiateTransport(entry);
-    expect(t.kind).toBe("telegram");
-  });
-
-  test("unknown transport kind errors clearly", () => {
-    const entry: ChannelEntry = { name: "weird", transport: "carrier-pigeon" };
-    expect(() => instantiateTransport(entry)).toThrow(/unknown transport kind "carrier-pigeon"/);
-  });
-
-  test("telegram entry with no token errors clearly (names the channel)", () => {
-    const entry: ChannelEntry = { name: "t", transport: "telegram" };
-    expect(() => instantiateTransport(entry)).toThrow(
-      /telegram channel t requires a per-channel bot token/,
-    );
-  });
-});
-
-describe("loadRegistry", () => {
-  test("builds a live channel map keyed by name", () => {
-    writeFileSync(
-      join(dir, "channels.json"),
-      JSON.stringify({
-        channels: [
-          { name: "a", transport: "telegram", config: { token: "t1", stateDir: dir } },
-          { name: "b", transport: "telegram", config: { token: "t2", stateDir: dir } },
-        ],
-      }),
-    );
-    const reg = loadRegistry({ stateDir: dir, loadEnv: false });
-    expect([...reg.keys()].sort()).toEqual(["a", "b"]);
-    expect(reg.get("a")!.transport.kind).toBe("telegram");
-  });
-
-  test("duplicate channel names throw", () => {
-    writeFileSync(
-      join(dir, "channels.json"),
-      JSON.stringify({
-        channels: [
-          { name: "dup", transport: "telegram", config: { token: "t1", stateDir: dir } },
-          { name: "dup", transport: "telegram", config: { token: "t2", stateDir: dir } },
-        ],
-      }),
-    );
-    expect(() => loadRegistry({ stateDir: dir, loadEnv: false })).toThrow(/duplicate channel name/);
-  });
-
-  test("unknown transport kind surfaces from loadRegistry", () => {
-    writeFileSync(
-      join(dir, "channels.json"),
-      JSON.stringify({ channels: [{ name: "x", transport: "smoke-signal" }] }),
-    );
-    expect(() => loadRegistry({ stateDir: dir, loadEnv: false })).toThrow(/unknown transport kind/);
-  });
-});
-
-// ===========================================================================
-// defaultStateDir — channel→agent rename + back-compat resolution.
-//
-// Resolution order (registry.ts):
-//   1. PARACHUTE_AGENT_STATE_DIR env → legacy PARACHUTE_CHANNEL_STATE_DIR (via
-//      env-compat.agentEnv) — explicit override.
-//   2. ~/.parachute/agent (the NEW default) if it exists.
-//   3. Back-compat: ~/.parachute/channel (legacy) if it exists and agent does not.
-//   4. ~/.parachute/agent (the new default) when neither exists.
-//
-// `defaultStateDir(home?)` takes an injectable home so we exercise the
-// home-dir-default + legacy-fallback branches against a throwaway dir WITHOUT a
-// process-wide `mock.module("os")` — which would leak a faked `homedir()` into
-// other test files (it broke the live-Seatbelt path-confinement tests when an
-// earlier version did exactly that).
-// ===========================================================================
-
-describe("defaultStateDir — env override (new + legacy)", () => {
-  const savedAgent = process.env.PARACHUTE_AGENT_STATE_DIR;
-  const savedChannel = process.env.PARACHUTE_CHANNEL_STATE_DIR;
-  afterEach(() => {
-    if (savedAgent === undefined) delete process.env.PARACHUTE_AGENT_STATE_DIR;
-    else process.env.PARACHUTE_AGENT_STATE_DIR = savedAgent;
-    if (savedChannel === undefined) delete process.env.PARACHUTE_CHANNEL_STATE_DIR;
-    else process.env.PARACHUTE_CHANNEL_STATE_DIR = savedChannel;
-  });
-
-  test("PARACHUTE_AGENT_STATE_DIR (the new var) wins", () => {
-    delete process.env.PARACHUTE_CHANNEL_STATE_DIR;
-    process.env.PARACHUTE_AGENT_STATE_DIR = "/tmp/explicit-agent-state";
-    expect(defaultStateDir()).toBe("/tmp/explicit-agent-state");
-  });
-
-  test("back-compat: legacy PARACHUTE_CHANNEL_STATE_DIR is still honored when the new var is unset", () => {
-    delete process.env.PARACHUTE_AGENT_STATE_DIR;
-    process.env.PARACHUTE_CHANNEL_STATE_DIR = "/tmp/legacy-channel-state";
-    expect(defaultStateDir()).toBe("/tmp/legacy-channel-state");
-  });
-
-  test("the new PARACHUTE_AGENT_STATE_DIR takes precedence over the legacy one", () => {
-    process.env.PARACHUTE_AGENT_STATE_DIR = "/tmp/new-wins";
-    process.env.PARACHUTE_CHANNEL_STATE_DIR = "/tmp/legacy-loses";
-    expect(defaultStateDir()).toBe("/tmp/new-wins");
-  });
-});
-
-describe("defaultStateDir — home-dir default + legacy-dir back-compat", () => {
-  let home: string;
-  const savedAgent = process.env.PARACHUTE_AGENT_STATE_DIR;
-  const savedChannel = process.env.PARACHUTE_CHANNEL_STATE_DIR;
-
-  beforeEach(() => {
-    // A throwaway HOME passed straight to defaultStateDir(home); no env override so
-    // the existence checks drive resolution. No os mock — see the note above.
-    home = mkdtempSync(join(tmpdir(), "agent-home-"));
-    delete process.env.PARACHUTE_AGENT_STATE_DIR;
-    delete process.env.PARACHUTE_CHANNEL_STATE_DIR;
-  });
-  afterEach(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (savedAgent === undefined) delete process.env.PARACHUTE_AGENT_STATE_DIR;
-    else process.env.PARACHUTE_AGENT_STATE_DIR = savedAgent;
-    if (savedChannel === undefined) delete process.env.PARACHUTE_CHANNEL_STATE_DIR;
-    else process.env.PARACHUTE_CHANNEL_STATE_DIR = savedChannel;
-  });
-
-  test("the new default is ~/.parachute/agent when neither dir exists", () => {
-    expect(defaultStateDir(home)).toBe(join(home, ".parachute", "agent"));
-  });
-
-  test("uses the new ~/.parachute/agent when it exists", () => {
-    mkdirSync(join(home, ".parachute", "agent"), { recursive: true });
-    expect(defaultStateDir(home)).toBe(join(home, ".parachute", "agent"));
-  });
-
-  test("back-compat: uses legacy ~/.parachute/channel when ~/.parachute/agent is absent", () => {
-    mkdirSync(join(home, ".parachute", "channel"), { recursive: true });
-    expect(defaultStateDir(home)).toBe(join(home, ".parachute", "channel"));
-  });
-
-  test("the new agent dir wins even when the legacy channel dir also exists", () => {
-    mkdirSync(join(home, ".parachute", "agent"), { recursive: true });
-    mkdirSync(join(home, ".parachute", "channel"), { recursive: true });
-    expect(defaultStateDir(home)).toBe(join(home, ".parachute", "agent"));
-  });
-});

package/src/resolve-port.test.ts

@@ -1,64 +0,0 @@
-/**
- * Port-resolution tests (channel#41).
- *
- * The hub supervisor injects `PORT` from the module's services.json `entry.port`
- * and PROBES that same port for readiness (and reverse-proxies `/agent/*` to
- * it). Pre-#41 the daemon read only `PARACHUTE_AGENT_PORT` (default 1941), so
- * it ignored the supervisor's `PORT` and could bind a different port than the
- * supervisor probed — the supervisor then reported `started_but_unbound` and the
- * proxy routed to a dead port. `resolvePort` now honors `PORT` first so the bound
- * port (which is also the self-registered port) matches what the supervisor
- * assigned.
- *
- * Resolution order: `PORT > PARACHUTE_AGENT_PORT > PARACHUTE_CHANNEL_PORT > 1941`.
- * The legacy `PARACHUTE_CHANNEL_PORT` stays a recognized fallback (back-compat
- * for pre-rename operator setups) but the new `PARACHUTE_AGENT_PORT` wins over it.
- */
-import { describe, test, expect } from "bun:test";
-import { resolvePort } from "./daemon.ts";
-
-describe("resolvePort — PORT > PARACHUTE_AGENT_PORT > PARACHUTE_CHANNEL_PORT > 1941", () => {
-  test("honors the supervisor-injected PORT first", () => {
-    expect(resolvePort({ PORT: "19415" })).toBe(19415);
-  });
-
-  test("PORT wins even when PARACHUTE_AGENT_PORT is also set", () => {
-    expect(resolvePort({ PORT: "1941", PARACHUTE_AGENT_PORT: "19415" })).toBe(1941);
-  });
-
-  test("falls back to PARACHUTE_AGENT_PORT when PORT is unset", () => {
-    expect(resolvePort({ PARACHUTE_AGENT_PORT: "2025" })).toBe(2025);
-  });
-
-  test("the legacy PARACHUTE_CHANNEL_PORT STILL works as a fallback (back-compat)", () => {
-    // Pre-rename operator setups exported PARACHUTE_CHANNEL_PORT; it stays a
-    // recognized tier so those installs keep binding the intended port.
-    expect(resolvePort({ PARACHUTE_CHANNEL_PORT: "2030" })).toBe(2030);
-  });
-
-  test("PARACHUTE_AGENT_PORT wins over the legacy PARACHUTE_CHANNEL_PORT", () => {
-    // Both present → the NEW var takes precedence; the legacy var is only a
-    // fallback for when the new one is absent.
-    expect(resolvePort({ PARACHUTE_AGENT_PORT: "2040", PARACHUTE_CHANNEL_PORT: "2050" })).toBe(2040);
-  });
-
-  test("falls back to the canonical 1941 default when none is set", () => {
-    expect(resolvePort({})).toBe(1941);
-  });
-
-  test("an EMPTY PORT='' falls through to PARACHUTE_AGENT_PORT (|| not ??)", () => {
-    // With `??` an empty string is "defined" → parseInt("") = NaN → bind port 0.
-    // `||` skips the empty string to the next tier.
-    expect(resolvePort({ PORT: "", PARACHUTE_AGENT_PORT: "2000" })).toBe(2000);
-  });
-
-  test("an EMPTY PARACHUTE_AGENT_PORT='' falls through to the legacy PARACHUTE_CHANNEL_PORT", () => {
-    expect(resolvePort({ PARACHUTE_AGENT_PORT: "", PARACHUTE_CHANNEL_PORT: "2060" })).toBe(2060);
-  });
-
-  test("a non-numeric PORT='abc' falls through to the canonical default", () => {
-    // parseInt("abc") = NaN → falsy → falls through past PARACHUTE_AGENT_PORT +
-    // PARACHUTE_CHANNEL_PORT (also unset here) to 1941. No garbage port.
-    expect(resolvePort({ PORT: "abc" })).toBe(1941);
-  });
-});

package/src/routing.test.ts

@@ -1,184 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { ClientRegistry, sseFrame, type ClientSink } from "./routing.ts";
-
-/** A fake sink that records every payload pushed to it. */
-function fakeClient(channel: string): ClientSink & { received: string[] } {
-  const received: string[] = [];
-  return {
-    channel,
-    received,
-    enqueue(payload: string) {
-      received.push(payload);
-    },
-  };
-}
-
-describe("sseFrame", () => {
-  test("serializes an event + JSON data block", () => {
-    expect(sseFrame("message", { a: 1 })).toBe('event: message\ndata: {"a":1}\n\n');
-  });
-});
-
-describe("ClientRegistry routing", () => {
-  test("delivers to subscribers of the channel and NOT others", () => {
-    const reg = new ClientRegistry();
-    const a1 = fakeClient("A");
-    const a2 = fakeClient("A");
-    const b1 = fakeClient("B");
-    reg.add("a1", a1);
-    reg.add("a2", a2);
-    reg.add("b1", b1);
-
-    const delivered = reg.routeToChannel("A", "message", { content: "hi" });
-
-    expect(delivered).toBe(2);
-    expect(a1.received).toHaveLength(1);
-    expect(a2.received).toHaveLength(1);
-    expect(b1.received).toHaveLength(0); // the core property: B never sees A's message
-    expect(a1.received[0]).toContain('"content":"hi"');
-  });
-
-  test("emitting on B does not reach A", () => {
-    const reg = new ClientRegistry();
-    const a1 = fakeClient("A");
-    const b1 = fakeClient("B");
-    reg.add("a1", a1);
-    reg.add("b1", b1);
-
-    reg.routeToChannel("B", "message", { content: "for-b" });
-
-    expect(b1.received).toHaveLength(1);
-    expect(a1.received).toHaveLength(0);
-  });
-
-  test("routing to an unsubscribed channel delivers to nobody", () => {
-    const reg = new ClientRegistry();
-    reg.add("a1", fakeClient("A"));
-    expect(reg.routeToChannel("ghost", "message", {})).toBe(0);
-  });
-
-  test("countForChannel + subscribedChannels reflect subscriptions", () => {
-    const reg = new ClientRegistry();
-    reg.add("a1", fakeClient("A"));
-    reg.add("a2", fakeClient("A"));
-    reg.add("b1", fakeClient("B"));
-    expect(reg.size).toBe(3);
-    expect(reg.countForChannel("A")).toBe(2);
-    expect(reg.countForChannel("B")).toBe(1);
-    expect(reg.countForChannel("C")).toBe(0);
-    expect(reg.subscribedChannels().sort()).toEqual(["A", "B"]);
-  });
-
-  test("a throwing client is dropped and does not block delivery to others", () => {
-    const reg = new ClientRegistry();
-    const good = fakeClient("A");
-    const bad: ClientSink = {
-      channel: "A",
-      enqueue() {
-        throw new Error("stream closed");
-      },
-    };
-    reg.add("good", good);
-    reg.add("bad", bad);
-
-    const delivered = reg.routeToChannel("A", "message", { content: "x" });
-
-    expect(delivered).toBe(1); // only the good client counted
-    expect(good.received).toHaveLength(1);
-    expect(reg.has("bad")).toBe(false); // bad client evicted
-    expect(reg.has("good")).toBe(true);
-  });
-
-  test("remove unsubscribes a client", () => {
-    const reg = new ClientRegistry();
-    const a1 = fakeClient("A");
-    reg.add("a1", a1);
-    reg.remove("a1");
-    reg.routeToChannel("A", "message", {});
-    expect(a1.received).toHaveLength(0);
-    expect(reg.size).toBe(0);
-  });
-});
-
-describe("ClientRegistry live SSE integration", () => {
-  test("two SSE clients on different channels each get only their channel", async () => {
-    const reg = new ClientRegistry();
-
-    const server = Bun.serve({
-      port: 0,
-      hostname: "127.0.0.1",
-      idleTimeout: 0,
-      fetch(req) {
-        const url = new URL(req.url);
-        if (url.pathname === "/events") {
-          const channel = url.searchParams.get("channel") ?? "default";
-          const id = crypto.randomUUID();
-          const stream = new ReadableStream<string>({
-            start(controller) {
-              reg.add(id, { channel, enqueue: (p) => controller.enqueue(p) });
-              controller.enqueue(": connected\n\n");
-            },
-            cancel() {
-              reg.remove(id);
-            },
-          });
-          return new Response(stream, {
-            headers: { "content-type": "text/event-stream" },
-          });
-        }
-        return new Response("not found", { status: 404 });
-      },
-    });
-
-    const base = `http://127.0.0.1:${server.port}`;
-
-    async function openAndRead(channel: string): Promise<{
-      read: () => Promise<string>;
-      cancel: () => void;
-    }> {
-      const res = await fetch(`${base}/events?channel=${channel}`);
-      const reader = res.body!.getReader();
-      const decoder = new TextDecoder();
-      return {
-        async read() {
-          // Read until we get a non-comment data frame.
-          while (true) {
-            const { value, done } = await reader.read();
-            if (done) return "";
-            const chunk = decoder.decode(value, { stream: true });
-            if (chunk.includes("event:")) return chunk;
-          }
-        },
-        cancel() {
-          reader.cancel().catch(() => {});
-        },
-      };
-    }
-
-    const a = await openAndRead("A");
-    const b = await openAndRead("B");
-
-    // Wait until both clients have registered.
-    const start = Date.now();
-    while (reg.size < 2 && Date.now() - start < 1000) {
-      await new Promise((r) => setTimeout(r, 5));
-    }
-    expect(reg.size).toBe(2);
-
-    // Emit only on A.
-    reg.routeToChannel("A", "message", { content: "only-A" });
-
-    const aFrame = await a.read();
-    expect(aFrame).toContain("only-A");
-
-    // B should receive nothing on channel A; emit on B to prove B's stream is live.
-    reg.routeToChannel("B", "message", { content: "only-B" });
-    const bFrame = await b.read();
-    expect(bFrame).toContain("only-B");
-    expect(bFrame).not.toContain("only-A");
-
-    a.cancel();
-    b.cancel();
-    server.stop(true);
-  });
-});