chainlesschain 0.162.101 → 0.162.103

package/src/repl/__tests__/slash-macro.test.js

@@ -0,0 +1,81 @@
+"use strict";
+
+/**
+ * resolveSlashMacro tests (previously untested) — the REPL's user-command-macro
+ * wire (.claude/commands/*.md). The routing safety matters: a leading `/name`
+ * that resolves to a macro is expanded, but plain text or an unknown `/...`
+ * (e.g. asking about "/etc/hosts") must pass through verbatim to the LLM and
+ * never be swallowed. Deps (getCommand/expandCommand) are injected; no I/O.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { resolveSlashMacro } from "../slash-macro.js";
+
+const deps = (macro, expand = { prompt: "EXPANDED", warnings: [] }) => ({
+  getCommand: vi.fn(() => macro),
+  expandCommand: vi.fn(() => expand),
+});
+
+describe("resolveSlashMacro", () => {
+  it("returns plain text unchanged (no slash)", async () => {
+    const r = await resolveSlashMacro("  just a question  ", {
+      deps: deps(null),
+    });
+    expect(r.matched).toBe(false);
+    expect(r.promptText).toBe("just a question"); // trimmed
+  });
+
+  it("passes an unknown /... through verbatim (does not swallow /etc/hosts)", async () => {
+    const d = deps(null);
+    const r = await resolveSlashMacro("/etc/hosts is interesting", { deps: d });
+    expect(r.matched).toBe(false);
+    expect(r.promptText).toBe("/etc/hosts is interesting");
+    // first token after the slash was probed, but no macro matched
+    expect(d.getCommand).toHaveBeenCalledWith("etc/hosts", expect.any(String));
+  });
+
+  it("expands a resolved macro and reports its name/scope", async () => {
+    const macro = { name: "deploy", scope: "project" };
+    const d = deps(macro);
+    const r = await resolveSlashMacro("/deploy prod fast", {
+      deps: d,
+      cwd: "/proj",
+    });
+    expect(r.matched).toBe(true);
+    expect(r.promptText).toBe("EXPANDED");
+    expect(r.name).toBe("deploy");
+    expect(r.scope).toBe("project");
+    expect(d.getCommand).toHaveBeenCalledWith("deploy", "/proj");
+    expect(d.expandCommand).toHaveBeenCalledWith(macro, ["prod", "fast"], {
+      cwd: "/proj",
+    });
+  });
+
+  it("propagates warnings from expandCommand", async () => {
+    const d = deps(
+      { name: "x", scope: "personal" },
+      {
+        prompt: "P",
+        warnings: ["missing $2"],
+      },
+    );
+    const r = await resolveSlashMacro("/x a", { deps: d });
+    expect(r.warnings).toEqual(["missing $2"]);
+  });
+
+  it("does not treat a bare '/' as a command", async () => {
+    const d = deps({ name: "should-not-fire", scope: "project" });
+    const r = await resolveSlashMacro("/", { deps: d });
+    expect(r.matched).toBe(false);
+    expect(d.getCommand).not.toHaveBeenCalled(); // empty head → never probed
+  });
+
+  it("handles empty/nullish input", async () => {
+    expect((await resolveSlashMacro("", { deps: deps(null) })).matched).toBe(
+      false,
+    );
+    expect(
+      (await resolveSlashMacro(null, { deps: deps(null) })).promptText,
+    ).toBe("");
+  });
+});

package/src/runtime/__tests__/coding-agent-contract-shared.test.js

@@ -0,0 +1,136 @@
+"use strict";
+
+/**
+ * coding-agent-contract-shared tests (previously untested) — the single source
+ * of truth for the coding agent's tool surface (the function-calling contracts
+ * the LLM sees). Rather than hardcode the whole table, this pins the accessor
+ * contracts + cross-table invariants: every listed name resolves to a contract
+ * AND a function definition, lookups return defensive clones, unknown -> null,
+ * the OpenAI function-tool shape, names/tier filtering, MVP/extension membership
+ * and the policy projection. Anchored on the stable `read_file` tool. No I/O.
+ */
+
+import { describe, it, expect } from "vitest";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const {
+  CODING_AGENT_MVP_TOOL_NAMES,
+  CODING_AGENT_EXTENSION_TOOL_NAMES,
+  getCodingAgentFunctionToolDefinition,
+  getCodingAgentFunctionToolDefinitions,
+  getCodingAgentToolContract,
+  getCodingAgentToolContracts,
+  getCodingAgentToolPolicy,
+  isCodingAgentMvpTool,
+  listCodingAgentToolNames,
+} = require("../coding-agent-contract-shared.cjs");
+
+describe("listCodingAgentToolNames + consistency", () => {
+  it("returns a non-empty list of unique names including read_file", () => {
+    const names = listCodingAgentToolNames();
+    expect(names.length).toBeGreaterThan(0);
+    expect(new Set(names).size).toBe(names.length);
+    expect(names).toContain("read_file");
+  });
+
+  it("every listed name resolves to both a contract and a function definition", () => {
+    for (const n of listCodingAgentToolNames()) {
+      expect(getCodingAgentToolContract(n)).toBeTruthy();
+      expect(getCodingAgentFunctionToolDefinition(n)).toBeTruthy();
+    }
+  });
+});
+
+describe("getCodingAgentToolContract", () => {
+  it("returns the contract for a known tool", () => {
+    const c = getCodingAgentToolContract("read_file");
+    expect(c.name).toBe("read_file");
+    expect(c.tier).toBe("mvp");
+  });
+
+  it("returns null for an unknown tool", () => {
+    expect(getCodingAgentToolContract("__nope__")).toBe(null);
+  });
+
+  it("returns a defensive clone (mutation does not leak back)", () => {
+    const a = getCodingAgentToolContract("read_file");
+    a.name = "MUTATED";
+    expect(getCodingAgentToolContract("read_file").name).toBe("read_file");
+  });
+});
+
+describe("getCodingAgentFunctionToolDefinition", () => {
+  it("emits an OpenAI function-tool definition for a known tool", () => {
+    const def = getCodingAgentFunctionToolDefinition("read_file");
+    expect(def.type).toBe("function");
+    expect(def.function.name).toBe("read_file");
+    expect(typeof def.function.description).toBe("string");
+    expect(def.function.parameters.type).toBe("object");
+    expect(def.function.parameters.required).toContain("path");
+  });
+
+  it("returns null for an unknown tool", () => {
+    expect(getCodingAgentFunctionToolDefinition("__nope__")).toBe(null);
+  });
+});
+
+describe("getCodingAgentFunctionToolDefinitions filtering", () => {
+  it("filters by an explicit names allow-list", () => {
+    const defs = getCodingAgentFunctionToolDefinitions({
+      names: ["read_file"],
+    });
+    expect(defs).toHaveLength(1);
+    expect(defs[0].function.name).toBe("read_file");
+  });
+
+  it("treats an empty names array as no filter (returns all)", () => {
+    const all = getCodingAgentFunctionToolDefinitions();
+    expect(getCodingAgentFunctionToolDefinitions({ names: [] })).toHaveLength(
+      all.length,
+    );
+  });
+
+  it("returns [] for unknown names", () => {
+    expect(
+      getCodingAgentFunctionToolDefinitions({ names: ["__nope__"] }),
+    ).toHaveLength(0);
+  });
+});
+
+describe("tier filtering", () => {
+  it("getCodingAgentToolContracts({tier}) returns only that tier", () => {
+    const mvp = getCodingAgentToolContracts({ tier: "mvp" });
+    expect(mvp.length).toBeGreaterThan(0);
+    expect(mvp.every((t) => t.tier === "mvp")).toBe(true);
+  });
+});
+
+describe("isCodingAgentMvpTool + membership", () => {
+  it("is true for every MVP name and false for unknown", () => {
+    for (const n of CODING_AGENT_MVP_TOOL_NAMES)
+      expect(isCodingAgentMvpTool(n)).toBe(true);
+    expect(isCodingAgentMvpTool("__nope__")).toBe(false);
+  });
+
+  it("MVP and extension names are all valid tool names", () => {
+    const all = new Set(listCodingAgentToolNames());
+    for (const n of CODING_AGENT_MVP_TOOL_NAMES) expect(all.has(n)).toBe(true);
+    for (const n of CODING_AGENT_EXTENSION_TOOL_NAMES)
+      expect(all.has(n)).toBe(true);
+  });
+});
+
+describe("getCodingAgentToolPolicy", () => {
+  it("projects the policy fields for a known tool", () => {
+    const p = getCodingAgentToolPolicy("read_file");
+    expect(p).toHaveProperty("tier");
+    expect(p).toHaveProperty("riskLevel");
+    expect(p).toHaveProperty("permissions");
+    expect(typeof p.planModeBehavior).toBe("string"); // defaults to "standard"
+  });
+
+  it("returns null for an unknown tool", () => {
+    expect(getCodingAgentToolPolicy("__nope__")).toBe(null);
+  });
+});

