Skip to content

A tiny friend in your Mac's notch and on your iPhone that keeps an eye on your AI coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more. Approve from the notch or your Lock Screen.

16.9 KB
Raw Blame
// The pill catalog (src/core/pills.ts) and the declared pills in the app state.

import { beforeEach, test } from "node:test";
import assert from "node:assert/strict";
import {
  DEFAULT_MAIN_PILL, MAX_DECLARED, PILL_CATALOG, PILL_CATEGORIES, availablePills, chooseMainPill,
  isComingSoon, isHookPill, mainPillChoices, orderPills, pillDefinition, sanitizeDeclared, sessionSubtitle,
  toggleDeclared,
} from "../src/core/pills.ts";
import { DEFAULT_SETTINGS, State } from "../src/core/state.ts";
import { installFakeDom } from "./fakedom.mjs";
import { renderIntegrationCard } from "../src/views/integrations.ts";

installFakeDom();

// ── The catalog itself ────────────────────────────────────────────────────────

test("the catalog holds the Mac's pills with the Claude Code label for Windows and Linux", () => {
  // Copied from NotchBuddy/Sources/CoucouKit/PillCatalog.swift: an ID is a
  // contract value, and a colour or subtitle that drifts is a visible bug.
  // Windows and Linux name the Claude Code integration after the agent.
  const mac = [
    ["integration_claude", "Claude Code", "#F5F6F8", "workspace", "Integration"],
    ["agent_cursor", "Cursor", "#C0C4CC", "workspace", "Integration"],
    ["agent_antigravity", "Antigravity", "#E879F9", "workspace", "Integration"],
    ["agent_codex", "Codex", "#2DD4BF", "workspace", "Integration"],
    ["agent_gemini", "Gemini CLI", "#8AB4F8", "agent", "Agent"],
    ["agent_copilot", "Copilot CLI", "#818CF8", "agent", "Agent"],
    ["agent_muse", "Muse Code", "#38BDF8", "agent", "Agent"],
    ["agent_opencode", "OpenCode", "#4ADE80", "agent", "Agent"],
    ["agent_amp", "Amp", "#F59E0B", "agent", "Agent"],
    ["agent_hermes", "Hermes", "#C084FC", "agent", "Agent"],
    ["agent_claude-desktop", "Claude Desktop", "#D97757", "agent", "Agent"],
    ["ai_anthropic", "Anthropic", "#E07950", "ai", "Chat"],
    ["ai_google", "Google AI", "#4285F4", "ai", "Chat"],
    ["ai_openai", "OpenAI", "#10A37F", "ai", "Chat"],
    ["ai_ollama", "Ollama", "#FACC15", "ai", "Chat"],
    ["ai_lmstudio", "LM Studio", "#A3E635", "ai", "Chat"],
    ["integration_resend", "Resend", "#22C55E", "service", "Integration"],
    ["integration_n8n", "n8n", "#F29B38", "service", "Integration"],
    ["integration_vercel", "Vercel", "#7C5CFF", "service", "Integration"],
    ["integration_github", "GitHub", "#F4505E", "service", "Integration"],
    ["integration_notion", "Notion", "#8C8C8C", "service", "Integration"],
    ["integration_calcom", "Cal.com", "#C9956A", "service", "Integration"],
    ["integration_stripe", "Stripe", "#0570DE", "service", "Integration"],
    ["integration_music", "Apple Music", "#FA2D48", "service", "Integration"],
    ["integration_spotify", "Spotify", "#1DB954", "service", "Integration"],
    ["integration_mail", "Mail", "#2F8CFF", "service", "Integration"],
    ["integration_whatsapp", "WhatsApp", "#25D366", "service", "Integration"],
  ];
  assert.deepEqual(
    PILL_CATALOG.filter((p) => !["integration_gitlab", "integration_gitea"].includes(p.id))
      .map((p) => [p.id, p.name, p.color, p.category, p.subtitle]),
    mac,
  );
  assert.deepEqual(PILL_CATEGORIES.map((c) => c.title), [
    "Where you code", "Agents", "AI for the chat", "Services",
  ]);
});

test("GitLab is a supported service integration", () => {
  const def = pillDefinition("integration_gitlab");
  assert.deepEqual([def.name, def.color, def.category, def.support], ["GitLab", "#FC6D26", "service", "yes"]);
  assert.ok(!isComingSoon("integration_gitlab"));
});

test("Gitea is an available service pill", () => {
  assert.deepEqual(
    pillDefinition("integration_gitea"),
    { id: "integration_gitea", name: "Gitea", color: "#609926", category: "service",
      subtitle: "Integration", source: "n8n", support: "yes", connect: { kind: "key", key: "gitea-token" } },
  );
});

