@calltelemetry/openclaw-linear 0.7.1 → 0.8.0

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({});
+  });
+});

package/src/infra/cli.ts

@@ -8,7 +8,8 @@ import { exec } from "node:child_process";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveLinearToken, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "../api/linear-api.js";
+import { resolveLinearToken, LinearAgentApi, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "../api/linear-api.js";
+import { validateRepoPath } from "./multi-repo.js";
 import { LINEAR_OAUTH_AUTH_URL, LINEAR_OAUTH_TOKEN_URL, LINEAR_AGENT_SCOPES } from "../api/auth.js";
 import { listWorktrees } from "./codex-worktree.js";
 import { loadPrompts, clearPromptCache } from "../pipeline/pipeline.js";
@@ -250,6 +251,25 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
       console.log(`\nTo remove one: openclaw openclaw-linear worktrees --prune <path>\n`);
     });
 
+  // --- openclaw openclaw-linear repos ---
+  const repos = linear
+    .command("repos")
+    .description("Validate multi-repo config and sync labels to Linear");
+
+  repos
+    .command("check")
+    .description("Validate repo paths and show what labels would be created (dry run)")
+    .action(async () => {
+      await reposAction(api, { dryRun: true });
+    });
+
+  repos
+    .command("sync")
+    .description("Create missing repo: labels in Linear from your repos config")
+    .action(async () => {
+      await reposAction(api, { dryRun: false });
+    });
+
   // --- openclaw openclaw-linear prompts ---
   const prompts = linear
     .command("prompts")
@@ -625,3 +645,158 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
       }
     });
 }
+
+// ---------------------------------------------------------------------------
+// repos sync / check helper
+// ---------------------------------------------------------------------------
+
+const REPO_LABEL_COLOR = "#5e6ad2"; // Linear indigo
+
+async function reposAction(
+  api: OpenClawPluginApi,
+  opts: { dryRun: boolean },
+): Promise<void> {
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const reposMap = (pluginConfig?.repos as Record<string, string> | undefined) ?? {};
+  const repoNames = Object.keys(reposMap);
+
+  const mode = opts.dryRun ? "Repos Check" : "Repos Sync";
+  console.log(`\n${mode}`);
+  console.log("─".repeat(40));
+
+  // 1. Validate config
+  if (repoNames.length === 0) {
+    console.log(`\n  No "repos" configured in plugin config.`);
+    console.log(`  Add a repos map to openclaw.json → plugins.entries.openclaw-linear.config:`);
+    console.log(`\n    "repos": {`);
+    console.log(`      "api": "/home/claw/repos/api",`);
+    console.log(`      "frontend": "/home/claw/repos/frontend"`);
+    console.log(`    }\n`);
+    return;
+  }
+
+  // 2. Validate each repo path
+  console.log("\n  Repos from config:");
+  const warnings: string[] = [];
+
+  for (const name of repoNames) {
+    const repoPath = reposMap[name];
+    const status = validateRepoPath(repoPath);
+    const pad = name.padEnd(16);
+
+    if (!status.exists) {
+      console.log(`  \u2717 ${pad} ${repoPath} (path not found)`);
+      warnings.push(`"${name}" at ${repoPath} does not exist`);
+    } else if (!status.isGitRepo) {
+      console.log(`  \u2717 ${pad} ${repoPath} (not a git repo)`);
+      warnings.push(`"${name}" at ${repoPath} is not a git repository`);
+    } else if (status.isSubmodule) {
+      console.log(`  \u26a0 ${pad} ${repoPath} (submodule)`);
+      warnings.push(`"${name}" at ${repoPath} is a git submodule`);
+    } else {
+      console.log(`  \u2714 ${pad} ${repoPath} (git repo)`);
+    }
+  }
+
+  // 3. Connect to Linear
+  const tokenInfo = resolveLinearToken(pluginConfig);
+  if (!tokenInfo.accessToken) {
+    console.log(`\n  No Linear token found. Run "openclaw openclaw-linear auth" first.\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const linearApi = new LinearAgentApi(tokenInfo.accessToken, {
+    refreshToken: tokenInfo.refreshToken,
+    expiresAt: tokenInfo.expiresAt,
+    clientId: pluginConfig?.clientId as string | undefined,
+    clientSecret: pluginConfig?.clientSecret as string | undefined,
+  });
+
+  // 4. Get teams
+  let teams: Array<{ id: string; name: string; key: string }>;
+  try {
+    teams = await linearApi.getTeams();
+  } catch (err) {
+    console.log(`\n  Failed to fetch teams: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (teams.length === 0) {
+    console.log(`\n  No teams found in your Linear workspace.\n`);
+    return;
+  }
+
+  // 5. Sync labels per team
+  let totalCreated = 0;
+  let totalExisted = 0;
+
+  for (const team of teams) {
+    console.log(`\n  Team: ${team.name} (${team.key})`);
+
+    let existingLabels: Array<{ id: string; name: string }>;
+    try {
+      existingLabels = await linearApi.getTeamLabels(team.id);
+    } catch (err) {
+      console.log(`    Failed to fetch labels: ${err instanceof Error ? err.message : String(err)}`);
+      continue;
+    }
+
+    const existingNames = new Set(existingLabels.map(l => l.name.toLowerCase()));
+
+    for (const name of repoNames) {
+      const labelName = `repo:${name}`;
+
+      if (existingNames.has(labelName.toLowerCase())) {
+        console.log(`  \u2714 ${labelName.padEnd(24)} already exists`);
+        totalExisted++;
+      } else if (opts.dryRun) {
+        console.log(`  + ${labelName.padEnd(24)} would be created`);
+      } else {
+        try {
+          await linearApi.createLabel(team.id, labelName, {
+            color: REPO_LABEL_COLOR,
+            description: `Multi-repo dispatch: ${name}`,
+          });
+          console.log(`  + ${labelName.padEnd(24)} created`);
+          totalCreated++;
+        } catch (err) {
+          console.log(`  \u2717 ${labelName.padEnd(24)} failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  }
+
+  // 6. Summary
+  if (opts.dryRun) {
+    const wouldCreate = repoNames.length * teams.length - totalExisted;
+    console.log(`\n  Dry run: ${wouldCreate} label(s) would be created, ${totalExisted} already exist`);
+  } else {
+    console.log(`\n  Summary: ${totalCreated} created, ${totalExisted} already existed`);
+  }
+
+  // 7. Submodule warnings
+  const submoduleWarnings = warnings.filter(w => w.includes("submodule"));
+  if (submoduleWarnings.length > 0) {
+    console.log(`\n  \u26a0 Submodule warning:`);
+    for (const w of submoduleWarnings) {
+      console.log(`    ${w}`);
+    }
+    console.log(`    Multi-repo dispatch uses "git worktree add" which doesn't work on submodules.`);
+    console.log(`    Options:`);
+    console.log(`    1. Clone the repo as a standalone repo instead`);
+    console.log(`    2. Remove it from "repos" config and use the parent repo as codexBaseRepo`);
+  }
+
+  // Other warnings
+  const otherWarnings = warnings.filter(w => !w.includes("submodule"));
+  if (otherWarnings.length > 0) {
+    console.log(`\n  Warnings:`);
+    for (const w of otherWarnings) {
+      console.log(`    \u26a0 ${w}`);
+    }
+  }
+
+  console.log();
+}