@sjawhar/opencode-legion-envoy 0.6.0 → 0.6.1

package/src/__tests__/log.test.ts

@@ -1,135 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-import { createLogger } from "../log";
-
-let logDir: string;
-
-beforeEach(async () => {
-  logDir = await mkdtemp(path.join(tmpdir(), "envoy-plugin-log-"));
-});
-
-afterEach(async () => {
-  await rm(logDir, { recursive: true, force: true });
-});
-
-describe("envoy-plugin logger", () => {
-  // The whole point of this module: plugins run in-process with OpenCode's
-  // TUI, so any console.warn/console.error byte goes straight to the terminal
-  // and corrupts the render. Plugin diagnostics must go to a file instead.
-  it("writes warn/error/info to the configured log file, NOT to console", async () => {
-    const consoleWarn = mock(() => {});
-    const consoleError = mock(() => {});
-    const consoleLog = mock(() => {});
-    const originalWarn = console.warn;
-    const originalError = console.error;
-    const originalLog = console.log;
-    console.warn = consoleWarn;
-    console.error = consoleError;
-    console.log = consoleLog;
-    try {
-      const logger = createLogger({ logDir });
-      logger.warn("a-warn");
-      logger.error("an-error");
-      logger.info("some-info");
-      await logger.flush();
-
-      expect(consoleWarn).not.toHaveBeenCalled();
-      expect(consoleError).not.toHaveBeenCalled();
-      expect(consoleLog).not.toHaveBeenCalled();
-
-      const logFile = path.join(logDir, "envoy-plugin.log");
-      const contents = await readFile(logFile, "utf-8");
-      expect(contents).toContain("a-warn");
-      expect(contents).toContain("an-error");
-      expect(contents).toContain("some-info");
-      expect(contents).toContain("WARN");
-      expect(contents).toContain("ERROR");
-      expect(contents).toContain("INFO");
-    } finally {
-      console.warn = originalWarn;
-      console.error = originalError;
-      console.log = originalLog;
-    }
-  });
-
-  it("creates the log directory if it doesn't exist", async () => {
-    const nested = path.join(logDir, "deeply", "nested");
-    const logger = createLogger({ logDir: nested });
-    logger.warn("hello");
-    await logger.flush();
-    const contents = await readFile(path.join(nested, "envoy-plugin.log"), "utf-8");
-    expect(contents).toContain("hello");
-  });
-
-  it("prefixes each line with an ISO timestamp so logs are sortable", async () => {
-    const logger = createLogger({ logDir });
-    logger.warn("x");
-    await logger.flush();
-    const contents = await readFile(path.join(logDir, "envoy-plugin.log"), "utf-8");
-    // Match leading ISO-8601 datetime like 2026-05-30T22:35:01.123Z
-    expect(contents).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z /);
-  });
-
-  it("appends across calls instead of truncating", async () => {
-    const logger = createLogger({ logDir });
-    logger.warn("first");
-    logger.warn("second");
-    await logger.flush();
-    const contents = await readFile(path.join(logDir, "envoy-plugin.log"), "utf-8");
-    expect(contents).toContain("first");
-    expect(contents).toContain("second");
-    expect(contents.split("\n").filter((l) => l.length > 0).length).toBe(2);
-  });
-
-  it("never throws on logging errors — diagnostics must not crash the host", async () => {
-    // Point at a path that cannot be created (a parent that exists as a file).
-    const blockingFile = path.join(logDir, "blocker");
-    const fs = await import("node:fs/promises");
-    await fs.writeFile(blockingFile, "");
-    const logger = createLogger({ logDir: path.join(blockingFile, "child") });
-    expect(() => logger.warn("x")).not.toThrow();
-    await expect(logger.flush()).resolves.toBeUndefined();
-  });
-});
-
-describe("no console.* in plugin source (regression guard)", () => {
-  // Plugins load in-process with OpenCode's TUI; any direct console.warn /
-  // console.error / console.log write goes straight to the terminal and
-  // corrupts the render. All diagnostics must route through the file logger.
-  it("does not write to console anywhere outside __tests__ and log.ts", async () => {
-    const { readdir, readFile, stat } = await import("node:fs/promises");
-    const root = path.resolve(import.meta.dir, "..");
-
-    async function walk(dir: string): Promise<string[]> {
-      const entries = await readdir(dir);
-      const out: string[] = [];
-      for (const name of entries) {
-        if (name === "__tests__" || name === "node_modules") continue;
-        const full = path.join(dir, name);
-        const s = await stat(full);
-        if (s.isDirectory()) out.push(...(await walk(full)));
-        else if (name.endsWith(".ts") || name.endsWith(".tsx")) out.push(full);
-      }
-      return out;
-    }
-
-    const files = await walk(root);
-    const offenders: Array<{ file: string; line: number; text: string }> = [];
-    for (const file of files) {
-      // log.ts is allowed to mention console in its module docstring — it's
-      // the module explaining the prohibition.
-      if (file.endsWith("/log.ts")) continue;
-      const lines = (await readFile(file, "utf-8")).split("\n");
-      lines.forEach((text, idx) => {
-        if (/^\s*(?:\/\/|\*| \*)/.test(text)) return; // comments are fine
-        if (/\bconsole\.(warn|error|log)\s*\(/.test(text)) {
-          offenders.push({ file: path.relative(root, file), line: idx + 1, text });
-        }
-      });
-    }
-    expect(offenders).toEqual([]);
-  });
-});

package/src/__tests__/port.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-import { resolvePort } from "../port";
-
-describe("resolvePort", () => {
-  const noopExec = (async () => {
-    throw new Error("ss not available");
-  }) as Parameters<typeof resolvePort>[1];
-
-  const ssOutput = (pid: number, port: number) =>
-    [
-      "State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process",
-      `LISTEN 0      511    127.0.0.1:${port}  0.0.0.0:*  users:(("bun",pid=${pid},fd=6))`,
-      "",
-    ].join("\n");
-
-  describe("URL port extraction", () => {
-    it("returns port from standard non-default URL", async () => {
-      expect(await resolvePort(new URL("http://127.0.0.1:4096"), noopExec)).toBe(4096);
-    });
-
-    it("returns port for high serve ports", async () => {
-      expect(await resolvePort(new URL("http://127.0.0.1:13381"), noopExec)).toBe(13381);
-    });
-
-    it("returns port for localhost URLs", async () => {
-      expect(await resolvePort(new URL("http://localhost:4096"), noopExec)).toBe(4096);
-    });
-
-    it("returns port for IPv6 URLs", async () => {
-      expect(await resolvePort(new URL("http://[::1]:4096"), noopExec)).toBe(4096);
-    });
-
-    it("skips exec entirely when URL port is valid", async () => {
-      const exec = mock(async () => ssOutput(process.pid, 9999));
-      expect(await resolvePort(new URL("http://127.0.0.1:4096"), exec as never)).toBe(4096);
-      expect(exec).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("ss fallback", () => {
-    it("uses ss when URL has no port (default HTTP)", async () => {
-      const exec = mock(async () => ssOutput(process.pid, 4096));
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBe(4096);
-      expect(exec).toHaveBeenCalledWith("ss", ["-tlnp"], { encoding: "utf-8" });
-    });
-
-    it("uses ss when URL port is 0", async () => {
-      // URL("http://127.0.0.1:0").port is "0", which is not > 0
-      const exec = mock(async () => ssOutput(process.pid, 13381));
-      expect(await resolvePort(new URL("http://127.0.0.1:0"), exec as never)).toBe(13381);
-    });
-
-    it("ignores ss lines with different PIDs", async () => {
-      const exec = mock(async () => ssOutput(99999, 4096));
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBeNull();
-    });
-
-    it("handles multiple ss entries and picks the matching PID", async () => {
-      const output = [
-        "State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process",
-        `LISTEN 0      511    127.0.0.1:8080  0.0.0.0:*  users:(("node",pid=99999,fd=6))`,
-        `LISTEN 0      511    127.0.0.1:4096  0.0.0.0:*  users:(("bun",pid=${process.pid},fd=7))`,
-        "",
-      ].join("\n");
-      const exec = mock(async () => output);
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBe(4096);
-    });
-
-    it("handles IPv6 listening addresses in ss output", async () => {
-      const output = [
-        "State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process",
-        `LISTEN 0      511    [::]:4096  [::]:*  users:(("bun",pid=${process.pid},fd=6))`,
-        "",
-      ].join("\n");
-      const exec = mock(async () => output);
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBe(4096);
-    });
-
-    it("works with async exec that resolves after a delay", async () => {
-      const exec = mock(
-        () =>
-          new Promise<string>((resolve) =>
-            setTimeout(() => resolve(ssOutput(process.pid, 5555)), 10)
-          )
-      );
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBe(5555);
-    });
-  });
-
-  describe("failure cases", () => {
-    it("returns null when ss is not available", async () => {
-      expect(await resolvePort(new URL("http://127.0.0.1"), noopExec)).toBeNull();
-    });
-
-    it("returns null when ss returns empty output", async () => {
-      const exec = mock(async () => "");
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBeNull();
-    });
-
-    it("returns null when async exec rejects", async () => {
-      const exec = mock(async () => {
-        throw new Error("command failed");
-      });
-      expect(await resolvePort(new URL("http://127.0.0.1"), exec as never)).toBeNull();
-    });
-  });
-
-  describe("edge cases", () => {
-    it("URL.port is empty string for default HTTP port 80", async () => {
-      // http://127.0.0.1:80 → URL.port is "" (80 is default for http)
-      const url = new URL("http://127.0.0.1:80");
-      expect(url.port).toBe("");
-      const exec = mock(async () => ssOutput(process.pid, 4096));
-      expect(await resolvePort(url, exec as never)).toBe(4096);
-    });
-
-    it("URL.port is empty string for default HTTPS port 443", async () => {
-      const url = new URL("https://127.0.0.1:443");
-      expect(url.port).toBe("");
-      const exec = mock(async () => ssOutput(process.pid, 4096));
-      expect(await resolvePort(url, exec as never)).toBe(4096);
-    });
-  });
-});

package/src/__tests__/ss.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { portFromSsOutput } from "../ss";
-
-const header = "State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process";
-
-function listen(local: string, pid: number): string {
-  return `LISTEN 0      511    ${local}  0.0.0.0:*  users:(("bun",pid=${pid},fd=6))`;
-}
-
-describe("portFromSsOutput", () => {
-  test("returns null when the process id has no listening socket", () => {
-    const output = [header, listen("127.0.0.1:4096", 99_999)].join("\n");
-
-    expect(portFromSsOutput(output, 12_345)).toBeNull();
-  });
-
-  test("skips matching process rows whose local address column is malformed", () => {
-    const output = [header, listen("not-a-local-address", 123)].join("\n");
-
-    expect(portFromSsOutput(output, 123)).toBeNull();
-  });
-
-  test("ignores zero and negative local ports", () => {
-    const output = [header, listen("127.0.0.1:0", 123), listen("127.0.0.1:-1", 123)].join("\n");
-
-    expect(portFromSsOutput(output, 123)).toBeNull();
-  });
-
-  test("matches the full pid token before returning a port", () => {
-    const output = [header, listen("127.0.0.1:9999", 123), listen("127.0.0.1:4444", 12)].join("\n");
-
-    expect(portFromSsOutput(output, 12)).toBe(4444);
-  });
-});

package/src/__tests__/tui-port.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  parsePort,
-  resolveCurrentProcessPort,
-  resolveSessionProcessPort,
-  resolveTuiPort,
-} from "../tui-port";
-
-describe("parsePort", () => {
-  it("returns the port from a standard http URL", () => {
-    expect(parsePort("http://localhost:4096")).toBe(4096);
-  });
-
-  it("returns the port from a 127.0.0.1 URL", () => {
-    expect(parsePort("http://127.0.0.1:13381")).toBe(13381);
-  });
-
-  it("returns the port from an https URL with explicit port", () => {
-    expect(parsePort("https://example.com:8443")).toBe(8443);
-  });
-
-  it("returns null when the URL has no explicit port", () => {
-    expect(parsePort("http://localhost")).toBe(null);
-  });
-
-  it("returns null for the empty string", () => {
-    expect(parsePort("")).toBe(null);
-  });
-
-  it("returns null for a non-URL string", () => {
-    expect(parsePort("not a url")).toBe(null);
-  });
-
-  it("returns null for a malformed port", () => {
-    expect(parsePort("http://localhost:abc")).toBe(null);
-  });
-
-  it("returns null for undefined input", () => {
-    expect(parsePort(undefined)).toBe(null);
-  });
-});
-
-describe("resolveCurrentProcessPort", () => {
-  it("returns a listening port for the current process from ss output", () => {
-    const exec = () =>
-      `LISTEN 0 512 127.0.0.1:41895 0.0.0.0:* users:(("opencode",pid=${process.pid},fd=23))`;
-
-    expect(resolveCurrentProcessPort(exec)).toBe(41895);
-  });
-
-  it("returns null when ss has no current process match", () => {
-    const exec = () => 'LISTEN 0 512 127.0.0.1:41895 0.0.0.0:* users:(("opencode",pid=123,fd=23))';
-
-    expect(resolveCurrentProcessPort(exec)).toBe(null);
-  });
-});
-
-describe("resolveTuiPort", () => {
-  it("prefers the base URL port", () => {
-    const exec = () => {
-      throw new Error("should not call ss");
-    };
-
-    expect(resolveTuiPort("http://127.0.0.1:4096", undefined, exec)).toBe(4096);
-  });
-
-  it("falls back to the current process listening port", () => {
-    const exec = () =>
-      `LISTEN 0 512 127.0.0.1:35291 0.0.0.0:* users:(("opencode",pid=${process.pid},fd=23))`;
-
-    expect(resolveTuiPort(undefined, undefined, exec)).toBe(35291);
-  });
-});
-
-describe("resolveSessionProcessPort", () => {
-  it("resolves the listening port for an opencode session process", () => {
-    const sessionID = "ses_test";
-    const exec = (command: string) => {
-      if (command === "ps") return `123 opencode --port 0 -s ${sessionID}`;
-      return 'LISTEN 0 512 127.0.0.1:42823 0.0.0.0:* users:(("opencode",pid=123,fd=23))';
-    };
-
-    expect(resolveSessionProcessPort(sessionID, exec)).toBe(42823);
-  });
-});

package/src/config/__tests__/index.test.ts

@@ -1,93 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { logger } from "../../log";
-import { loadEnvoyConfig } from "..";
-
-describe("loadEnvoyConfig", () => {
-  let homeDir: string;
-  let repoDir: string;
-  let warn: ReturnType<typeof spyOn>;
-
-  beforeEach(async () => {
-    homeDir = await mkdtemp(path.join(tmpdir(), "envoy-home-"));
-    repoDir = await mkdtemp(path.join(tmpdir(), "envoy-repo-"));
-    // Spy on the file logger — plugin diagnostics route there instead of
-    // console to keep stderr clean for the in-process TUI host.
-    warn = spyOn(logger, "warn").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    warn.mockRestore();
-  });
-
-  async function writeJson(filePath: string, value: unknown) {
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(value));
-  }
-
-  it("loads user-only config", async () => {
-    await writeJson(path.join(homeDir, ".config", "opencode", "envoy.json"), {
-      natsUrls: ["nats://127.0.0.1:4222"],
-      dispatch: { enabled: true, defaultRepo: "sjawhar/legion" },
-    });
-
-    await expect(loadEnvoyConfig(repoDir, { homeDir })).resolves.toEqual({
-      natsUrls: ["nats://127.0.0.1:4222"],
-      dispatch: { enabled: true, defaultRepo: "sjawhar/legion" },
-    });
-  });
-
-  it("loads repo-only config", async () => {
-    await writeJson(path.join(repoDir, ".opencode", "envoy.json"), {
-      dispatch: { serverUrl: "http://localhost:8766" },
-    });
-
-    await expect(loadEnvoyConfig(repoDir, { homeDir })).resolves.toEqual({
-      dispatch: { serverUrl: "http://localhost:8766" },
-    });
-  });
-
-  it("shallow-merges user config with repo config and lets repo dispatch keys win", async () => {
-    await writeJson(path.join(homeDir, ".config", "opencode", "envoy.json"), {
-      natsUrls: ["nats://user:4222"],
-      dispatch: { enabled: false, defaultRepo: "sjawhar/legion" },
-    });
-    await writeJson(path.join(repoDir, ".opencode", "envoy.json"), {
-      dispatch: { enabled: true, serverUrl: "http://localhost:8766" },
-    });
-
-    await expect(loadEnvoyConfig(repoDir, { homeDir })).resolves.toEqual({
-      natsUrls: ["nats://user:4222"],
-      dispatch: {
-        enabled: true,
-        defaultRepo: "sjawhar/legion",
-        serverUrl: "http://localhost:8766",
-      },
-    });
-  });
-
-  it("returns empty config and warns on invalid JSON", async () => {
-    const configPath = path.join(homeDir, ".config", "opencode", "envoy.json");
-    await mkdir(path.dirname(configPath), { recursive: true });
-    await writeFile(configPath, "{");
-
-    await expect(loadEnvoyConfig(repoDir, { homeDir })).resolves.toEqual({});
-    expect(warn).toHaveBeenCalled();
-  });
-
-  it("returns empty config and warns on schema-invalid JSON", async () => {
-    await writeJson(path.join(repoDir, ".opencode", "envoy.json"), {
-      natsUrls: "nats://127.0.0.1:4222",
-    });
-
-    await expect(loadEnvoyConfig(repoDir, { homeDir })).resolves.toEqual({});
-    expect(warn).toHaveBeenCalled();
-  });
-
-  it("returns empty config when files are missing", async () => {
-    await expect(loadEnvoyConfig(repoDir, { homeDir })).resolves.toEqual({});
-    expect(warn).not.toHaveBeenCalled();
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "baseUrl": ".",
-    "paths": {
-      "@legion/contracts": ["../contracts/src/index.ts"],
-      "@legion/envoy-client/defaults": ["../envoy-client/src/defaults.ts"],
-      "@legion/envoy-client/tool-contract": ["../envoy-client/src/tool-contract.ts"],
-      "@legion/envoy-client/transport": ["../envoy-client/src/transport.ts"]
-    },
-    "strict": true,
-    "noEmit": true,
-    "skipLibCheck": true,
-    "jsx": "preserve",
-    "types": ["bun"]
-  },
-  "include": ["bin/**/*.ts", "src/**/*.ts", "src/**/*.tsx"]
-}