package/src/runtime/__tests__/coding-agent-events.test.js

@@ -0,0 +1,263 @@
+"use strict";
+
+/**
+ * coding-agent-events tests (previously untested) — the unified event protocol
+ * shared by the CLI runtime, Desktop Main and the Renderer. Pins the contract:
+ * mapLegacyType normalization, the per-requestId monotonic SequenceTracker,
+ * createCodingAgentEvent envelope shaping (type normalize, id/eventId alias,
+ * sessionId/requestId resolution, sequence rules, meta sanitization, source
+ * default), wrapLegacyMessage, and validateCodingAgentEvent (version/type/
+ * eventId/payload checks). A fresh tracker is injected per test to avoid the
+ * module-global default tracker leaking state. No I/O.
+ */
+
+import { describe, it, expect } from "vitest";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const {
+  CODING_AGENT_EVENT_VERSION,
+  CODING_AGENT_EVENT_TYPES,
+  LEGACY_TO_UNIFIED_TYPE,
+  CodingAgentSequenceTracker,
+  createCodingAgentEvent,
+  wrapLegacyMessage,
+  validateCodingAgentEvent,
+  mapLegacyType,
+} = require("../coding-agent-events.cjs");
+
+const VALID_TYPE = Object.values(CODING_AGENT_EVENT_TYPES)[0];
+const newTracker = () => new CodingAgentSequenceTracker();
+
+describe("mapLegacyType", () => {
+  it("returns null for falsy input", () => {
+    expect(mapLegacyType(null)).toBe(null);
+    expect(mapLegacyType("")).toBe(null);
+  });
+
+  it("maps a known legacy type to its canonical form", () => {
+    const entries = Object.entries(LEGACY_TO_UNIFIED_TYPE);
+    expect(entries.length).toBeGreaterThan(0);
+    const [legacy, unified] = entries[0];
+    expect(mapLegacyType(legacy)).toBe(unified);
+  });
+
+  it("passes an unknown type through unchanged", () => {
+    expect(mapLegacyType("totally.unknown.type")).toBe("totally.unknown.type");
+  });
+});
+
+describe("CodingAgentSequenceTracker", () => {
+  it("increments strictly per requestId", () => {
+    const t = newTracker();
+    expect(t.next("r1")).toBe(1);
+    expect(t.next("r1")).toBe(2);
+    expect(t.next("r1")).toBe(3);
+  });
+
+  it("keeps separate requestIds independent", () => {
+    const t = newTracker();
+    expect(t.next("a")).toBe(1);
+    expect(t.next("b")).toBe(1);
+    expect(t.next("a")).toBe(2);
+  });
+
+  it("returns 0 for a falsy requestId without advancing", () => {
+    const t = newTracker();
+    expect(t.next(null)).toBe(0);
+    expect(t.next(null)).toBe(0);
+  });
+
+  it("peek reads without advancing; reset clears", () => {
+    const t = newTracker();
+    t.next("r");
+    expect(t.peek("r")).toBe(1);
+    expect(t.peek("r")).toBe(1);
+    t.reset("r");
+    expect(t.next("r")).toBe(1); // back to start
+  });
+});
+
+describe("createCodingAgentEvent", () => {
+  it("throws on a non-object payload", () => {
+    expect(() => createCodingAgentEvent(VALID_TYPE, "nope")).toThrow(TypeError);
+  });
+
+  it("produces a versioned envelope with eventId/id alias and defaults", () => {
+    const ev = createCodingAgentEvent(
+      VALID_TYPE,
+      { x: 1 },
+      { tracker: newTracker() },
+    );
+    expect(ev.version).toBe(CODING_AGENT_EVENT_VERSION);
+    expect(ev.type).toBe(VALID_TYPE);
+    expect(ev.eventId).toBeTruthy();
+    expect(ev.id).toBe(ev.eventId); // legacy alias
+    expect(ev.source).toBe("desktop-main"); // default source
+    expect(ev.payload).toEqual({ x: 1 });
+  });
+
+  it("normalizes a legacy type alias", () => {
+    const [legacy, unified] = Object.entries(LEGACY_TO_UNIFIED_TYPE)[0];
+    expect(
+      createCodingAgentEvent(legacy, {}, { tracker: newTracker() }).type,
+    ).toBe(unified);
+  });
+
+  it("resolves sessionId/requestId from context, falling back to payload", () => {
+    const fromCtx = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      {
+        sessionId: "s1",
+        requestId: "r1",
+        tracker: newTracker(),
+      },
+    );
+    expect(fromCtx.sessionId).toBe("s1");
+    expect(fromCtx.requestId).toBe("r1");
+
+    const fromPayload = createCodingAgentEvent(
+      VALID_TYPE,
+      { sessionId: "sp", id: "rp" },
+      {
+        tracker: newTracker(),
+      },
+    );
+    expect(fromPayload.sessionId).toBe("sp");
+    expect(fromPayload.requestId).toBe("rp");
+  });
+
+  it("uses an explicit integer sequence when provided", () => {
+    const ev = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      { sequence: 7, tracker: newTracker() },
+    );
+    expect(ev.sequence).toBe(7);
+  });
+
+  it("auto-increments sequence via the tracker for a requestId", () => {
+    const tracker = newTracker();
+    const a = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      { requestId: "r", tracker },
+    );
+    const b = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      { requestId: "r", tracker },
+    );
+    expect(a.sequence).toBe(1);
+    expect(b.sequence).toBe(2);
+  });
+
+  it("leaves sequence null when there is no requestId and no explicit value", () => {
+    const ev = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      { tracker: newTracker() },
+    );
+    expect(ev.sequence).toBe(null);
+  });
+
+  it("honors an explicit eventId and timestamp", () => {
+    const ev = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      {
+        eventId: "fixed-id",
+        timestamp: 1234,
+        tracker: newTracker(),
+      },
+    );
+    expect(ev.eventId).toBe("fixed-id");
+    expect(ev.timestamp).toBe(1234);
+  });
+
+  it("strips envelope fields accidentally placed in meta", () => {
+    const ev = createCodingAgentEvent(
+      VALID_TYPE,
+      {},
+      {
+        meta: {
+          sessionId: "x",
+          requestId: "y",
+          sequence: 9,
+          source: "z",
+          eventId: "e",
+          keep: "ok",
+        },
+        tracker: newTracker(),
+      },
+    );
+    expect(ev.meta).toEqual({ keep: "ok" });
+  });
+});
+
+describe("wrapLegacyMessage", () => {
+  it("throws for a non-object message", () => {
+    expect(() => wrapLegacyMessage(null)).toThrow(TypeError);
+  });
+
+  it("splits {type, ...payload} and resolves requestId from message.id", () => {
+    const ev = wrapLegacyMessage(
+      { type: VALID_TYPE, id: "req-9", foo: "bar" },
+      { tracker: newTracker() },
+    );
+    expect(ev.type).toBe(VALID_TYPE);
+    expect(ev.requestId).toBe("req-9");
+    expect(ev.payload.foo).toBe("bar");
+  });
+});
+
+describe("validateCodingAgentEvent", () => {
+  const valid = () =>
+    createCodingAgentEvent(VALID_TYPE, {}, { tracker: newTracker() });
+
+  it("accepts a freshly created envelope", () => {
+    expect(validateCodingAgentEvent(valid())).toEqual({
+      valid: true,
+      errors: [],
+    });
+  });
+
+  it("rejects a non-object", () => {
+    const r = validateCodingAgentEvent(null);
+    expect(r.valid).toBe(false);
+    expect(r.errors[0]).toMatch(/object/);
+  });
+
+  it("flags a wrong version", () => {
+    const r = validateCodingAgentEvent({ ...valid(), version: "v0" });
+    expect(r.valid).toBe(false);
+    expect(r.errors.some((e) => /version/.test(e))).toBe(true);
+  });
+
+  it("flags a missing or non-whitelisted type", () => {
+    expect(
+      validateCodingAgentEvent({ ...valid(), type: undefined }).errors.some(
+        (e) => /type is required/.test(e),
+      ),
+    ).toBe(true);
+    expect(
+      validateCodingAgentEvent({ ...valid(), type: "bogus.type" }).errors.some(
+        (e) => /whitelist/.test(e),
+      ),
+    ).toBe(true);
+  });
+
+  it("flags a missing eventId and a non-object payload", () => {
+    expect(
+      validateCodingAgentEvent({ ...valid(), eventId: undefined }).errors.some(
+        (e) => /eventId/.test(e),
+      ),
+    ).toBe(true);
+    expect(
+      validateCodingAgentEvent({ ...valid(), payload: "x" }).errors.some((e) =>
+        /payload/.test(e),
+      ),
+    ).toBe(true);
+  });
+});

