@calltelemetry/openclaw-linear 0.7.1 → 0.8.1

package/src/api/linear-api.test.ts

@@ -300,7 +300,7 @@ describe("LinearAgentApi", () => {
       });
 
       await expect(api.updateIssue("i1", { estimate: 1 })).rejects.toThrow(
-        /Linear API 403 \(after refresh\)/,
+        /Linear API authentication failed/,
       );
     });
   });
@@ -464,6 +464,98 @@ describe("LinearAgentApi", () => {
     });
   });
 
+  describe("getTeams", () => {
+    it("returns parsed team list", async () => {
+      fetchMock.mockResolvedValueOnce(
+        okResponse({
+          teams: {
+            nodes: [
+              { id: "t1", name: "Engineering", key: "ENG" },
+              { id: "t2", name: "Design", key: "DES" },
+            ],
+          },
+        }),
+      );
+
+      const api = new LinearAgentApi(TOKEN);
+      const teams = await api.getTeams();
+      expect(teams).toHaveLength(2);
+      expect(teams[0]).toEqual({ id: "t1", name: "Engineering", key: "ENG" });
+      expect(teams[1]).toEqual({ id: "t2", name: "Design", key: "DES" });
+    });
+
+    it("handles empty teams list", async () => {
+      fetchMock.mockResolvedValueOnce(okResponse({ teams: { nodes: [] } }));
+
+      const api = new LinearAgentApi(TOKEN);
+      const teams = await api.getTeams();
+      expect(teams).toEqual([]);
+    });
+  });
+
+  describe("createLabel", () => {
+    it("sends correct mutation and returns label", async () => {
+      fetchMock.mockResolvedValueOnce(
+        okResponse({
+          issueLabelCreate: {
+            success: true,
+            issueLabel: { id: "label-1", name: "repo:api" },
+          },
+        }),
+      );
+
+      const api = new LinearAgentApi(TOKEN);
+      const label = await api.createLabel("t1", "repo:api", {
+        color: "#5e6ad2",
+        description: "Multi-repo dispatch: api",
+      });
+
+      expect(label).toEqual({ id: "label-1", name: "repo:api" });
+
+      const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+      expect(body.query).toContain("issueLabelCreate");
+      expect(body.variables.input).toEqual({
+        teamId: "t1",
+        name: "repo:api",
+        color: "#5e6ad2",
+        description: "Multi-repo dispatch: api",
+      });
+    });
+
+    it("throws on API failure", async () => {
+      fetchMock.mockResolvedValueOnce(
+        okResponse({
+          issueLabelCreate: { success: false, issueLabel: null },
+        }),
+      );
+
+      const api = new LinearAgentApi(TOKEN);
+      await expect(
+        api.createLabel("t1", "repo:bad"),
+      ).rejects.toThrow(/Failed to create label/);
+    });
+
+    it("omits optional fields when not provided", async () => {
+      fetchMock.mockResolvedValueOnce(
+        okResponse({
+          issueLabelCreate: {
+            success: true,
+            issueLabel: { id: "label-2", name: "repo:frontend" },
+          },
+        }),
+      );
+
+      const api = new LinearAgentApi(TOKEN);
+      await api.createLabel("t1", "repo:frontend");
+
+      const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+      expect(body.variables.input).toEqual({
+        teamId: "t1",
+        name: "repo:frontend",
+      });
+    });
+  });
+
   describe("createSessionOnIssue", () => {
     it("returns sessionId on success", async () => {
       fetchMock.mockResolvedValueOnce(

package/src/api/linear-api.ts

@@ -189,7 +189,7 @@ export class LinearAgentApi {
 
       if (!retryRes.ok) {
         const text = await retryRes.text();
-        throw new Error(`Linear API ${retryRes.status} (after refresh): ${text}`);
+        throw new Error(`Linear API authentication failed (${retryRes.status}). Your token may have expired. Run: openclaw openclaw-linear auth`);
       }
 
       const payload = await retryRes.json();
@@ -375,6 +375,42 @@ export class LinearAgentApi {
     return data.team.labels.nodes;
   }
 
+  async getTeams(): Promise<Array<{ id: string; name: string; key: string }>> {
+    const data = await this.gql<{
+      teams: { nodes: Array<{ id: string; name: string; key: string }> };
+    }>(
+      `query { teams { nodes { id name key } } }`,
+    );
+    return data.teams.nodes;
+  }
+
+  async createLabel(
+    teamId: string,
+    name: string,
+    opts?: { color?: string; description?: string },
+  ): Promise<{ id: string; name: string }> {
+    const input: Record<string, string> = { teamId, name };
+    if (opts?.color) input.color = opts.color;
+    if (opts?.description) input.description = opts.description;
+
+    const data = await this.gql<{
+      issueLabelCreate: { success: boolean; issueLabel: { id: string; name: string } };
+    }>(
+      `mutation CreateLabel($input: IssueLabelCreateInput!) {
+        issueLabelCreate(input: $input) {
+          success
+          issueLabel { id name }
+        }
+      }`,
+      { input },
+    );
+
+    if (!data.issueLabelCreate.success) {
+      throw new Error(`Failed to create label "${name}"`);
+    }
+    return data.issueLabelCreate.issueLabel;
+  }
+
   // ---------------------------------------------------------------------------
   // Planning methods
   // ---------------------------------------------------------------------------

package/src/gateway/dispatch-methods.test.ts

@@ -0,0 +1,409 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mock dispatch-state
+// ---------------------------------------------------------------------------
+
+const mockReadDispatchState = vi.fn();
+const mockGetActiveDispatch = vi.fn();
+const mockListActiveDispatches = vi.fn();
+const mockTransitionDispatch = vi.fn();
+const mockRemoveActiveDispatch = vi.fn();
+const mockRegisterDispatch = vi.fn();
+
+vi.mock("../pipeline/dispatch-state.js", () => ({
+  readDispatchState: (...args: any[]) => mockReadDispatchState(...args),
+  getActiveDispatch: (...args: any[]) => mockGetActiveDispatch(...args),
+  listActiveDispatches: (...args: any[]) => mockListActiveDispatches(...args),
+  transitionDispatch: (...args: any[]) => mockTransitionDispatch(...args),
+  removeActiveDispatch: (...args: any[]) => mockRemoveActiveDispatch(...args),
+  registerDispatch: (...args: any[]) => mockRegisterDispatch(...args),
+  TransitionError: class TransitionError extends Error {},
+}));
+
+import { registerDispatchMethods } from "./dispatch-methods.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createApi() {
+  const methods: Record<string, Function> = {};
+  return {
+    api: {
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      pluginConfig: {},
+      registerGatewayMethod: (name: string, handler: Function) => {
+        methods[name] = handler;
+      },
+    } as any,
+    methods,
+  };
+}
+
+function makeDispatch(overrides?: Record<string, any>) {
+  return {
+    issueIdentifier: "CT-100",
+    issueId: "issue-id",
+    status: "working",
+    tier: "senior",
+    attempt: 0,
+    worktreePath: "/wt/ct-100",
+    model: "opus",
+    startedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+function makeState(active: Record<string, any> = {}, completed: Record<string, any> = {}) {
+  return {
+    dispatches: { active, completed },
+    sessionMap: {},
+    processedEvents: [],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("registerDispatchMethods", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("registers all 6 methods", () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+    expect(Object.keys(methods)).toEqual(
+      expect.arrayContaining([
+        "dispatch.list",
+        "dispatch.get",
+        "dispatch.retry",
+        "dispatch.escalate",
+        "dispatch.cancel",
+        "dispatch.stats",
+      ]),
+    );
+  });
+});
+
+describe("dispatch.list", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("returns active and completed dispatches", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch();
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }, { "CT-99": { status: "done" } }));
+    mockListActiveDispatches.mockReturnValue([d]);
+
+    const respond = vi.fn();
+    await methods["dispatch.list"]({ params: {}, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: true,
+      active: [d],
+    }));
+  });
+
+  it("filters by status", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d1 = makeDispatch({ issueIdentifier: "CT-1", status: "working" });
+    const d2 = makeDispatch({ issueIdentifier: "CT-2", status: "stuck" });
+    mockReadDispatchState.mockResolvedValue(makeState());
+    mockListActiveDispatches.mockReturnValue([d1, d2]);
+
+    const respond = vi.fn();
+    await methods["dispatch.list"]({ params: { status: "stuck" }, respond });
+
+    const result = respond.mock.calls[0][1];
+    expect(result.ok).toBe(true);
+    expect(result.active).toEqual([d2]);
+  });
+
+  it("filters by tier", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d1 = makeDispatch({ issueIdentifier: "CT-1", tier: "junior" });
+    const d2 = makeDispatch({ issueIdentifier: "CT-2", tier: "senior" });
+    mockReadDispatchState.mockResolvedValue(makeState());
+    mockListActiveDispatches.mockReturnValue([d1, d2]);
+
+    const respond = vi.fn();
+    await methods["dispatch.list"]({ params: { tier: "senior" }, respond });
+
+    const result = respond.mock.calls[0][1];
+    expect(result.active).toEqual([d2]);
+  });
+});
+
+describe("dispatch.get", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("returns active dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch();
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+
+    const respond = vi.fn();
+    await methods["dispatch.get"]({ params: { identifier: "CT-100" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: true,
+      dispatch: d,
+      source: "active",
+    }));
+  });
+
+  it("returns completed dispatch when not active", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const completed = { status: "done", tier: "junior" };
+    mockReadDispatchState.mockResolvedValue(makeState({}, { "CT-99": completed }));
+    mockGetActiveDispatch.mockReturnValue(undefined);
+
+    const respond = vi.fn();
+    await methods["dispatch.get"]({ params: { identifier: "CT-99" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: true,
+      source: "completed",
+    }));
+  });
+
+  it("fails when identifier missing", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const respond = vi.fn();
+    await methods["dispatch.get"]({ params: {}, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: false,
+      error: expect.stringContaining("identifier"),
+    }));
+  });
+
+  it("fails when dispatch not found", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    mockReadDispatchState.mockResolvedValue(makeState());
+    mockGetActiveDispatch.mockReturnValue(undefined);
+
+    const respond = vi.fn();
+    await methods["dispatch.get"]({ params: { identifier: "NOPE-1" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: false,
+      error: expect.stringContaining("NOPE-1"),
+    }));
+  });
+});
+
+describe("dispatch.retry", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("retries stuck dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch({ status: "stuck", attempt: 1 });
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+    mockRemoveActiveDispatch.mockResolvedValue(undefined);
+    mockRegisterDispatch.mockResolvedValue(undefined);
+
+    const respond = vi.fn();
+    await methods["dispatch.retry"]({ params: { identifier: "CT-100" }, respond });
+
+    const result = respond.mock.calls[0][1];
+    expect(result.ok).toBe(true);
+    expect(result.dispatch.status).toBe("dispatched");
+    expect(result.dispatch.attempt).toBe(2);
+    expect(mockRemoveActiveDispatch).toHaveBeenCalledWith("CT-100", undefined);
+    expect(mockRegisterDispatch).toHaveBeenCalled();
+  });
+
+  it("rejects retry for working dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch({ status: "working" });
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+
+    const respond = vi.fn();
+    await methods["dispatch.retry"]({ params: { identifier: "CT-100" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: false,
+      error: expect.stringContaining("working"),
+    }));
+  });
+
+  it("rejects retry for missing dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    mockReadDispatchState.mockResolvedValue(makeState());
+    mockGetActiveDispatch.mockReturnValue(undefined);
+
+    const respond = vi.fn();
+    await methods["dispatch.retry"]({ params: { identifier: "CT-100" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: false,
+    }));
+  });
+});
+
+describe("dispatch.escalate", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("escalates working dispatch to stuck", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch({ status: "working" });
+    const updated = { ...d, status: "stuck", stuckReason: "Manual escalation" };
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+    mockTransitionDispatch.mockResolvedValue(updated);
+
+    const respond = vi.fn();
+    await methods["dispatch.escalate"]({ params: { identifier: "CT-100", reason: "Manual escalation" }, respond });
+
+    const result = respond.mock.calls[0][1];
+    expect(result.ok).toBe(true);
+    expect(mockTransitionDispatch).toHaveBeenCalledWith("CT-100", "working", "stuck", expect.objectContaining({ stuckReason: "Manual escalation" }), undefined);
+  });
+
+  it("uses default reason when none provided", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch({ status: "auditing" });
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+    mockTransitionDispatch.mockResolvedValue(d);
+
+    const respond = vi.fn();
+    await methods["dispatch.escalate"]({ params: { identifier: "CT-100" }, respond });
+
+    expect(mockTransitionDispatch).toHaveBeenCalledWith(
+      "CT-100", "auditing", "stuck",
+      expect.objectContaining({ stuckReason: "Manually escalated via gateway" }),
+      undefined,
+    );
+  });
+
+  it("rejects escalation for stuck dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch({ status: "stuck" });
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+
+    const respond = vi.fn();
+    await methods["dispatch.escalate"]({ params: { identifier: "CT-100" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: false,
+      error: expect.stringContaining("stuck"),
+    }));
+  });
+});
+
+describe("dispatch.cancel", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("removes active dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const d = makeDispatch({ status: "working" });
+    mockReadDispatchState.mockResolvedValue(makeState({ "CT-100": d }));
+    mockGetActiveDispatch.mockReturnValue(d);
+    mockRemoveActiveDispatch.mockResolvedValue(undefined);
+
+    const respond = vi.fn();
+    await methods["dispatch.cancel"]({ params: { identifier: "CT-100" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: true,
+      cancelled: "CT-100",
+      previousStatus: "working",
+    }));
+    expect(mockRemoveActiveDispatch).toHaveBeenCalledWith("CT-100", undefined);
+  });
+
+  it("fails for missing dispatch", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    mockReadDispatchState.mockResolvedValue(makeState());
+    mockGetActiveDispatch.mockReturnValue(undefined);
+
+    const respond = vi.fn();
+    await methods["dispatch.cancel"]({ params: { identifier: "CT-999" }, respond });
+
+    expect(respond).toHaveBeenCalledWith(true, expect.objectContaining({
+      ok: false,
+    }));
+  });
+});
+
+describe("dispatch.stats", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("returns counts by status and tier", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    const active = [
+      makeDispatch({ status: "working", tier: "senior" }),
+      makeDispatch({ status: "working", tier: "junior" }),
+      makeDispatch({ status: "stuck", tier: "senior" }),
+    ];
+    mockReadDispatchState.mockResolvedValue(makeState({}, { "CT-99": {} }));
+    mockListActiveDispatches.mockReturnValue(active);
+
+    const respond = vi.fn();
+    await methods["dispatch.stats"]({ params: {}, respond });
+
+    const result = respond.mock.calls[0][1];
+    expect(result.ok).toBe(true);
+    expect(result.activeCount).toBe(3);
+    expect(result.completedCount).toBe(1);
+    expect(result.byStatus).toEqual({ working: 2, stuck: 1 });
+    expect(result.byTier).toEqual({ senior: 2, junior: 1 });
+  });
+
+  it("returns zeros when no dispatches", async () => {
+    const { api, methods } = createApi();
+    registerDispatchMethods(api);
+
+    mockReadDispatchState.mockResolvedValue(makeState());
+    mockListActiveDispatches.mockReturnValue([]);
+
+    const respond = vi.fn();
+    await methods["dispatch.stats"]({ params: {}, respond });
+
+    const result = respond.mock.calls[0][1];
+    expect(result.activeCount).toBe(0);
+    expect(result.completedCount).toBe(0);
+    expect(result.byStatus).toEqual({});
+    expect(result.byTier).toEqual({});
+  });
+});