@calltelemetry/openclaw-linear 0.7.1 → 0.8.1

package/src/tools/claude-tool.ts

@@ -150,6 +150,12 @@ export async function runClaude(
     const env = { ...process.env };
     delete env.CLAUDECODE;
 
+    // Pass Anthropic API key if configured (plugin config takes precedence over env)
+    const claudeApiKey = pluginConfig?.claudeApiKey as string | undefined;
+    if (claudeApiKey) {
+      env.ANTHROPIC_API_KEY = claudeApiKey;
+    }
+
     const child = spawn(CLAUDE_BIN, args, {
       stdio: ["ignore", "pipe", "pipe"],
       cwd: workingDir,

package/src/tools/cli-shared.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock the active-session module
+vi.mock("../pipeline/active-session.js", () => ({
+  getCurrentSession: vi.fn(() => null),
+  getActiveSessionByIdentifier: vi.fn(() => null),
+}));
+
+// Mock the linear-api module — LinearAgentApi must be a class (used with `new`)
+vi.mock("../api/linear-api.js", () => {
+  const MockClass = vi.fn(function (this: any) {
+    return this;
+  });
+  return {
+    resolveLinearToken: vi.fn(() => ({ accessToken: null, source: "none" })),
+    LinearAgentApi: MockClass,
+  };
+});
+
+// Mock the watchdog module (re-exported constants)
+vi.mock("../agent/watchdog.js", () => ({
+  DEFAULT_INACTIVITY_SEC: 120,
+  DEFAULT_MAX_TOTAL_SEC: 7200,
+  DEFAULT_TOOL_TIMEOUT_SEC: 600,
+}));
+
+import { getCurrentSession, getActiveSessionByIdentifier } from "../pipeline/active-session.js";
+import { resolveLinearToken, LinearAgentApi } from "../api/linear-api.js";
+import { extractPrompt, resolveSession, buildLinearApi } from "./cli-shared.js";
+import type { CliToolParams } from "./cli-shared.js";
+
+const mockedGetCurrentSession = vi.mocked(getCurrentSession);
+const mockedGetActiveByIdentifier = vi.mocked(getActiveSessionByIdentifier);
+const mockedResolveLinearToken = vi.mocked(resolveLinearToken);
+const MockedLinearAgentApi = vi.mocked(LinearAgentApi);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// extractPrompt
+// ---------------------------------------------------------------------------
+describe("extractPrompt", () => {
+  it("returns prompt field when present", () => {
+    const params: CliToolParams = { prompt: "do the thing" };
+    expect(extractPrompt(params)).toBe("do the thing");
+  });
+
+  it("falls back to text field", () => {
+    const params = { text: "text fallback" } as unknown as CliToolParams;
+    expect(extractPrompt(params)).toBe("text fallback");
+  });
+
+  it("falls back to message field", () => {
+    const params = { message: "message fallback" } as unknown as CliToolParams;
+    expect(extractPrompt(params)).toBe("message fallback");
+  });
+
+  it("falls back to task field", () => {
+    const params = { task: "task fallback" } as unknown as CliToolParams;
+    expect(extractPrompt(params)).toBe("task fallback");
+  });
+
+  it("returns undefined when no fields present", () => {
+    const params = {} as unknown as CliToolParams;
+    expect(extractPrompt(params)).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveSession
+// ---------------------------------------------------------------------------
+describe("resolveSession", () => {
+  it("uses explicit session params when provided", () => {
+    const params: CliToolParams = {
+      prompt: "test",
+      agentSessionId: "sess-123",
+      issueIdentifier: "API-42",
+    };
+
+    const result = resolveSession(params);
+    expect(result.agentSessionId).toBe("sess-123");
+    expect(result.issueIdentifier).toBe("API-42");
+    // Should not consult the registry at all
+    expect(mockedGetCurrentSession).not.toHaveBeenCalled();
+    expect(mockedGetActiveByIdentifier).not.toHaveBeenCalled();
+  });
+
+  it("falls back to active session registry", () => {
+    mockedGetCurrentSession.mockReturnValue({
+      agentSessionId: "active-sess-456",
+      issueIdentifier: "API-99",
+      issueId: "issue-id-99",
+      startedAt: Date.now(),
+    });
+
+    const params: CliToolParams = { prompt: "test" };
+    const result = resolveSession(params);
+
+    expect(result.agentSessionId).toBe("active-sess-456");
+    expect(result.issueIdentifier).toBe("API-99");
+    expect(mockedGetCurrentSession).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildLinearApi
+// ---------------------------------------------------------------------------
+describe("buildLinearApi", () => {
+  it("returns null when no agentSessionId provided", () => {
+    const api = { pluginConfig: {} } as any;
+    expect(buildLinearApi(api)).toBeNull();
+    expect(buildLinearApi(api, undefined)).toBeNull();
+  });
+
+  it("returns null when no token available", () => {
+    mockedResolveLinearToken.mockReturnValue({
+      accessToken: null,
+      source: "none",
+    });
+
+    const api = { pluginConfig: {} } as any;
+    expect(buildLinearApi(api, "sess-123")).toBeNull();
+  });
+
+  it("creates a LinearAgentApi when token is available", () => {
+    mockedResolveLinearToken.mockReturnValue({
+      accessToken: "lin_tok_abc",
+      refreshToken: "refresh_xyz",
+      expiresAt: 9999999999,
+      source: "profile",
+    });
+    MockedLinearAgentApi.mockImplementation(function (this: any) {
+      this.fake = true;
+      return this;
+    } as any);
+
+    const api = {
+      pluginConfig: {
+        clientId: "cid",
+        clientSecret: "csecret",
+      },
+    } as any;
+
+    const result = buildLinearApi(api, "sess-123");
+    expect(result).not.toBeNull();
+    expect(MockedLinearAgentApi).toHaveBeenCalledWith("lin_tok_abc", {
+      refreshToken: "refresh_xyz",
+      expiresAt: 9999999999,
+      clientId: "cid",
+      clientSecret: "csecret",
+    });
+  });
+});

package/src/tools/code-tool.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock node:fs so loadCodingConfig can be tested
+vi.mock("node:fs", () => ({
+  readFileSync: vi.fn(),
+}));
+
+// Mock heavy runner dependencies — we only test resolution/config logic
+vi.mock("./codex-tool.js", () => ({
+  runCodex: vi.fn(),
+}));
+vi.mock("./claude-tool.js", () => ({
+  runClaude: vi.fn(),
+}));
+vi.mock("./gemini-tool.js", () => ({
+  runGemini: vi.fn(),
+}));
+vi.mock("../pipeline/active-session.js", () => ({
+  getCurrentSession: vi.fn(() => null),
+}));
+vi.mock("openclaw/plugin-sdk", () => ({
+  jsonResult: vi.fn((v: unknown) => v),
+}));
+
+import { readFileSync } from "node:fs";
+import type { CodingToolsConfig } from "./code-tool.js";
+import { loadCodingConfig, resolveCodingBackend } from "./code-tool.js";
+
+// buildAliasMap and resolveAlias are not exported, so we test them indirectly
+// through the module's behaviour. However, for direct testing we can re-derive
+// the same logic here with a small helper that mirrors the source (or just
+// test through resolveCodingBackend / createCodeTool).
+//
+// Since buildAliasMap and resolveAlias are private, we import the module source
+// and test their effects through the public API. For unit-level tests we
+// replicate the minimal logic inline.
+
+// Inline copies of the private helpers, matching the source exactly.
+// This lets us unit-test alias mapping without exporting internals.
+type CodingBackend = "claude" | "codex" | "gemini";
+
+const BACKEND_IDS: CodingBackend[] = ["claude", "codex", "gemini"];
+
+function buildAliasMap(config: CodingToolsConfig): Map<string, CodingBackend> {
+  const map = new Map<string, CodingBackend>();
+  for (const backendId of BACKEND_IDS) {
+    map.set(backendId, backendId);
+    const aliases = config.backends?.[backendId]?.aliases;
+    if (aliases) {
+      for (const alias of aliases) {
+        map.set(alias.toLowerCase(), backendId);
+      }
+    }
+  }
+  return map;
+}
+
+function resolveAlias(
+  aliasMap: Map<string, CodingBackend>,
+  input: string,
+): CodingBackend | undefined {
+  return aliasMap.get(input.toLowerCase());
+}
+
+const mockedReadFileSync = vi.mocked(readFileSync);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// loadCodingConfig
+// ---------------------------------------------------------------------------
+describe("loadCodingConfig", () => {
+  it("loads valid coding-tools.json", () => {
+    const validConfig: CodingToolsConfig = {
+      codingTool: "gemini",
+      agentCodingTools: { kaylee: "codex" },
+      backends: {
+        gemini: { aliases: ["gem"] },
+      },
+    };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(validConfig));
+
+    const result = loadCodingConfig();
+    expect(result).toEqual(validConfig);
+  });
+
+  it("returns defaults when file not found", () => {
+    mockedReadFileSync.mockImplementation(() => {
+      throw new Error("ENOENT: no such file or directory");
+    });
+
+    const result = loadCodingConfig();
+    expect(result).toEqual({});
+  });
+
+  it("returns defaults for invalid JSON", () => {
+    mockedReadFileSync.mockReturnValue("{ not valid json !!!");
+
+    const result = loadCodingConfig();
+    expect(result).toEqual({});
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildAliasMap
+// ---------------------------------------------------------------------------
+describe("buildAliasMap", () => {
+  it("maps backend IDs as aliases", () => {
+    const map = buildAliasMap({});
+
+    expect(map.get("claude")).toBe("claude");
+    expect(map.get("codex")).toBe("codex");
+    expect(map.get("gemini")).toBe("gemini");
+  });
+
+  it("includes configured aliases from backends", () => {
+    const config: CodingToolsConfig = {
+      backends: {
+        claude: { aliases: ["CC", "anthropic"] },
+        gemini: { aliases: ["Gem", "Google"] },
+      },
+    };
+
+    const map = buildAliasMap(config);
+
+    // Aliases should be lowercased
+    expect(map.get("cc")).toBe("claude");
+    expect(map.get("anthropic")).toBe("claude");
+    expect(map.get("gem")).toBe("gemini");
+    expect(map.get("google")).toBe("gemini");
+
+    // Backend IDs still present
+    expect(map.get("claude")).toBe("claude");
+    expect(map.get("gemini")).toBe("gemini");
+    expect(map.get("codex")).toBe("codex");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveAlias
+// ---------------------------------------------------------------------------
+describe("resolveAlias", () => {
+  const config: CodingToolsConfig = {
+    backends: {
+      codex: { aliases: ["OpenAI", "ox"] },
+    },
+  };
+  const aliasMap = buildAliasMap(config);
+
+  it("finds match case-insensitively", () => {
+    expect(resolveAlias(aliasMap, "OPENAI")).toBe("codex");
+    expect(resolveAlias(aliasMap, "openai")).toBe("codex");
+    expect(resolveAlias(aliasMap, "OX")).toBe("codex");
+    expect(resolveAlias(aliasMap, "Claude")).toBe("claude");
+    expect(resolveAlias(aliasMap, "GEMINI")).toBe("gemini");
+  });
+
+  it("returns undefined for unknown alias", () => {
+    expect(resolveAlias(aliasMap, "unknown-backend")).toBeUndefined();
+    expect(resolveAlias(aliasMap, "gpt")).toBeUndefined();
+    expect(resolveAlias(aliasMap, "")).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveCodingBackend
+// ---------------------------------------------------------------------------
+describe("resolveCodingBackend", () => {
+  it("uses explicit backend parameter (per-agent override)", () => {
+    const config: CodingToolsConfig = {
+      codingTool: "gemini",
+      agentCodingTools: { kaylee: "codex" },
+    };
+
+    // Even though global says gemini, kaylee has codex
+    expect(resolveCodingBackend(config, "kaylee")).toBe("codex");
+  });
+
+  it("uses per-agent override from agentCodingTools", () => {
+    const config: CodingToolsConfig = {
+      codingTool: "claude",
+      agentCodingTools: {
+        inara: "gemini",
+        mal: "codex",
+      },
+    };
+
+    expect(resolveCodingBackend(config, "inara")).toBe("gemini");
+    expect(resolveCodingBackend(config, "mal")).toBe("codex");
+  });
+
+  it("falls back to global codingTool default", () => {
+    const config: CodingToolsConfig = {
+      codingTool: "gemini",
+      agentCodingTools: { kaylee: "codex" },
+    };
+
+    // Agent "mal" has no override, so global "gemini" is used
+    expect(resolveCodingBackend(config, "mal")).toBe("gemini");
+    // No agent ID at all
+    expect(resolveCodingBackend(config)).toBe("gemini");
+  });
+
+  it("falls back to codex when no config provided", () => {
+    expect(resolveCodingBackend({})).toBe("codex");
+    expect(resolveCodingBackend({}, "anyAgent")).toBe("codex");
+  });
+});

package/src/tools/code-tool.ts

@@ -88,7 +88,7 @@ function resolveAlias(aliasMap: Map<string, CodingBackend>, input: string): Codi
  * Priority:
  *   1. Per-agent override: config.agentCodingTools[agentId]
  *   2. Global default: config.codingTool
- *   3. Hardcoded fallback: "claude"
+ *   3. Hardcoded fallback: "codex"
  */
 export function resolveCodingBackend(
   config: CodingToolsConfig,
@@ -104,7 +104,7 @@ export function resolveCodingBackend(
   const global = config.codingTool;
   if (global && global in BACKEND_RUNNERS) return global as CodingBackend;
 
-  return "claude";
+  return "codex";
 }
 
 /**