@botcord/daemon 0.1.1

package/src/__tests__/daemon.test.ts

@@ -0,0 +1,300 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { GatewayInboundMessage, GatewayLogger } from "../gateway/index.js";
+import {
+  backfillBootAgents,
+  classifyActivitySender,
+  createActivityRecorder,
+} from "../daemon.js";
+import type { DiscoveredAgentCredential } from "../agent-discovery.js";
+import { agentWorkspaceDir } from "../agent-workspace.js";
+
+function makeMsg(overrides: {
+  conversationId?: string;
+  senderKind?: "user" | "agent" | "system";
+  senderId?: string;
+  senderName?: string;
+  sourceType?: unknown;
+}): GatewayInboundMessage {
+  return {
+    id: "m1",
+    channel: "botcord",
+    accountId: "acc",
+    conversation: {
+      id: overrides.conversationId ?? "rm_team",
+      kind: "group",
+    },
+    sender: {
+      id: overrides.senderId ?? "ag_peer",
+      kind: overrides.senderKind ?? "agent",
+      ...(overrides.senderName ? { name: overrides.senderName } : {}),
+    },
+    text: "",
+    raw: overrides.sourceType !== undefined ? { source_type: overrides.sourceType } : {},
+    receivedAt: Date.now(),
+  };
+}
+
+describe("classifyActivitySender", () => {
+  it("labels rm_oc_* rooms as owner regardless of sender.kind", () => {
+    const msg = makeMsg({
+      conversationId: "rm_oc_abc",
+      senderKind: "user",
+      senderId: "ag_self",
+    });
+    expect(classifyActivitySender(msg)).toEqual({ kind: "owner", label: "ag_self" });
+  });
+
+  it("labels source_type=dashboard_user_chat as owner even outside rm_oc_ rooms", () => {
+    const msg = makeMsg({
+      conversationId: "rm_team_42",
+      senderKind: "user",
+      senderId: "ag_owner",
+      sourceType: "dashboard_user_chat",
+    });
+    // Regression guard: the gateway channel collapses owner + human-room humans
+    // into sender.kind="user"; without the source_type peek the classifier would
+    // label this turn as "human" in the cross-room digest.
+    expect(classifyActivitySender(msg)).toEqual({ kind: "owner", label: "ag_owner" });
+  });
+
+  it("labels dashboard_human_room senders as human and uses source_user_name", () => {
+    const msg = makeMsg({
+      conversationId: "rm_team_42",
+      senderKind: "user",
+      senderName: "Alice",
+      senderId: "ag_bridge",
+      sourceType: "dashboard_human_room",
+    });
+    expect(classifyActivitySender(msg)).toEqual({ kind: "human", label: "Alice" });
+  });
+
+  it("labels A2A peer (sender.kind=agent) as agent", () => {
+    const msg = makeMsg({
+      conversationId: "rm_team_42",
+      senderKind: "agent",
+      senderId: "ag_peer",
+    });
+    expect(classifyActivitySender(msg)).toEqual({ kind: "agent", label: "ag_peer" });
+  });
+
+  it("falls back cleanly when raw is a non-object (defensive path for non-BotCord channels)", () => {
+    const msg = makeMsg({ conversationId: "rm_team_42", senderKind: "agent" });
+    // Overwrite raw to a non-object; classifier should still return agent.
+    (msg as { raw: unknown }).raw = "not-an-object";
+    expect(classifyActivitySender(msg)).toEqual({ kind: "agent", label: "ag_peer" });
+  });
+
+  it("uses sender.id when the user sender has no name", () => {
+    const msg = makeMsg({
+      conversationId: "rm_other",
+      senderKind: "user",
+      senderId: "ag_anon",
+    });
+    expect(classifyActivitySender(msg)).toEqual({ kind: "human", label: "ag_anon" });
+  });
+});
+
+describe("createActivityRecorder", () => {
+  it("records inbound messages regardless of the channel id the gateway stamps", () => {
+    // Regression: pre-fix, the observer bailed out when msg.channel !== "botcord".
+    // After the agent-id channel migration, the gateway stamps the agentId
+    // (e.g. "ag_self"). The recorder must still fire — cross-room digest
+    // silently going empty was the original bug.
+    const record = vi.fn();
+    const onInbound = createActivityRecorder({
+      activityTracker: { record },
+    });
+    const msg: GatewayInboundMessage = {
+      ...makeMsg({ conversationId: "rm_team_42", senderKind: "agent", senderId: "ag_peer" }),
+      accountId: "ag_self",
+      channel: "ag_self",
+      text: "hello there",
+    };
+    onInbound(msg);
+    expect(record).toHaveBeenCalledTimes(1);
+    expect(record).toHaveBeenCalledWith({
+      agentId: "ag_self",
+      roomId: "rm_team_42",
+      roomName: undefined,
+      topic: null,
+      lastInboundPreview: "hello there",
+      lastSenderKind: "agent",
+      lastSender: "ag_peer",
+    });
+  });
+
+  it("derives the activity agentId from msg.accountId (multi-agent isolation)", () => {
+    // Multi-agent regression guard: two messages targeting different
+    // configured agents must land under distinct tracker keys, not a
+    // closed-over constant.
+    const record = vi.fn();
+    const onInbound = createActivityRecorder({
+      activityTracker: { record },
+    });
+    onInbound({
+      ...makeMsg({ conversationId: "rm_a", senderKind: "agent", senderId: "ag_peer" }),
+      accountId: "ag_one",
+      channel: "ag_one",
+      text: "for agent one",
+    });
+    onInbound({
+      ...makeMsg({ conversationId: "rm_b", senderKind: "agent", senderId: "ag_peer" }),
+      accountId: "ag_two",
+      channel: "ag_two",
+      text: "for agent two",
+    });
+    expect(record.mock.calls[0][0].agentId).toBe("ag_one");
+    expect(record.mock.calls[1][0].agentId).toBe("ag_two");
+  });
+
+  it("falls back to fallbackAgentId when msg.accountId is empty", () => {
+    const record = vi.fn();
+    const onInbound = createActivityRecorder({
+      activityTracker: { record },
+      fallbackAgentId: "ag_fallback",
+    });
+    onInbound({
+      ...makeMsg({ conversationId: "rm_x", senderKind: "agent", senderId: "ag_peer" }),
+      accountId: "",
+      channel: "ag_fallback",
+    });
+    expect(record.mock.calls[0][0].agentId).toBe("ag_fallback");
+  });
+
+  it("passes owner text through verbatim and sanitizes non-owner text", () => {
+    const record = vi.fn();
+    const onInbound = createActivityRecorder({
+      activityTracker: { record },
+    });
+    onInbound({
+      ...makeMsg({ conversationId: "rm_oc_abc", senderKind: "user", senderId: "ag_self" }),
+      accountId: "ag_self",
+      channel: "ag_self",
+      text: "raw owner text",
+    });
+    expect(record.mock.calls[0][0].lastInboundPreview).toBe("raw owner text");
+    expect(record.mock.calls[0][0].lastSenderKind).toBe("owner");
+  });
+});
+
+function silentLogger(): GatewayLogger {
+  return {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  };
+}
+
+function bootAgent(
+  agentId: string,
+  extra: Partial<DiscoveredAgentCredential> = {},
+): DiscoveredAgentCredential {
+  return {
+    agentId,
+    credentialsFile: `/fake/${agentId}.json`,
+    hubUrl: "https://hub.example.com",
+    ...extra,
+  };
+}
+
+describe("backfillBootAgents", () => {
+  let tmpHome: string;
+  let origHome: string | undefined;
+
+  beforeEach(() => {
+    tmpHome = mkdtempSync(path.join(os.tmpdir(), "botcord-daemon-boot-"));
+    origHome = process.env.HOME;
+    process.env.HOME = tmpHome;
+  });
+
+  afterEach(() => {
+    if (origHome === undefined) delete process.env.HOME;
+    else process.env.HOME = origHome;
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it("creates the per-agent workspace for a legacy discovered agent that has none", () => {
+    // Simulates plan §9's primary use case: an agent was provisioned before
+    // the workspace feature existed, so `~/.botcord/agents/{id}/` doesn't
+    // exist yet. Boot backfill should materialize it — but leave the
+    // credentials file alone (no-credential-mutation invariant).
+    const res = backfillBootAgents(
+      [
+        bootAgent("ag_legacy", {
+          displayName: "Legacy",
+          keyId: "k_42",
+          savedAt: "2026-04-23T00:00:00.000Z",
+        }),
+      ],
+      { logger: silentLogger() },
+    );
+    const ws = agentWorkspaceDir("ag_legacy");
+    expect(existsSync(path.join(ws, "AGENTS.md"))).toBe(true);
+    expect(existsSync(path.join(ws, "identity.md"))).toBe(true);
+    const identity = readFileSync(path.join(ws, "identity.md"), "utf8");
+    expect(identity).toContain("ag_legacy");
+    expect(identity).toContain("Legacy");
+    expect(identity).toContain("k_42");
+    // Maps still populated for downstream `toGatewayConfig` consumption.
+    expect(res.credentialPathByAgentId.get("ag_legacy")).toBe(
+      "/fake/ag_legacy.json",
+    );
+    // No runtime/cwd on the boot agent → no entry in the runtimes map.
+    expect(res.agentRuntimes.ag_legacy).toBeUndefined();
+  });
+
+  it("is idempotent: a second call leaves user-edited files alone", () => {
+    backfillBootAgents([bootAgent("ag_one")], { logger: silentLogger() });
+    const memoryPath = path.join(agentWorkspaceDir("ag_one"), "memory.md");
+    const edited = "# My notes\n\nremembered thing\n";
+    // Simulate the LLM/user editing memory.md.
+    writeFileSync(memoryPath, edited);
+    backfillBootAgents([bootAgent("ag_one")], { logger: silentLogger() });
+    expect(readFileSync(memoryPath, "utf8")).toBe(edited);
+  });
+
+  it("warns and continues when ensureAgentWorkspace throws for one agent", () => {
+    // One agent's broken workspace (permission denied, full disk, etc.)
+    // must not block the other agents from being brought up.
+    const warn = vi.fn();
+    const ensure = vi.fn((agentId: string) => {
+      if (agentId === "ag_bad") throw new Error("EACCES");
+    });
+    const logger: GatewayLogger = { ...silentLogger(), warn };
+    const res = backfillBootAgents(
+      [bootAgent("ag_bad"), bootAgent("ag_good", { runtime: "codex" })],
+      { logger, ensure },
+    );
+    expect(ensure).toHaveBeenCalledTimes(2);
+    expect(warn).toHaveBeenCalledWith(
+      "ensureAgentWorkspace failed at boot; continuing",
+      expect.objectContaining({ agentId: "ag_bad" }),
+    );
+    // Both agents are still plumbed into the downstream caches — the peer
+    // agent's channel and route are not taken down by the sibling's error.
+    expect(res.credentialPathByAgentId.has("ag_bad")).toBe(true);
+    expect(res.credentialPathByAgentId.has("ag_good")).toBe(true);
+    expect(res.agentRuntimes.ag_good).toEqual({ runtime: "codex" });
+  });
+
+  it("does not touch credential files (no-credential-mutation invariant)", () => {
+    // §9 "No credential mutation": boot backfill writes to the agent's
+    // workspace dir only; the credential file passed in via `credentialsFile`
+    // is not opened. We verify by using a path that doesn't exist on disk —
+    // if the backfill tried to read or rewrite it, we'd see an ENOENT.
+    expect(() =>
+      backfillBootAgents([bootAgent("ag_one")], { logger: silentLogger() }),
+    ).not.toThrow();
+    expect(existsSync("/fake/ag_one.json")).toBe(false);
+  });
+});

package/src/__tests__/device-code.test.ts

@@ -0,0 +1,152 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  pollDeviceToken,
+  requestDeviceCode,
+} from "@botcord/protocol-core";
+
+const HUB = "http://localhost:9000";
+
+describe("requestDeviceCode", () => {
+  let originalFetch: typeof fetch;
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("parses snake_case fields and applies defaults", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          device_code: "dc_abc",
+          user_code: "ABCD-EFGH",
+          verification_uri: "https://app.botcord.dev/activate",
+          expires_in: 600,
+          interval: 5,
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      ),
+    ) as unknown as typeof fetch;
+
+    const dc = await requestDeviceCode(HUB);
+    expect(dc.deviceCode).toBe("dc_abc");
+    expect(dc.userCode).toBe("ABCD-EFGH");
+    expect(dc.expiresIn).toBe(600);
+    expect(dc.interval).toBe(5);
+  });
+
+  it("forwards label in the request body when provided", async () => {
+    let captured: { url: string; init: RequestInit | undefined } | null = null;
+    globalThis.fetch = vi.fn(async (url: unknown, init: unknown) => {
+      captured = { url: String(url), init: init as RequestInit | undefined };
+      return new Response(
+        JSON.stringify({
+          device_code: "dc_x",
+          user_code: "XXXX-YYYY",
+          verification_uri: "https://app.botcord.dev/activate",
+          expires_in: 600,
+          interval: 5,
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as unknown as typeof fetch;
+
+    await requestDeviceCode(HUB, { label: "MacBook Pro" });
+    expect(captured).not.toBeNull();
+    const cap = captured as unknown as { url: string; init: { body?: string } };
+    const body = JSON.parse(cap.init.body as string) as { label?: string };
+    expect(body.label).toBe("MacBook Pro");
+  });
+
+  it("throws on missing fields", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({}), { status: 200 }),
+    ) as unknown as typeof fetch;
+    await expect(requestDeviceCode(HUB)).rejects.toThrow(/missing/);
+  });
+});
+
+describe("pollDeviceToken", () => {
+  let originalFetch: typeof fetch;
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("returns pending on a 200 envelope with status=pending", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ status: "pending" }), { status: 200 }),
+    ) as unknown as typeof fetch;
+    const r = await pollDeviceToken(HUB, "dc_x");
+    expect(r.status).toBe("pending");
+  });
+
+  it("translates 4xx authorization_pending into pending", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ error: "authorization_pending" }), { status: 400 }),
+    ) as unknown as typeof fetch;
+    const r = await pollDeviceToken(HUB, "dc_x");
+    expect(r.status).toBe("pending");
+  });
+
+  it("returns slow_down with the suggested interval", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ status: "slow_down", interval: 12 }), {
+        status: 200,
+      }),
+    ) as unknown as typeof fetch;
+    const r = await pollDeviceToken(HUB, "dc_x");
+    expect(r.status).toBe("slow_down");
+    if (r.status === "slow_down") expect(r.interval).toBe(12);
+  });
+
+  it("returns the issued token envelope", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          status: "issued",
+          access_token: "at_1",
+          refresh_token: "rt_1",
+          expires_in: 3600,
+          user_id: "usr_1",
+          daemon_instance_id: "dm_1",
+          hub_url: HUB,
+        }),
+        { status: 200 },
+      ),
+    ) as unknown as typeof fetch;
+    const r = await pollDeviceToken(HUB, "dc_x");
+    expect(r.status).toBe("issued");
+    if (r.status === "issued") {
+      expect(r.accessToken).toBe("at_1");
+      expect(r.refreshToken).toBe("rt_1");
+      expect(r.userId).toBe("usr_1");
+      expect(r.daemonInstanceId).toBe("dm_1");
+    }
+  });
+
+  it("throws on unrecognized 4xx errors", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ error: "expired_token" }), { status: 400 }),
+    ) as unknown as typeof fetch;
+    await expect(pollDeviceToken(HUB, "dc_x")).rejects.toThrow(/expired_token/);
+  });
+
+  it("forwards label on poll requests", async () => {
+    let body: { label?: string; device_code?: string } | null = null;
+    globalThis.fetch = vi.fn(async (_url: unknown, init: unknown) => {
+      body = JSON.parse((init as { body: string }).body) as {
+        label?: string;
+        device_code?: string;
+      };
+      return new Response(JSON.stringify({ status: "pending" }), { status: 200 });
+    }) as unknown as typeof fetch;
+    await pollDeviceToken(HUB, "dc_x", { label: "Studio" });
+    const cap = body as unknown as { label?: string; device_code?: string };
+    expect(cap.label).toBe("Studio");
+    expect(cap.device_code).toBe("dc_x");
+  });
+});

