@calltelemetry/openclaw-linear 0.3.0 → 0.4.0

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[];
+}
+
+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.
+ */
+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;
+}

package/src/codex-tool.ts

@@ -0,0 +1,240 @@
+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 CODEX_BIN = "/home/claw/.npm-global/bin/codex";
+
+/**
+ * Parse a JSONL line from `codex exec --json` and map it to a Linear activity.
+ */
+function mapCodexEventToActivity(event: any): ActivityContent | null {
+  const eventType = event?.type;
+  const item = event?.item;
+
+  if (item?.type === "reasoning") {
+    const text = item.text ?? "";
+    return { type: "thought", body: text ? text.slice(0, 500) : "Reasoning..." };
+  }
+
+  if (
+    (eventType === "item.completed" || eventType === "item.started") &&
+    (item?.type === "agent_message" || item?.type === "message")
+  ) {
+    const text = item.text ?? item.content ?? "";
+    if (text) return { type: "thought", body: text.slice(0, 1000) };
+    return null;
+  }
+
+  if (eventType === "item.started" && item?.type === "command_execution") {
+    const cmd = item.command ?? "unknown";
+    const cleaned = typeof cmd === "string"
+      ? cmd.replace(/^\/usr\/bin\/\w+ -lc ['"]?/, "").replace(/['"]?$/, "")
+      : JSON.stringify(cmd);
+    return { type: "action", action: "Running", parameter: cleaned.slice(0, 200) };
+  }
+
+  if (eventType === "item.completed" && item?.type === "command_execution") {
+    const cmd = item.command ?? "unknown";
+    const exitCode = item.exit_code ?? "?";
+    const output = item.aggregated_output ?? item.output ?? "";
+    const cleaned = typeof cmd === "string"
+      ? cmd.replace(/^\/usr\/bin\/\w+ -lc ['"]?/, "").replace(/['"]?$/, "")
+      : JSON.stringify(cmd);
+    const truncated = output.length > 500 ? output.slice(0, 500) + "..." : output;
+    return {
+      type: "action",
+      action: `${cleaned.slice(0, 150)}`,
+      parameter: `exit ${exitCode}`,
+      result: truncated || undefined,
+    };
+  }
+
+  if (eventType === "item.completed" && item?.type === "file_changes") {
+    const files = item.files ?? [];
+    const fileList = Array.isArray(files) ? files.join(", ") : String(files);
+    return { type: "action", action: "Modified files", parameter: fileList || "unknown files" };
+  }
+
+  if (eventType === "turn.completed") {
+    const usage = event.usage;
+    if (usage) {
+      const input = usage.input_tokens ?? 0;
+      const cached = usage.cached_input_tokens ?? 0;
+      const output = usage.output_tokens ?? 0;
+      return { type: "thought", body: `Codex turn complete (${input} in / ${cached} cached / ${output} out tokens)` };
+    }
+    return { type: "thought", body: "Codex turn complete" };
+  }
+
+  return null;
+}
+
+/**
+ * Run Codex CLI with JSONL streaming, mapping events to Linear activities in real-time.
+ */
+export async function runCodex(
+  api: OpenClawPluginApi,
+  params: CliToolParams,
+  pluginConfig?: Record<string, unknown>,
+): Promise<CliResult> {
+  api.logger.info(`codex_run params: ${JSON.stringify(params).slice(0, 500)}`);
+
+  const prompt = extractPrompt(params);
+  if (!prompt) {
+    return {
+      success: false,
+      output: `codex_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(`codex_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
+
+  const timeout = timeoutMs ?? (pluginConfig?.codexTimeoutMs as number) ?? DEFAULT_TIMEOUT_MS;
+  const workingDir = params.workingDir ?? (pluginConfig?.codexBaseRepo as string) ?? DEFAULT_BASE_REPO;
+
+  // Build Linear API for activity streaming
+  const linearApi = buildLinearApi(api, agentSessionId);
+
+  if (linearApi && agentSessionId) {
+    await linearApi.emitActivity(agentSessionId, {
+      type: "thought",
+      body: `Starting Codex: "${prompt.slice(0, 100)}${prompt.length > 100 ? "..." : ""}"`,
+    }).catch(() => {});
+  }
+
+  // Build codex command
+  const args = ["exec", "--full-auto", "--json", "--ephemeral"];
+  if (model ?? pluginConfig?.codexModel) {
+    args.push("--model", (model ?? pluginConfig?.codexModel) as string);
+  }
+  args.push("-C", workingDir);
+  args.push(prompt);
+
+  api.logger.info(`Codex exec: ${CODEX_BIN} ${args.join(" ").slice(0, 200)}...`);
+
+  return new Promise<CliResult>((resolve) => {
+    const child = spawn(CODEX_BIN, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.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 = "";
+
+    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;
+      }
+
+      const item = event?.item;
+
+      if (
+        event?.type === "item.completed" &&
+        (item?.type === "agent_message" || item?.type === "message")
+      ) {
+        const text = item.text ?? item.content ?? "";
+        if (text) collectedMessages.push(text);
+      }
+
+      // Skip reasoning events from final output — they're streamed to
+      // Linear as activities but don't belong in the returned result.
+
+      if (event?.type === "item.completed" && item?.type === "command_execution") {
+        const cmd = item.command ?? "unknown";
+        const exitCode = item.exit_code ?? "?";
+        const output = item.aggregated_output ?? item.output ?? "";
+        const cleanCmd = typeof cmd === "string"
+          ? cmd.replace(/^\/usr\/bin\/\w+ -lc ['"]?/, "").replace(/['"]?$/, "")
+          : String(cmd);
+        const truncOutput = output.length > 500 ? output.slice(0, 500) + "..." : output;
+        collectedCommands.push(`\`${cleanCmd}\` → exit ${exitCode}${truncOutput ? "\n```\n" + truncOutput + "\n```" : ""}`);
+      }
+
+      const activity = mapCodexEventToActivity(event);
+      if (activity && linearApi && agentSessionId) {
+        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+          api.logger.warn(`Failed to emit Codex 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(`Codex timed out after ${timeout}ms`);
+        resolve({
+          success: false,
+          output: `Codex timed out after ${Math.round(timeout / 1000)}s. Partial output:\n${output}`,
+          error: "timeout",
+        });
+        return;
+      }
+
+      if (code !== 0) {
+        api.logger.warn(`Codex exited with code ${code}`);
+        resolve({
+          success: false,
+          output: `Codex failed (exit ${code}):\n${output}`,
+          error: `exit ${code}`,
+        });
+        return;
+      }
+
+      api.logger.info(`Codex completed successfully`);
+      resolve({ success: true, output });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      rl.close();
+      api.logger.error(`Codex spawn error: ${err}`);
+      resolve({
+        success: false,
+        output: `Failed to start Codex: ${err.message}`,
+        error: err.message,
+      });
+    });
+  });
+}
+