chainlesschain 0.162.101 → 0.162.102

package/src/lib/__tests__/agents.test.js

@@ -0,0 +1,225 @@
+"use strict";
+
+/**
+ * agents tests — user-defined subagent discovery (.claude/agents/*.md), the
+ * Claude-Code parity layer, previously untested. Covers normalizeTools,
+ * parseAgentFile (frontmatter + body=systemPrompt, defaults, bad YAML),
+ * discoverAgents (path-derived names with `:`, frontmatter name override,
+ * project-shadows-personal precedence, sorting) and getAgent (colon/slash/
+ * leading-slash lookup). In-memory fake fs over POSIX paths via the deps seam;
+ * no `.git` present so projectRootBase resolves to null (cwd+home dirs only).
+ */
+
+import { describe, it, expect } from "vitest";
+import pathDefault from "path";
+import {
+  normalizeTools,
+  parseAgentFile,
+  discoverAgents,
+  getAgent,
+} from "../agents.js";
+
+const P = pathDefault.posix;
+
+function makeFs(files) {
+  const contents = new Map(Object.entries(files));
+  const fileSet = new Set(contents.keys());
+  const dirSet = new Set(["/"]);
+  for (const f of fileSet) {
+    let d = P.dirname(f);
+    while (d && !dirSet.has(d)) {
+      dirSet.add(d);
+      d = P.dirname(d);
+    }
+  }
+  const childrenOf = (dir) => {
+    const out = new Map();
+    for (const f of fileSet)
+      if (P.dirname(f) === dir) out.set(P.basename(f), false);
+    for (const d of dirSet)
+      if (d !== "/" && P.dirname(d) === dir) out.set(P.basename(d), true);
+    return out;
+  };
+  return {
+    readFileSync(p) {
+      if (!fileSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      return contents.get(p);
+    },
+    existsSync(p) {
+      return fileSet.has(p) || dirSet.has(p);
+    },
+    statSync(p) {
+      if (!fileSet.has(p) && !dirSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      const isDir = dirSet.has(p);
+      return { isDirectory: () => isDir, isFile: () => !isDir };
+    },
+    readdirSync(p, opts) {
+      if (!dirSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      const kids = childrenOf(p);
+      if (opts && opts.withFileTypes) {
+        return [...kids].map(([name, isDir]) => ({
+          name,
+          isDirectory: () => isDir,
+          isFile: () => !isDir,
+        }));
+      }
+      return [...kids.keys()];
+    },
+  };
+}
+
+const discover = (files, home = "/home/u") =>
+  discoverAgents("/proj", { deps: { fs: makeFs(files), path: P }, home });
+
+// --------------------------------------------------------------------------- //
+// normalizeTools
+// --------------------------------------------------------------------------- //
+describe("normalizeTools", () => {
+  it("returns null for null/undefined", () => {
+    expect(normalizeTools(null)).toBe(null);
+    expect(normalizeTools(undefined)).toBe(null);
+  });
+
+  it("splits a comma/space string into a trimmed list", () => {
+    expect(normalizeTools("read, write,  run")).toEqual([
+      "read",
+      "write",
+      "run",
+    ]);
+    expect(normalizeTools("a b c")).toEqual(["a", "b", "c"]);
+  });
+
+  it("normalizes an array, dropping empties", () => {
+    expect(normalizeTools(["read", "", "  write "])).toEqual(["read", "write"]);
+  });
+
+  it("returns null when nothing remains", () => {
+    expect(normalizeTools("")).toBe(null);
+    expect(normalizeTools([" ", ""])).toBe(null);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// parseAgentFile
+// --------------------------------------------------------------------------- //
+describe("parseAgentFile", () => {
+  const parse = (content, opts) =>
+    parseAgentFile("/a.md", "project", {
+      deps: { fs: makeFs({ "/a.md": content }) },
+      ...opts,
+    });
+
+  it("returns null when the file cannot be read", () => {
+    expect(
+      parseAgentFile("/missing.md", "project", { deps: { fs: makeFs({}) } }),
+    ).toBe(null);
+  });
+
+  it("uses the whole body as systemPrompt when there is no frontmatter", () => {
+    const a = parse("You are a helpful agent.");
+    expect(a.systemPrompt).toBe("You are a helpful agent.");
+    expect(a.name).toBe(null);
+    expect(a.description).toBe("");
+    expect(a.tools).toBe(null);
+    expect(a.model).toBe(null);
+  });
+
+  it("parses frontmatter metadata and trims the body", () => {
+    const a = parse(
+      "---\nname: sec\ndescription: security review\ntools: read, grep\nmodel: opus\n---\n\nReview for vulns.\n",
+    );
+    expect(a.name).toBe("sec");
+    expect(a.description).toBe("security review");
+    expect(a.tools).toEqual(["read", "grep"]);
+    expect(a.model).toBe("opus");
+    expect(a.systemPrompt).toBe("Review for vulns.");
+  });
+
+  it("accepts a YAML array for tools", () => {
+    const a = parse("---\ntools:\n  - read\n  - write\n---\nbody");
+    expect(a.tools).toEqual(["read", "write"]);
+  });
+
+  it("falls back to defaults on invalid YAML frontmatter", () => {
+    const a = parse("---\n: : bad : yaml :\n---\nthe body");
+    expect(a.name).toBe(null);
+    expect(a.systemPrompt).toBe("the body");
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// discoverAgents
+// --------------------------------------------------------------------------- //
+describe("discoverAgents", () => {
+  it("derives names from the path with ':' for nesting", () => {
+    const agents = discover({
+      "/proj/.claude/agents/reviewer.md": "Review.",
+      "/proj/.claude/agents/sec/audit.md": "Audit.",
+    });
+    const names = agents.map((a) => a.name);
+    expect(names).toEqual(["reviewer", "sec:audit"]); // sorted
+  });
+
+  it("lets frontmatter name override the path-derived name", () => {
+    const agents = discover({
+      "/proj/.claude/agents/x.md": "---\nname: custom\n---\nbody",
+    });
+    expect(agents[0].name).toBe("custom");
+  });
+
+  it("project scope shadows personal on a name clash", () => {
+    const agents = discover({
+      "/proj/.claude/agents/reviewer.md": "PROJECT version.",
+      "/home/u/.claude/agents/reviewer.md": "PERSONAL version.",
+      "/home/u/.claude/agents/helper.md": "Helper.",
+    });
+    const reviewer = agents.find((a) => a.name === "reviewer");
+    expect(reviewer.scope).toBe("project");
+    expect(reviewer.systemPrompt).toBe("PROJECT version.");
+    // personal-only agent still discovered
+    expect(agents.find((a) => a.name === "helper").scope).toBe("personal");
+  });
+
+  it("returns [] when no agent dirs exist", () => {
+    expect(discover({ "/proj/readme.md": "x" })).toEqual([]);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// getAgent
+// --------------------------------------------------------------------------- //
+describe("getAgent", () => {
+  const files = {
+    "/proj/.claude/agents/sec/audit.md": "---\ndescription: d\n---\nAudit.",
+  };
+  const get = (name) =>
+    getAgent(name, "/proj", {
+      deps: { fs: makeFs(files), path: P },
+      home: "/home/u",
+    });
+
+  it("looks up by colon name", () => {
+    expect(get("sec:audit")?.description).toBe("d");
+  });
+
+  it("accepts slash and leading-slash forms", () => {
+    expect(get("sec/audit")?.name).toBe("sec:audit");
+    expect(get("/sec/audit")?.name).toBe("sec:audit");
+  });
+
+  it("returns null for an unknown agent", () => {
+    expect(get("nope")).toBe(null);
+  });
+});

package/src/lib/__tests__/cowork-observe-html.test.js

@@ -0,0 +1,141 @@
+"use strict";
+
+/**
+ * cowork-observe-html buildHtml tests (previously untested).
+ *
+ * buildHtml renders a static dashboard from an aggregate snapshot and embeds
+ * user-controlled data (template names, failure summaries, schedule fields) into
+ * HTML and into an inline <script> JSON blob. The escaping is the security
+ * boundary — these tests pin XSS safety (HTML entity escaping + JSON
+ * script-breakout escaping) plus the structural rendering / empty states.
+ */
+
+import { describe, it, expect } from "vitest";
+import { buildHtml } from "../cowork-observe-html.js";
+
+describe("buildHtml — document shape", () => {
+  it("emits a full HTML document with UTF-8 charset", () => {
+    const html = buildHtml({});
+    expect(html.startsWith("<!DOCTYPE html>")).toBe(true);
+    expect(html).toContain('<meta charset="UTF-8">');
+    expect(html).toContain("Cowork Observe");
+  });
+
+  it("does not throw on null/undefined data", () => {
+    expect(() => buildHtml(null)).not.toThrow();
+    expect(() => buildHtml(undefined)).not.toThrow();
+  });
+
+  it("renders empty-state messages when there is no data", () => {
+    const html = buildHtml({});
+    expect(html).toContain("No template runs in window.");
+    expect(html).toContain("No failures in window");
+    expect(html).toContain("No upcoming triggers.");
+  });
+
+  it("renders summary stat cards", () => {
+    const html = buildHtml({
+      tasks: { total: 42, successRate: 0.876, failed: 5, avgTokens: 1200 },
+      schedules: { active: 3 },
+    });
+    expect(html).toContain(">42<"); // total
+    expect(html).toContain(">88%<"); // successRate rounded
+    expect(html).toContain(">3<"); // active schedules
+  });
+});
+
+describe("buildHtml — table rendering", () => {
+  it("renders template rows with success-rate percentage", () => {
+    const html = buildHtml({
+      templates: [
+        { templateName: "build", runs: 9, successRate: 0.5, avgTokens: 100 },
+      ],
+    });
+    expect(html).toContain("<td>build</td>");
+    expect(html).toContain("<td>50%</td>");
+  });
+
+  it("caps template rows at 10", () => {
+    const templates = Array.from({ length: 15 }, (_, i) => ({
+      templateName: `t${i}`,
+      runs: i,
+      successRate: 1,
+      avgTokens: 0,
+    }));
+    const html = buildHtml({ templates });
+    expect(html).toContain("<td>t9</td>");
+    expect(html).not.toContain("<td>t10</td>"); // 11th dropped
+  });
+
+  it("truncates failure summary to 80 chars", () => {
+    const long = "x".repeat(200);
+    const html = buildHtml({
+      failures: [
+        {
+          templateId: "f",
+          failureCount: 2,
+          commonSummaries: [{ summary: long }],
+        },
+      ],
+    });
+    // the visible table cell is truncated to 80 (the raw 200-char string still
+    // lives untruncated inside the embedded JSON blob, so scope to the <td>).
+    expect(html).toContain("<td>" + "x".repeat(80) + "</td>");
+    expect(html).not.toContain("<td>" + "x".repeat(81));
+  });
+});
+
+describe("buildHtml — XSS safety", () => {
+  it("HTML-escapes user-controlled template names", () => {
+    const html = buildHtml({
+      templates: [
+        {
+          templateName: "<script>alert(1)</script>",
+          runs: 1,
+          successRate: 1,
+          avgTokens: 0,
+        },
+      ],
+    });
+    expect(html).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+    // the raw payload must not appear inside a table cell
+    expect(html).not.toContain("<td><script>alert(1)</script></td>");
+  });
+
+  it("HTML-escapes failure summaries and schedule fields", () => {
+    const html = buildHtml({
+      failures: [
+        {
+          templateName: "<b>x</b>",
+          failureCount: 1,
+          commonSummaries: [{ summary: "a&b\"c'" }],
+        },
+      ],
+      schedules: {
+        nextTriggers: [
+          { at: "<i>t</i>", cron: "* * * * *", scheduleId: "s<1>" },
+        ],
+      },
+    });
+    expect(html).toContain("&lt;b&gt;x&lt;/b&gt;");
+    expect(html).toContain("a&amp;b&quot;c&#39;");
+    expect(html).toContain("&lt;i&gt;t&lt;/i&gt;");
+    expect(html).toContain("s&lt;1&gt;");
+  });
+
+  it("escapes a </script> breakout in the embedded JSON blob", () => {
+    const html = buildHtml({
+      tasks: { note: "</script><img src=x onerror=alert(1)>" },
+    });
+    // the inline JSON must not contain a raw closing script tag
+    expect(html).toContain("\\u003c/script");
+    expect(html).not.toContain("</script><img");
+  });
+
+  it("escapes <, > and & in the embedded JSON blob", () => {
+    const html = buildHtml({ x: "<a> & <b>" });
+    expect(html).toContain("\\u003ca\\u003e \\u0026 \\u003cb\\u003e");
+    // the script assignment line itself carries the escaped form
+    expect(html).toContain("window.__COWORK_OBSERVE__ =");
+  });
+});

package/src/lib/__tests__/logger.test.js

@@ -0,0 +1,110 @@
+"use strict";
+
+/**
+ * logger tests (previously untested) — the cc CLI's console logger. Small but
+ * the gating semantics matter: quiet suppresses info/success/log/newline but
+ * must NEVER suppress warn/error (otherwise failures would be hidden), and
+ * verbose only emits when enabled. console is spied; module-level verbose/quiet
+ * flags are reset between tests.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  setVerbose,
+  setQuiet,
+  info,
+  success,
+  warn,
+  error,
+  verbose,
+  log,
+  newline,
+  logger,
+} from "../logger.js";
+
+let logSpy;
+let errSpy;
+
+beforeEach(() => {
+  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  setQuiet(false);
+  setVerbose(false);
+});
+
+afterEach(() => {
+  setQuiet(false);
+  setVerbose(false);
+  vi.restoreAllMocks();
+});
+
+describe("default (not quiet, not verbose)", () => {
+  it("info/success/log/newline write to console.log", () => {
+    info("i");
+    success("s");
+    log("l");
+    newline();
+    expect(logSpy).toHaveBeenCalledTimes(4);
+  });
+
+  it("verbose is suppressed unless enabled", () => {
+    verbose("v");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("error writes to console.error, not console.log", () => {
+    error("boom");
+    expect(errSpy).toHaveBeenCalledTimes(1);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("quiet mode", () => {
+  beforeEach(() => setQuiet(true));
+
+  it("suppresses info/success/log/newline", () => {
+    info("i");
+    success("s");
+    log("l");
+    newline();
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("does NOT suppress warn (still console.log)", () => {
+    warn("careful");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT suppress error", () => {
+    error("boom");
+    expect(errSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("verbose mode", () => {
+  it("emits verbose only after setVerbose(true)", () => {
+    verbose("before");
+    expect(logSpy).not.toHaveBeenCalled();
+    setVerbose(true);
+    verbose("after");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger object", () => {
+  it("exposes the full method surface", () => {
+    for (const m of [
+      "info",
+      "success",
+      "warn",
+      "error",
+      "verbose",
+      "log",
+      "newline",
+      "setVerbose",
+      "setQuiet",
+    ]) {
+      expect(typeof logger[m]).toBe("function");
+    }
+  });
+});