test("the shipped pills keep their IDs, colours and sources with current display names", () => {
  const shipped = [
    ["integration_claude", "Claude Code", "#F5F6F8", "claudeCode"],
    ["integration_resend", "Resend", "#22C55E", "n8n"],
    ["integration_n8n", "n8n", "#F29B38", "n8n"],
    ["integration_vercel", "Vercel", "#7C5CFF", "n8n"],
    ["integration_github", "GitHub", "#F4505E", "n8n"],
    ["integration_notion", "Notion", "#8C8C8C", "n8n"],
    ["integration_calcom", "Cal.com", "#C9956A", "n8n"],
    ["integration_stripe", "Stripe", "#0570DE", "n8n"],
  ];
  for (const [id, name, color, source] of shipped) {
    const def = pillDefinition(id);
    assert.deepEqual([def.id, def.name, def.color, def.source], [id, name, color, source]);
    assert.equal(def.support, "yes");
  }
});

test("IDs are unique", () => {
  const ids = PILL_CATALOG.map((p) => p.id);
  assert.equal(new Set(ids).size, ids.length);
});

test("this build leaves out what only macOS has", () => {
  const windows = availablePills("windows").map((p) => p.id);
  const linux = availablePills("linux").map((p) => p.id);
  for (const id of ["integration_music"]) {
    assert.ok(!windows.includes(id), id);
    assert.ok(!linux.includes(id), id);
  }
  // Their plugins are written from Settings → Agents, and the chat talks to
  // every provider (port/chat-providers), on both systems.
  for (const id of ["agent_opencode", "agent_amp", "agent_hermes", "ai_google", "ai_openai", "ai_ollama", "ai_lmstudio"]) {
    assert.ok(windows.includes(id), id);
    assert.ok(linux.includes(id), id);
  }
  assert.ok(windows.includes("agent_claude-desktop"));
  assert.ok(linux.includes("agent_claude-desktop"));
  // Mail is Outlook's, and Outlook is a Windows program.
  assert.ok(windows.includes("integration_mail"));
  assert.ok(!linux.includes("integration_mail"));
  // Spotify: MPRIS on Linux, the system media controls on Windows.
  assert.ok(linux.includes("integration_spotify"));
  assert.ok(windows.includes("integration_spotify"));
  assert.deepEqual(linux, windows.filter((id) => id !== "integration_mail"));
});

test("Spotify: a service on both systems with nothing to set up", () => {
  const def = pillDefinition("integration_spotify");
  assert.equal(def.support, "yes");
  assert.deepEqual(def.connect, { kind: "none" });
  assert.equal(def.category, "service");
  assert.ok(!isComingSoon("integration_spotify"));
  assert.ok(!isHookPill("integration_spotify"));
  assert.ok(!mainPillChoices("linux").some((p) => p.id === "integration_spotify"));
  assert.ok(!mainPillChoices("windows").some((p) => p.id === "integration_spotify"));
});

test("Spotify and Claude Desktop can be declared on both systems", () => {
  const d = { mainPill: "integration_claude", activeIntegrations: ["integration_spotify", "integration_n8n"] };
  assert.deepEqual(sanitizeDeclared(d, "linux").activeIntegrations, ["integration_spotify", "integration_n8n"]);
  assert.deepEqual(sanitizeDeclared(d, "windows").activeIntegrations, ["integration_spotify", "integration_n8n"]);
  const empty = { mainPill: "integration_claude", activeIntegrations: [] };
  assert.deepEqual(toggleDeclared(empty, "integration_spotify", "linux"), ["integration_spotify"]);
  assert.deepEqual(toggleDeclared(empty, "integration_spotify", "windows"), ["integration_spotify"]);
  // Claude Desktop is available on both Linux and Windows.
  assert.deepEqual(toggleDeclared(empty, "agent_claude-desktop", "linux"), ["agent_claude-desktop"]);
  assert.deepEqual(toggleDeclared(empty, "agent_claude-desktop", "windows"), ["agent_claude-desktop"]);
});

test("no chat provider that works here says Coming soon", () => {
  for (const id of ["ai_anthropic", "ai_google", "ai_openai", "ai_ollama", "ai_lmstudio"]) {
    assert.ok(!isComingSoon(id), id);
  }
  // The local servers are connected through Settings → Local models, not a key.
  assert.deepEqual(pillDefinition("ai_ollama").connect, { kind: "server", field: "ollamaUrl" });
  assert.deepEqual(pillDefinition("ai_lmstudio").connect, { kind: "server", field: "lmstudioUrl" });
  assert.equal(pillDefinition("ai_google").connect.key, "google-api-key");
});

test("the main pill is a workspace tool that works here", () => {
  assert.deepEqual(mainPillChoices("linux").map((p) => p.id), [
    "integration_claude", "agent_cursor", "agent_antigravity", "agent_codex",
  ]);
  assert.equal(DEFAULT_MAIN_PILL, "integration_claude");
});