package/src/__tests__/doctor.test.ts

@@ -0,0 +1,218 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  channelsFromDaemonConfig,
+  probeChannel,
+  probeChannels,
+  renderDoctor,
+  type ChannelProbeConfig,
+  type DoctorFileReader,
+  type DoctorHttpFetcher,
+} from "../doctor.js";
+import type { DaemonConfig } from "../config.js";
+
+const okCreds = JSON.stringify({
+  token: "secret-token",
+  hubUrl: "https://hub.example.com",
+});
+
+function fileReader(files: Record<string, string | null>): DoctorFileReader {
+  return {
+    readFile(p) {
+      return p in files ? files[p] : null;
+    },
+  };
+}
+
+function fetcher(result: { ok: boolean; status?: number; error?: string }): DoctorHttpFetcher {
+  return vi.fn(async () => result);
+}
+
+describe("probeChannel", () => {
+  const ch: ChannelProbeConfig = {
+    id: "botcord-main",
+    type: "botcord",
+    accountId: "ag_123",
+  };
+
+  it("reports credentials and hub both ✓ when everything is healthy", async () => {
+    const credsPath = "/creds/ag_123.json";
+    const result = await probeChannel(ch, {
+      credentialsPath: () => credsPath,
+      fileReader: fileReader({ [credsPath]: okCreds }),
+      fetcher: fetcher({ ok: true, status: 200 }),
+      timeoutMs: 1000,
+    });
+    expect(result.credentialsOk).toBe(true);
+    expect(result.hubOk).toBe(true);
+    expect(result.hubUrl).toBe("https://hub.example.com");
+    expect(result.hubMessage).toContain("200");
+  });
+
+  it("reports missing credentials when the file cannot be read", async () => {
+    const result = await probeChannel(ch, {
+      credentialsPath: () => "/no/such/file.json",
+      fileReader: fileReader({}),
+      fetcher: fetcher({ ok: true, status: 200 }),
+      timeoutMs: 1000,
+    });
+    expect(result.credentialsOk).toBe(false);
+    expect(result.credentialsMessage).toContain("missing");
+    expect(result.hubOk).toBe(false);
+    expect(result.hubMessage).toContain("skipped");
+  });
+
+  it("reports invalid JSON when credentials fail to parse", async () => {
+    const credsPath = "/creds/bad.json";
+    const result = await probeChannel(ch, {
+      credentialsPath: () => credsPath,
+      fileReader: fileReader({ [credsPath]: "{not json" }),
+      fetcher: fetcher({ ok: true, status: 200 }),
+      timeoutMs: 1000,
+    });
+    expect(result.credentialsOk).toBe(false);
+    expect(result.credentialsMessage).toContain("invalid JSON");
+  });
+
+  it("reports ✗ with timeout message when the fetcher times out", async () => {
+    const credsPath = "/creds/ag_123.json";
+    const result = await probeChannel(ch, {
+      credentialsPath: () => credsPath,
+      fileReader: fileReader({ [credsPath]: okCreds }),
+      fetcher: fetcher({ ok: false, error: "timeout" }),
+      timeoutMs: 1000,
+    });
+    expect(result.credentialsOk).toBe(true);
+    expect(result.hubOk).toBe(false);
+    expect(result.hubMessage).toBe("timeout");
+  });
+
+  it("reports a non-2xx status when reachable but not ok", async () => {
+    const credsPath = "/creds/ag_123.json";
+    const result = await probeChannel(ch, {
+      credentialsPath: () => credsPath,
+      fileReader: fileReader({ [credsPath]: okCreds }),
+      fetcher: fetcher({ ok: false, status: 503 }),
+      timeoutMs: 1000,
+    });
+    expect(result.hubOk).toBe(false);
+    expect(result.hubMessage).toContain("503");
+  });
+
+  it("probeChannels returns an entry per input channel", async () => {
+    const credsPath = "/creds/ag_123.json";
+    const results = await probeChannels({
+      channels: [ch, { ...ch, id: "botcord-alt", accountId: "ag_alt" }],
+      credentialsPath: (acct) => (acct === "ag_123" ? credsPath : "/missing"),
+      fileReader: fileReader({ [credsPath]: okCreds }),
+      fetcher: fetcher({ ok: true, status: 200 }),
+      timeoutMs: 1000,
+    });
+    expect(results).toHaveLength(2);
+    expect(results[0].credentialsOk).toBe(true);
+    expect(results[1].credentialsOk).toBe(false);
+  });
+});
+
+describe("probeChannel (with per-channel credentialsFile)", () => {
+  it("uses channel.credentialsFile instead of the default when set", async () => {
+    const explicit = "/override/path/ag.json";
+    const reader = fileReader({ [explicit]: okCreds });
+    const result = await probeChannel(
+      {
+        id: "ag_x",
+        type: "botcord",
+        accountId: "ag_x",
+        credentialsFile: explicit,
+      },
+      {
+        credentialsPath: () => "/default/should-not-be-read.json",
+        fileReader: reader,
+        fetcher: fetcher({ ok: true, status: 200 }),
+        timeoutMs: 1000,
+      },
+    );
+    expect(result.credentialsOk).toBe(true);
+    expect(result.credentialsMessage).toContain(explicit);
+  });
+});
+
+describe("channelsFromDaemonConfig (boot-agent aware)", () => {
+  it("returns channels derived from the explicit agents list", () => {
+    const cfg: DaemonConfig = {
+      agents: ["ag_one", "ag_two"],
+      defaultRoute: { adapter: "claude-code", cwd: "/w" },
+      routes: [],
+      streamBlocks: true,
+    };
+    const channels = channelsFromDaemonConfig(cfg);
+    expect(channels.map((c) => c.id)).toEqual(["ag_one", "ag_two"]);
+    // Explicit config channels use the default credential path (no override).
+    for (const c of channels) {
+      expect(c.credentialsFile).toMatch(/\.botcord\/credentials\//);
+    }
+  });
+
+  it("returns an empty list when no agents are configured and discovery is unavailable", () => {
+    // Default discovery dir almost certainly has no credentials in test env.
+    // We rely on the fallback-to-empty behaviour, not a real scan — any scan
+    // that throws turns into [].
+    const cfg: DaemonConfig = {
+      defaultRoute: { adapter: "claude-code", cwd: "/w" },
+      routes: [],
+      streamBlocks: true,
+    };
+    const channels = channelsFromDaemonConfig(cfg);
+    expect(Array.isArray(channels)).toBe(true);
+    // Either empty or non-empty depending on environment; the important
+    // guarantee is that it does not throw.
+  });
+});
+
+describe("renderDoctor", () => {
+  it("renders runtimes + channel section with markers", () => {
+    const out = renderDoctor({
+      runtimes: [
+        {
+          id: "claude-code",
+          displayName: "Claude Code",
+          binary: "claude",
+          supportsRun: true,
+          result: { available: true, version: "1.0.0", path: "/usr/bin/claude" },
+        },
+      ],
+      channels: [
+        {
+          id: "botcord-main",
+          type: "botcord",
+          accountId: "ag_123",
+          credentialsOk: true,
+          credentialsMessage: "loaded",
+          hubUrl: "https://hub.example.com",
+          hubOk: true,
+          hubMessage: "reachable (HTTP 200)",
+        },
+      ],
+    });
+    expect(out).toContain("claude-code");
+    expect(out).toContain("1/1 runtimes available");
+    expect(out).toContain("Channels:");
+    expect(out).toContain("botcord-main");
+    expect(out).toContain("✓");
+  });
+
+  it("shows 'No channels configured.' when the channel list is empty", () => {
+    const out = renderDoctor({
+      runtimes: [
+        {
+          id: "claude-code",
+          displayName: "Claude Code",
+          binary: "claude",
+          supportsRun: true,
+          result: { available: false },
+        },
+      ],
+      channels: [],
+    });
+    expect(out).toContain("No channels configured.");
+  });
+});

package/src/__tests__/protocol-core-reexport.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import {
+  BotCordClient,
+  loadStoredCredentials,
+  buildHubWebSocketUrl,
+} from "@botcord/protocol-core";
+
+describe("@botcord/protocol-core re-exports", () => {
+  it("exposes BotCordClient as a class", () => {
+    expect(BotCordClient).toBeDefined();
+    expect(typeof BotCordClient).toBe("function");
+  });
+
+  it("exposes loadStoredCredentials as a function", () => {
+    expect(typeof loadStoredCredentials).toBe("function");
+  });
+
+  it("buildHubWebSocketUrl converts http → ws + appends /hub/ws", () => {
+    expect(typeof buildHubWebSocketUrl).toBe("function");
+    const u = buildHubWebSocketUrl("http://localhost:9000");
+    expect(u.startsWith("ws://")).toBe(true);
+    expect(u).toContain("/hub/ws");
+  });
+});