@calltelemetry/openclaw-linear 0.3.1 → 0.4.1

package/src/claude-tool.ts

@@ -0,0 +1,280 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { ActivityContent } from "./linear-api.js";
+import {
+  buildLinearApi,
+  resolveSession,
+  extractPrompt,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_BASE_REPO,
+  type CliToolParams,
+  type CliResult,
+} from "./cli-shared.js";
+
+const CLAUDE_BIN = "/home/claw/.npm-global/bin/claude";
+
+/**
+ * Map a Claude Code stream-json JSONL event to a Linear activity.
+ *
+ * Claude event types:
+ *   system(init) → assistant (text|tool_use) → user (tool_result) → result
+ */
+function mapClaudeEventToActivity(event: any): ActivityContent | null {
+  const type = event?.type;
+
+  // Assistant message — text response or tool use
+  if (type === "assistant") {
+    const content = event.message?.content;
+    if (!Array.isArray(content)) return null;
+
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        return { type: "thought", body: block.text.slice(0, 1000) };
+      }
+      if (block.type === "tool_use") {
+        const toolName = block.name ?? "tool";
+        const input = block.input ?? {};
+        // Summarize the input for display
+        let paramSummary: string;
+        if (input.command) {
+          paramSummary = String(input.command).slice(0, 200);
+        } else if (input.file_path) {
+          paramSummary = String(input.file_path);
+        } else if (input.pattern) {
+          paramSummary = String(input.pattern);
+        } else if (input.query) {
+          paramSummary = String(input.query).slice(0, 200);
+        } else {
+          paramSummary = JSON.stringify(input).slice(0, 200);
+        }
+        return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
+      }
+    }
+    return null;
+  }
+
+  // Tool result
+  if (type === "user") {
+    const content = event.message?.content;
+    if (!Array.isArray(content)) return null;
+
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        const output = typeof block.content === "string" ? block.content : "";
+        const truncated = output.length > 300 ? output.slice(0, 300) + "..." : output;
+        const isError = block.is_error === true;
+        return {
+          type: "action",
+          action: isError ? "Tool error" : "Tool result",
+          parameter: truncated || "(no output)",
+        };
+      }
+    }
+    return null;
+  }
+
+  // Final result
+  if (type === "result") {
+    const cost = event.total_cost_usd;
+    const turns = event.num_turns ?? 0;
+    const usage = event.usage;
+    const parts: string[] = [`Claude completed (${turns} turns)`];
+    if (cost != null) parts.push(`$${cost.toFixed(4)}`);
+    if (usage) {
+      const input = usage.input_tokens ?? 0;
+      const output = usage.output_tokens ?? 0;
+      parts.push(`${input} in / ${output} out tokens`);
+    }
+    return { type: "thought", body: parts.join(" — ") };
+  }
+
+  return null;
+}
+
+/**
+ * Run Claude Code CLI with JSONL streaming, mapping events to Linear activities.
+ */
+export async function runClaude(
+  api: OpenClawPluginApi,
+  params: CliToolParams,
+  pluginConfig?: Record<string, unknown>,
+): Promise<CliResult> {
+  api.logger.info(`claude_run params: ${JSON.stringify(params).slice(0, 500)}`);
+
+  const prompt = extractPrompt(params);
+  if (!prompt) {
+    return {
+      success: false,
+      output: `claude_run error: no prompt provided. Received keys: ${Object.keys(params).join(", ")}`,
+      error: "missing prompt",
+    };
+  }
+
+  const { model, timeoutMs } = params;
+  const { agentSessionId, issueIdentifier } = resolveSession(params);
+
+  api.logger.info(`claude_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
+
+  const timeout = timeoutMs ?? (pluginConfig?.claudeTimeoutMs as number) ?? DEFAULT_TIMEOUT_MS;
+  const workingDir = params.workingDir ?? (pluginConfig?.claudeBaseRepo as string) ?? DEFAULT_BASE_REPO;
+
+  const linearApi = buildLinearApi(api, agentSessionId);
+
+  if (linearApi && agentSessionId) {
+    await linearApi.emitActivity(agentSessionId, {
+      type: "thought",
+      body: `Starting Claude Code: "${prompt.slice(0, 100)}${prompt.length > 100 ? "..." : ""}"`,
+    }).catch(() => {});
+  }
+
+  // Build claude command
+  const args = [
+    "--print",
+    "--output-format", "stream-json",
+    "--verbose",
+    "--dangerously-skip-permissions",
+  ];
+  if (model ?? pluginConfig?.claudeModel) {
+    args.push("--model", (model ?? pluginConfig?.claudeModel) as string);
+  }
+  args.push("-C", workingDir);
+  args.push("-p", prompt);
+
+  api.logger.info(`Claude exec: ${CLAUDE_BIN} ${args.join(" ").slice(0, 200)}...`);
+
+  return new Promise<CliResult>((resolve) => {
+    // Must unset CLAUDECODE to avoid "nested session" error
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+
+    const child = spawn(CLAUDE_BIN, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 0,
+    });
+
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+      setTimeout(() => { if (!child.killed) child.kill("SIGKILL"); }, 5_000);
+    }, timeout);
+
+    const collectedMessages: string[] = [];
+    const collectedCommands: string[] = [];
+    let stderrOutput = "";
+    let lastToolName = "";
+
+    const rl = createInterface({ input: child.stdout! });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+
+      let event: any;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        collectedMessages.push(line);
+        return;
+      }
+
+      // Collect assistant text for final output
+      if (event.type === "assistant") {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text" && block.text) {
+              collectedMessages.push(block.text);
+            }
+            if (block.type === "tool_use") {
+              lastToolName = block.name ?? "tool";
+            }
+          }
+        }
+      }
+
+      // Collect tool results for final output
+      if (event.type === "user") {
+        const content = event.message?.content;
+        const toolResult = event.tool_use_result;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              const output = toolResult?.stdout ?? (typeof block.content === "string" ? block.content : "");
+              const isError = block.is_error === true;
+              const truncOutput = output.length > 500 ? output.slice(0, 500) + "..." : output;
+              if (truncOutput) {
+                collectedCommands.push(
+                  `\`${lastToolName}\` → ${isError ? "error" : "ok"}${truncOutput ? "\n```\n" + truncOutput + "\n```" : ""}`
+                );
+              }
+            }
+          }
+        }
+      }
+
+      // Collect final result text
+      if (event.type === "result" && event.result) {
+        // result.result contains the final answer — only add if we haven't already captured it
+        // (it duplicates the last assistant text message)
+      }
+
+      // Stream activity to Linear
+      const activity = mapClaudeEventToActivity(event);
+      if (activity && linearApi && agentSessionId) {
+        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+          api.logger.warn(`Failed to emit Claude activity: ${err}`);
+        });
+      }
+    });
+
+    child.stderr?.on("data", (chunk) => {
+      stderrOutput += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      rl.close();
+
+      const parts: string[] = [];
+      if (collectedMessages.length > 0) parts.push(collectedMessages.join("\n\n"));
+      if (collectedCommands.length > 0) parts.push(collectedCommands.join("\n\n"));
+      const output = parts.join("\n\n") || stderrOutput || "(no output)";
+
+      if (killed) {
+        api.logger.warn(`Claude timed out after ${timeout}ms`);
+        resolve({
+          success: false,
+          output: `Claude timed out after ${Math.round(timeout / 1000)}s. Partial output:\n${output}`,
+          error: "timeout",
+        });
+        return;
+      }
+
+      if (code !== 0) {
+        api.logger.warn(`Claude exited with code ${code}`);
+        resolve({
+          success: false,
+          output: `Claude failed (exit ${code}):\n${output}`,
+          error: `exit ${code}`,
+        });
+        return;
+      }
+
+      api.logger.info(`Claude completed successfully`);
+      resolve({ success: true, output });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      rl.close();
+      api.logger.error(`Claude spawn error: ${err}`);
+      resolve({
+        success: false,
+        output: `Failed to start Claude: ${err.message}`,
+        error: err.message,
+      });
+    });
+  });
+}
+