test("hook-driven pills are the workspace tools and the agents with hooks", () => {
  for (const id of ["integration_claude", "agent_cursor", "agent_codex", "agent_gemini", "agent_copilot", "agent_muse", "agent_antigravity", "agent_opencode", "agent_amp", "agent_hermes"]) {
    assert.ok(isHookPill(id), id);
  }
  for (const id of ["agent_claude-desktop", "ai_anthropic", "integration_stripe", "agent_unknown"]) {
    assert.ok(!isHookPill(id), id);
  }
});

test("a live session names its tool next to the project", () => {
  assert.equal(sessionSubtitle("integration_claude"), "Claude Code");
  assert.equal(sessionSubtitle("agent_cursor"), "Cursor");
  assert.equal(sessionSubtitle("agent_claude-desktop"), "Claude Desktop");
  assert.equal(sessionSubtitle("agent_gemini"), "Agent");
  assert.equal(sessionSubtitle("agent_whatever"), "Agent");
});

// ── Declaring pills ──────────────────────────────────────────────────────────

test("a declaration from an older or edited settings file is made usable", () => {
  assert.deepEqual(
    sanitizeDeclared({ mainPill: "integration_stripe", activeIntegrations: ["integration_claude", "x"] }, "linux"),
    { mainPill: "integration_claude", activeIntegrations: [] },
  );
  assert.deepEqual(
    sanitizeDeclared({ mainPill: "agent_cursor", activeIntegrations: ["agent_cursor", "integration_n8n", "integration_n8n", "integration_music"] }, "linux"),
    { mainPill: "agent_cursor", activeIntegrations: ["integration_n8n"] },
  );
  // No mainPill at all: a settings.json from before this version.
  assert.deepEqual(
    sanitizeDeclared({ activeIntegrations: ["integration_github"] }, "windows"),
    { mainPill: "integration_claude", activeIntegrations: ["integration_github"] },
  );
  assert.equal(sanitizeDeclared({ mainPill: "agent_claude-desktop", activeIntegrations: [] }, "windows").mainPill,
    "integration_claude");
});

test("up to four pills next to the main one, never the main one itself", () => {
  const d = {
    mainPill: "integration_claude",
    activeIntegrations: ["integration_n8n", "integration_github", "integration_stripe"],
  };
  const four = toggleDeclared(d, "agent_gemini", "linux");
  assert.equal(four.length, MAX_DECLARED);
  assert.equal(toggleDeclared({ ...d, activeIntegrations: four }, "ai_anthropic", "linux"), null);
  assert.equal(toggleDeclared(d, "integration_claude", "linux"), null);
  assert.equal(toggleDeclared(d, "integration_music", "linux"), null);
  assert.ok(toggleDeclared(d, "agent_claude-desktop", "linux").includes("agent_claude-desktop"));
  assert.ok(toggleDeclared(d, "agent_claude-desktop", "windows").includes("agent_claude-desktop"));
  assert.deepEqual(toggleDeclared(d, "integration_github", "linux"), ["integration_n8n", "integration_stripe"]);
  // Every chat provider can be declared now that the chat talks to it.
  assert.ok(toggleDeclared(d, "ai_google", "linux").includes("ai_google"));
  assert.ok(toggleDeclared(d, "ai_ollama", "linux").includes("ai_ollama"));
});

test("picking a main pill takes it out of the declared ones, and only workspace tools qualify", () => {
  const d = { mainPill: "integration_claude", activeIntegrations: ["agent_cursor", "integration_n8n"] };
  assert.deepEqual(chooseMainPill(d, "agent_cursor", "linux"), {
    mainPill: "agent_cursor", activeIntegrations: ["integration_n8n"],
  });
  assert.equal(chooseMainPill(d, "integration_n8n", "linux"), null);
  assert.equal(chooseMainPill(d, "agent_gemini", "linux"), null);
});

test("pills are ordered main first, then other agents, then the catalog's order", () => {
  const ids = (list) => list.map((t) => t.id);
  const tasks = ["integration_stripe", "agent_mine", "integration_n8n", "agent_cursor", "integration_claude", "agent_gemini"]
    .map((id) => ({ id }));
  assert.deepEqual(ids(orderPills(tasks, "integration_claude")), [
    "integration_claude", "agent_mine", "agent_cursor", "agent_gemini", "integration_n8n", "integration_stripe",
  ]);
  assert.deepEqual(ids(orderPills(tasks, "agent_cursor")).slice(0, 3), [
    "agent_cursor", "agent_mine", "integration_claude",
  ]);
});

// ── In the app state ─────────────────────────────────────────────────────────