package/src/assets/web-panel/assets/MobileProjects-DhDxrWze.js

@@ -1 +0,0 @@
-import{I as n,J as g,c as l,K as r,N as u,P as h,U as o,R as t,Q as b}from"./vendor-BvqAck49.js";import{_ as v,b as m}from"./index-Dl_NdY39.js";import{a7 as M,M as y}from"./icons-DP3uiYxy.js";const B={__name:"MobileProjects",setup(p,{expose:i}){i();const c=u(),{t:e}=m();function a(){c.push("/projects")}function _(){c.push("/mobile-bridge")}const s={router:c,t:e,goToProjects:a,goToMobileBridge:_,get useRouter(){return u},get useI18n(){return m},get MobileOutlined(){return y},get FolderOutlined(){return M}};return Object.defineProperty(s,"__isScriptSetup",{enumerable:!1,value:!0}),s}},x={class:"mobile-projects-placeholder"},O={class:"title"},k={class:"subtitle"},w={class:"explainer"};function T(p,i,c,e,a,_){const s=n("a-alert"),d=n("a-button"),f=n("a-space"),P=n("a-empty"),j=n("a-card");return h(),g("div",x,[l(j,null,{default:r(()=>[l(P,{description:!1},{image:r(()=>[l(e.MobileOutlined,{style:{fontSize:"64px",color:"#bfbfbf"}})]),default:r(()=>[o("h2",O,t(e.t("mobileProjects.title")),1),o("p",k,t(e.t("mobileProjects.subtitle")),1),l(s,{message:e.t("mobileProjects.v02Banner"),type:"info","show-icon":"",class:"banner"},null,8,["message"]),o("div",w,[o("h3",null,t(e.t("mobileProjects.currentDirection")),1),o("p",null,t(e.t("mobileProjects.currentDirectionBody")),1),o("ul",null,[o("li",null,t(e.t("mobileProjects.stepPhone")),1),o("li",null,t(e.t("mobileProjects.stepTap")),1),o("li",null,t(e.t("mobileProjects.stepPull")),1)]),o("h3",null,t(e.t("mobileProjects.reverseDirection")),1),o("p",null,t(e.t("mobileProjects.reverseDirectionBody")),1)]),l(f,{class:"actions"},{default:r(()=>[l(d,{type:"primary",onClick:e.goToProjects},{default:r(()=>[l(e.FolderOutlined),b(" "+t(e.t("mobileProjects.viewLocalProjects")),1)]),_:1}),l(d,{onClick:e.goToMobileBridge},{default:r(()=>[l(e.MobileOutlined),b(" "+t(e.t("mobileProjects.checkBridge")),1)]),_:1})]),_:1})]),_:1})]),_:1})])}const N=v(B,[["render",T],["__scopeId","data-v-9262cc45"],["__file","/tmp/cc-web-panel-aMJ4KB/repo/packages/web-panel/src/views/MobileProjects.vue"]]);export{N as default};

package/src/assets/web-panel/assets/devWarning-OhxeajH6.js

@@ -1 +0,0 @@
-import{O as r}from"./index-Dl_NdY39.js";const o=((n,a,e)=>{r(n,`[ant-design-vue: ${a}] ${e}`)});export{o as d};

package/src/assets/web-panel/assets/index-Bbtoi_47.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-rLxg7xk5.js";import{U as t}from"./index-Dl_NdY39.js";import"./vendor-BvqAck49.js";import"./responsiveObserve-DvIIMTD_.js";import"./useFlexGapSupport-DYv7Tvk0.js";import"./styleChecker-BNYQS60m.js";import"./index-CxKdSB-p.js";import"./icons-DP3uiYxy.js";const l=t(o);export{l as default};

package/src/assets/web-panel/assets/index-Cb8RWwaB.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-C2cV_dw4.js";import{U as t}from"./index-Dl_NdY39.js";import"./vendor-BvqAck49.js";import"./index-CxKdSB-p.js";import"./icons-DP3uiYxy.js";const s=t(o);export{s as default};