package/src/cli-shared.ts

@@ -0,0 +1,75 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { LinearAgentApi } from "./linear-api.js";
+import { resolveLinearToken, LinearAgentApi as LinearAgentApiClass } from "./linear-api.js";
+import { getCurrentSession, getActiveSessionByIdentifier } from "./active-session.js";
+
+export const DEFAULT_TIMEOUT_MS = 10 * 60_000; // 10 minutes
+export const DEFAULT_BASE_REPO = "/home/claw/ai-workspace";
+
+export interface CliToolParams {
+  prompt: string;
+  workingDir?: string;
+  model?: string;
+  timeoutMs?: number;
+  issueIdentifier?: string;
+  agentSessionId?: string;
+}
+
+export interface CliResult {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+/**
+ * Build a LinearAgentApi instance for streaming activities to Linear.
+ */
+export function buildLinearApi(
+  api: OpenClawPluginApi,
+  agentSessionId?: string,
+): LinearAgentApi | null {
+  if (!agentSessionId) return null;
+
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const tokenInfo = resolveLinearToken(pluginConfig);
+  if (!tokenInfo.accessToken) return null;
+
+  const clientId = (pluginConfig?.clientId as string) ?? process.env.LINEAR_CLIENT_ID;
+  const clientSecret = (pluginConfig?.clientSecret as string) ?? process.env.LINEAR_CLIENT_SECRET;
+
+  return new LinearAgentApiClass(tokenInfo.accessToken, {
+    refreshToken: tokenInfo.refreshToken,
+    expiresAt: tokenInfo.expiresAt,
+    clientId: clientId ?? undefined,
+    clientSecret: clientSecret ?? undefined,
+  });
+}
+
+/**
+ * Resolve session info from explicit params or the active session registry.
+ */
+export function resolveSession(params: CliToolParams): {
+  agentSessionId: string | undefined;
+  issueIdentifier: string | undefined;
+} {
+  let { issueIdentifier, agentSessionId } = params;
+
+  if (!agentSessionId || !issueIdentifier) {
+    const active = issueIdentifier
+      ? getActiveSessionByIdentifier(issueIdentifier)
+      : getCurrentSession();
+    if (active) {
+      agentSessionId = agentSessionId ?? active.agentSessionId;
+      issueIdentifier = issueIdentifier ?? active.issueIdentifier;
+    }
+  }
+
+  return { agentSessionId, issueIdentifier };
+}
+
+/**
+ * Robustly extract a prompt from params, handling various key names.
+ */
+export function extractPrompt(params: CliToolParams): string | undefined {
+  return params.prompt ?? (params as any).text ?? (params as any).message ?? (params as any).task;
+}

package/src/cli.ts

@@ -8,6 +8,7 @@ import { exec } from "node:child_process";
 import { readFileSync, writeFileSync } from "node:fs";
 import { resolveLinearToken, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "./linear-api.js";
 import { LINEAR_OAUTH_AUTH_URL, LINEAR_OAUTH_TOKEN_URL, LINEAR_AGENT_SCOPES } from "./auth.js";
+import { listWorktrees } from "./codex-worktree.js";
 
 function prompt(question: string): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -200,4 +201,42 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
 
       console.log();
     });