beforeEach(() => {
  State.tasks = [];
  State.focusId = null;
  State.os = "windows";
  State.settings = { ...DEFAULT_SETTINGS };
});

const ids = () => State.tasks.map((t) => t.id);

test("the main pill always loads, the declared ones join it, and focus starts on it", () => {
  State.settings.mainPill = "agent_cursor";
  State.settings.activeIntegrations = ["integration_github", "agent_gemini"];
  State.loadIntegrationTasks();
  assert.deepEqual(ids(), ["agent_cursor", "agent_gemini", "integration_github"]);
  assert.equal(State.focusId, "agent_cursor");
  assert.equal(State.tasks[1].name, "Gemini CLI");
  assert.equal(State.tasks[1].color, "#8AB4F8");
});

test("an old settings file gets Claude Code as its main pill and keeps its integrations", () => {
  State.settings = { ...DEFAULT_SETTINGS, mainPill: undefined };
  State.loadIntegrationTasks();
  assert.deepEqual(ids(), [
    "integration_claude", "integration_resend", "integration_n8n", "integration_vercel", "integration_github",
  ]);
  assert.equal(State.settings.mainPill, "integration_claude");
  assert.equal(State.tasks[0].name, "Claude Code");
});

test("switching the main pill frees its slot and the old main pill goes when idle", () => {
  State.loadIntegrationTasks();
  State.settings.mainPill = "agent_codex";
  State.loadIntegrationTasks();
  assert.equal(ids()[0], "agent_codex");
  assert.ok(!ids().includes("integration_claude"));
  assert.equal(State.focusId, "agent_codex");
});

test("a pill in the middle of a session stays until the session ends", () => {
  State.loadIntegrationTasks();
  State.tasks[0].state = "working";
  State.settings.mainPill = "agent_cursor";
  State.loadIntegrationTasks();
  assert.ok(ids().includes("integration_claude"));
  State.removeTask("integration_claude");
  assert.ok(!ids().includes("integration_claude"));
});

test("the end of a session puts a kept pill back as it was, and removes any other", () => {
  State.settings.activeIntegrations = ["agent_gemini"];
  State.loadIntegrationTasks();
  const gemini = State.tasks.find((t) => t.id === "agent_gemini");
  Object.assign(gemini, { name: "proj", state: "finished", steps: ["a"], pillBadge: "finished" });
  State.removeTask("agent_gemini");
  assert.deepEqual(
    [gemini.name, gemini.state, gemini.steps, gemini.pillBadge],
    ["Gemini CLI", "idle", [], null],
  );
  State.upsertExternalAgent("agent_mine", "mine", "#22C55E");
  State.setFocus("agent_mine");
  State.removeTask("agent_mine");
  assert.ok(!ids().includes("agent_mine"));
  assert.equal(State.focusId, "integration_claude");
});

test("a Claude Code session gets its pill even when it is not loaded", () => {
  State.settings.mainPill = "agent_codex";
  State.loadIntegrationTasks();
  const t = State.upsertWorkspacePill("integration_claude", "proj", "/p");
  assert.equal(ids()[1], "integration_claude");
  assert.equal(t.name, "proj");
  assert.equal(t.sessionCwd, "/p");
  assert.equal(State.upsertWorkspacePill("not_a_pill", "x", ""), null);
});

test("toggling declares up to four pills and never the main one", () => {
  State.settings.activeIntegrations = [];
  State.loadIntegrationTasks();
  for (const id of ["integration_n8n", "agent_gemini", "ai_anthropic", "integration_stripe", "integration_github"]) {
    State.toggleIntegration(id);
  }
  assert.deepEqual(State.settings.activeIntegrations, [
    "integration_n8n", "agent_gemini", "ai_anthropic", "integration_stripe",
  ]);
  State.toggleIntegration("integration_claude");
  assert.ok(ids().includes("integration_claude"));
  State.setFocus("agent_gemini");
  State.toggleIntegration("agent_gemini");
  assert.ok(!ids().includes("agent_gemini"));
  assert.equal(State.focusId, "integration_claude");
});

test("Claude Code is named after the agent in main-tool choices on both platforms", () => {
  for (const os of ["windows", "linux"]) {
    const choice = mainPillChoices(os).find((p) => p.id === "integration_claude");
    assert.equal(choice.name, "Claude Code");
    assert.equal(choice.source, "claudeCode");
  }
});

test("the Claude Code idle card keeps the agent title when the task has a project name", () => {
  State.loadIntegrationTasks();
  const task = State.tasks.find((t) => t.id === "integration_claude");
  task.name = "my-project";
  const card = renderIntegrationCard(task, { openSettings() {} });
  assert.ok(card.textContent.includes("Claude Code"));
  assert.ok(!card.textContent.includes("my-project"));
  assert.ok(card.textContent.includes("Open Visual Studio Code"));
});