+
+  // --- openclaw openclaw-linear worktrees ---
+  linear
+    .command("worktrees")
+    .description("List Codex worktrees (use --prune to remove specific ones)")
+    .option("--prune <path>", "Remove a specific worktree by path")
+    .action(async (opts: { prune?: string }) => {
+      if (opts.prune) {
+        try {
+          const { removeWorktree } = await import("./codex-worktree.js");
+          removeWorktree(opts.prune, { deleteBranch: true });
+          console.log(`\nRemoved: ${opts.prune}\n`);
+        } catch (err) {
+          console.error(`\nFailed to remove ${opts.prune}: ${err}\n`);
+          process.exitCode = 1;
+        }
+        return;
+      }
+
+      const worktrees = listWorktrees();
+
+      if (worktrees.length === 0) {
+        console.log("\nNo Codex worktrees found.\n");
+        return;
+      }
+
+      console.log(`\nCodex Worktrees (${worktrees.length})`);
+      console.log("─".repeat(60));
+
+      for (const wt of worktrees) {
+        const ageH = Math.round(wt.ageMs / 3_600_000 * 10) / 10;
+        const changes = wt.hasChanges ? " (uncommitted changes)" : "";
+        console.log(`  ${wt.path}`);
+        console.log(`    branch: ${wt.branch}  age: ${ageH}h${changes}`);
+      }
+
+      console.log(`\nTo remove one: openclaw openclaw-linear worktrees --prune <path>\n`);
+    });
 }

package/src/client.ts

@@ -90,4 +90,5 @@ export class LinearClient {
     `;
     return this.request(query, params);
   }
+
 }

package/src/code-tool.ts

@@ -0,0 +1,202 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { jsonResult } from "openclaw/plugin-sdk";
+import { getCurrentSession } from "./active-session.js";
+import { runCodex } from "./codex-tool.js";
+import { runClaude } from "./claude-tool.js";
+import { runGemini } from "./gemini-tool.js";
+import type { CliToolParams, CliResult } from "./cli-shared.js";
+
+export type CodingBackend = "claude" | "codex" | "gemini";
+
+const BACKEND_LABELS: Record<CodingBackend, string> = {
+  claude: "Claude Code (Anthropic)",
+  codex: "Codex (OpenAI)",
+  gemini: "Gemini CLI (Google)",
+};
+
+const BACKEND_RUNNERS: Record<
+  CodingBackend,
+  (api: OpenClawPluginApi, params: CliToolParams, pluginConfig?: Record<string, unknown>) => Promise<CliResult>
+> = {
+  claude: runClaude,
+  codex: runCodex,
+  gemini: runGemini,
+};
+
+interface BackendConfig {
+  aliases?: string[];
+}
+
+export interface CodingToolsConfig {
+  codingTool?: string;
+  agentCodingTools?: Record<string, string>;
+  backends?: Record<string, BackendConfig>;
+}
+
+/**
+ * Load coding tool config from the plugin's coding-tools.json file.
+ * Falls back to empty config if the file doesn't exist or is invalid.
+ */
+export function loadCodingConfig(): CodingToolsConfig {
+  try {
+    // Resolve relative to the plugin root (one level up from src/)
+    const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+    const raw = readFileSync(join(pluginRoot, "coding-tools.json"), "utf8");
+    return JSON.parse(raw) as CodingToolsConfig;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Build a reverse lookup map: alias (lowercase) → backend ID.
+ * Backend IDs themselves are always valid aliases.
+ */
+function buildAliasMap(config: CodingToolsConfig): Map<string, CodingBackend> {
+  const map = new Map<string, CodingBackend>();
+
+  for (const backendId of Object.keys(BACKEND_RUNNERS) as CodingBackend[]) {
+    // The backend ID itself is always an alias
+    map.set(backendId, backendId);
+
+    // Add configured aliases
+    const aliases = config.backends?.[backendId]?.aliases;
+    if (aliases) {
+      for (const alias of aliases) {
+        map.set(alias.toLowerCase(), backendId);
+      }
+    }
+  }
+
+  return map;
+}
+
+/**
+ * Resolve a user-provided alias string to a backend ID.
+ * Returns undefined if no match.
+ */
+function resolveAlias(aliasMap: Map<string, CodingBackend>, input: string): CodingBackend | undefined {
+  return aliasMap.get(input.toLowerCase());
+}
+
+/**
+ * Resolve which coding backend to use for a given agent.
+ *
+ * Priority:
+ *   1. Per-agent override: config.agentCodingTools[agentId]
+ *   2. Global default: config.codingTool
+ *   3. Hardcoded fallback: "claude"
+ */
+export function resolveCodingBackend(
+  config: CodingToolsConfig,
+  agentId?: string,
+): CodingBackend {
+  // Per-agent override
+  if (agentId) {
+    const override = config.agentCodingTools?.[agentId];
+    if (override && override in BACKEND_RUNNERS) return override as CodingBackend;
+  }
+
+  // Global default
+  const global = config.codingTool;
+  if (global && global in BACKEND_RUNNERS) return global as CodingBackend;
+
+  return "claude";
+}
+
+/**
+ * Create the unified `code_run` tool.
+ *
+ * The tool dispatches to the backend configured in coding-tools.json
+ * (codingTool / agentCodingTools). The agent always calls `code_run` —
+ * it doesn't need to know which CLI is being used.
+ */
+export function createCodeTool(
+  api: OpenClawPluginApi,
+  _ctx: Record<string, unknown>,
+): AnyAgentTool {
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const codingConfig = loadCodingConfig();
+  const aliasMap = buildAliasMap(codingConfig);
+
+  // Resolve the default backend for the tool description (may be overridden at runtime per-agent)
+  const defaultBackend = resolveCodingBackend(codingConfig);
+  const defaultLabel = BACKEND_LABELS[defaultBackend];
+
+  // Build alias description for each backend so the LLM knows what names to use
+  const aliasDescParts: string[] = [];
+  for (const backendId of Object.keys(BACKEND_RUNNERS) as CodingBackend[]) {
+    const aliases = codingConfig.backends?.[backendId]?.aliases ?? [backendId];
+    aliasDescParts.push(`${BACKEND_LABELS[backendId]}: ${aliases.map(a => `"${a}"`).join(", ")}`);
+  }
+  const aliasDesc = aliasDescParts.join("; ");
+
+  api.logger.info(`code_run: default backend=${defaultBackend}, aliases=${JSON.stringify(Object.fromEntries(aliasMap))}, per-agent overrides=${JSON.stringify(codingConfig.agentCodingTools ?? {})}`);
+
+  return {
+    name: "code_run",
+    label: "Run Coding Agent",
+    description:
+      `Run an agentic coding CLI to perform a hands-on coding task. ` +
+      `Default backend: ${defaultLabel}. You can override with the 'backend' parameter ` +
+      `if the user asks for a specific tool. ` +
+      `Known aliases — ${aliasDesc}. ` +
+      `The CLI can read/write files, run commands, search code, run tests, and more. ` +
+      `Streams progress to Linear in real-time. Use this for writing code, debugging, ` +
+      `refactoring, creating files, running tests, and other hands-on development work.`,
+    parameters: {
+      type: "object",
+      properties: {
+        prompt: {
+          type: "string",
+          description:
+            "What the coding agent should do. Be specific: include file paths, function names, " +
+            "expected behavior, and test requirements.",
+        },
+        backend: {
+          type: "string",
+          description:
+            `Which coding CLI to use. Accepts any known alias: ${aliasDesc}. ` +
+            "If omitted, uses the configured default.",
+        },
+        workingDir: {
+          type: "string",
+          description: "Override working directory (default: /home/claw/ai-workspace).",
+        },
+        model: {
+          type: "string",
+          description: "Model override for the coding backend.",
+        },
+        timeoutMs: {
+          type: "number",
+          description: "Max runtime in milliseconds (default: 600000 = 10 min).",
+        },
+      },
+      required: ["prompt"],
+    },
+    execute: async (toolCallId: string, params: CliToolParams & { backend?: string }, ...rest: unknown[]) => {
+      // Resolve backend: explicit alias → per-agent config → global default
+      const currentSession = getCurrentSession();
+      const agentId = currentSession?.agentId;
+      const explicitBackend = params.backend
+        ? resolveAlias(aliasMap, params.backend)
+        : undefined;
+      const backend = explicitBackend ?? resolveCodingBackend(codingConfig, agentId);
+      const runner = BACKEND_RUNNERS[backend];
+
+      api.logger.info(`code_run: backend=${backend} agent=${agentId ?? "unknown"}`);
+
+      const result = await runner(api, params, pluginConfig);
+
+      return jsonResult({
+        success: result.success,
+        backend,
+        output: result.output,
+        ...(result.error ? { error: result.error } : {}),
+      });
+    },
+  } as unknown as AnyAgentTool;
+}