@calltelemetry/openclaw-linear 0.3.1 → 0.4.1

package/src/dispatch-service.ts

@@ -0,0 +1,113 @@
+/**
+ * dispatch-service.ts — Background service for dispatch health monitoring.
+ *
+ * Registered via api.registerService(). Runs on a 5-minute interval.
+ * Zero LLM tokens — all logic is deterministic code.
+ *
+ * Responsibilities:
+ * - Hydrate active sessions from dispatch-state.json on startup
+ * - Detect stale dispatches (active >2h with no progress)
+ * - Verify worktree health for active dispatches
+ * - Prune completed dispatches older than 7 days
+ */
+import { existsSync } from "node:fs";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hydrateFromDispatchState } from "./active-session.js";
+import {
+  readDispatchState,
+  listStaleDispatches,
+  removeActiveDispatch,
+  pruneCompleted,
+} from "./dispatch-state.js";
+import { getWorktreeStatus } from "./codex-worktree.js";
+
+const INTERVAL_MS = 5 * 60_000; // 5 minutes
+const STALE_THRESHOLD_MS = 2 * 60 * 60_000; // 2 hours
+const COMPLETED_MAX_AGE_MS = 7 * 24 * 60 * 60_000; // 7 days
+
+type ServiceContext = {
+  logger: { info(msg: string): void; warn(msg: string): void; error(msg: string): void };
+};
+
+export function createDispatchService(api: OpenClawPluginApi) {
+  let intervalId: ReturnType<typeof setInterval> | null = null;
+
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+
+  return {
+    id: "linear-dispatch-monitor",
+
+    start: async (ctx: ServiceContext) => {
+      // Hydrate active sessions on startup
+      try {
+        const restored = await hydrateFromDispatchState(statePath);
+        if (restored > 0) {
+          ctx.logger.info(`linear-dispatch: hydrated ${restored} active session(s) from dispatch state`);
+        }
+      } catch (err) {
+        ctx.logger.warn(`linear-dispatch: hydration failed: ${err}`);
+      }
+
+      ctx.logger.info(`linear-dispatch: service started (interval: ${INTERVAL_MS / 1000}s)`);
+
+      intervalId = setInterval(() => runTick(ctx), INTERVAL_MS);
+    },
+
+    stop: async (ctx: ServiceContext) => {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+        ctx.logger.info("linear-dispatch: service stopped");
+      }
+    },
+  };
+
+  async function runTick(ctx: ServiceContext): Promise<void> {
+    try {
+      const state = await readDispatchState(statePath);
+      const activeCount = Object.keys(state.dispatches.active).length;
+
+      // Skip tick if nothing to do
+      if (activeCount === 0 && Object.keys(state.dispatches.completed).length === 0) return;
+
+      // 1. Stale dispatch detection
+      const stale = listStaleDispatches(state, STALE_THRESHOLD_MS);
+      for (const dispatch of stale) {
+        // Check if worktree still exists and has progress
+        if (existsSync(dispatch.worktreePath)) {
+          const status = getWorktreeStatus(dispatch.worktreePath);
+          if (status.hasUncommitted || status.lastCommit) {
+            // Worktree has activity — not truly stale, just slow
+            continue;
+          }
+        }
+        ctx.logger.warn(
+          `linear-dispatch: stale dispatch ${dispatch.issueIdentifier} ` +
+          `(dispatched ${dispatch.dispatchedAt}, status: ${dispatch.status})`
+        );
+      }
+
+      // 2. Worktree health — verify active dispatches have valid worktrees
+      for (const [id, dispatch] of Object.entries(state.dispatches.active)) {
+        if (!existsSync(dispatch.worktreePath)) {
+          ctx.logger.warn(
+            `linear-dispatch: worktree missing for ${id} at ${dispatch.worktreePath}`
+          );
+        }
+      }
+
+      // 3. Prune old completed entries
+      const pruned = await pruneCompleted(COMPLETED_MAX_AGE_MS, statePath);
+      if (pruned > 0) {
+        ctx.logger.info(`linear-dispatch: pruned ${pruned} old completed dispatch(es)`);
+      }
+
+      if (activeCount > 0) {
+        ctx.logger.info(`linear-dispatch: tick — ${activeCount} active, ${stale.length} stale`);
+      }
+    } catch (err) {
+      ctx.logger.error(`linear-dispatch: tick failed: ${err}`);
+    }
+  }
+}

package/src/dispatch-state.ts

@@ -0,0 +1,265 @@
+/**
+ * dispatch-state.ts — File-backed persistent dispatch state.
+ *
+ * Tracks active and completed dispatches across gateway restarts.
+ * Uses file-level locking to prevent concurrent read-modify-write races.
+ *
+ * Pattern borrowed from DevClaw's projects.ts — atomic writes with
+ * exclusive lock, stale lock detection, retry loop.
+ */
+import fs from "node:fs/promises";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type Tier = "junior" | "medior" | "senior";
+
+export interface ActiveDispatch {
+  issueId: string;
+  issueIdentifier: string;
+  worktreePath: string;
+  branch: string;
+  tier: Tier;
+  model: string;
+  status: "dispatched" | "running" | "failed";
+  dispatchedAt: string;
+  agentSessionId?: string;
+  project?: string;
+}
+
+export interface CompletedDispatch {
+  issueIdentifier: string;
+  tier: Tier;
+  status: "done" | "failed";
+  completedAt: string;
+  prUrl?: string;
+  project?: string;
+}
+
+export interface DispatchState {
+  dispatches: {
+    active: Record<string, ActiveDispatch>;
+    completed: Record<string, CompletedDispatch>;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+const DEFAULT_STATE_PATH = path.join(homedir(), ".openclaw", "linear-dispatch-state.json");
+
+function resolveStatePath(configPath?: string): string {
+  if (!configPath) return DEFAULT_STATE_PATH;
+  if (configPath.startsWith("~/")) return configPath.replace("~", homedir());
+  return configPath;
+}
+
+// ---------------------------------------------------------------------------
+// File locking
+// ---------------------------------------------------------------------------
+
+const LOCK_STALE_MS = 30_000;
+const LOCK_RETRY_MS = 50;
+const LOCK_TIMEOUT_MS = 10_000;
+
+function lockPath(statePath: string): string {
+  return statePath + ".lock";
+}
+
+async function acquireLock(statePath: string): Promise<void> {
+  const lock = lockPath(statePath);
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    try {
+      await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
+      return;
+    } catch (err: any) {
+      if (err.code !== "EEXIST") throw err;
+
+      // Check for stale lock
+      try {
+        const content = await fs.readFile(lock, "utf-8");
+        const lockTime = Number(content);
+        if (Date.now() - lockTime > LOCK_STALE_MS) {
+          try { await fs.unlink(lock); } catch { /* race */ }
+          continue;
+        }
+      } catch { /* lock disappeared — retry */ }
+
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+
+  // Last resort: force remove potentially stale lock
+  try { await fs.unlink(lockPath(statePath)); } catch { /* ignore */ }
+  await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
+}
+
+async function releaseLock(statePath: string): Promise<void> {
+  try { await fs.unlink(lockPath(statePath)); } catch { /* already removed */ }
+}
+
+// ---------------------------------------------------------------------------
+// Read / Write
+// ---------------------------------------------------------------------------
+
+function emptyState(): DispatchState {
+  return { dispatches: { active: {}, completed: {} } };
+}
+
+export async function readDispatchState(configPath?: string): Promise<DispatchState> {
+  const filePath = resolveStatePath(configPath);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw) as DispatchState;
+  } catch (err: any) {
+    if (err.code === "ENOENT") return emptyState();
+    throw err;
+  }
+}
+
+async function writeDispatchState(filePath: string, data: DispatchState): Promise<void> {
+  const dir = path.dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const tmpPath = filePath + ".tmp";
+  await fs.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await fs.rename(tmpPath, filePath);
+}
+
+// ---------------------------------------------------------------------------
+// Operations (all use file locking)
+// ---------------------------------------------------------------------------
+
+export async function registerDispatch(
+  issueIdentifier: string,
+  dispatch: ActiveDispatch,
+  configPath?: string,
+): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readDispatchState(configPath);
+    data.dispatches.active[issueIdentifier] = dispatch;
+    await writeDispatchState(filePath, data);
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+export async function completeDispatch(
+  issueIdentifier: string,
+  result: Omit<CompletedDispatch, "issueIdentifier">,
+  configPath?: string,
+): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readDispatchState(configPath);
+    const active = data.dispatches.active[issueIdentifier];
+    delete data.dispatches.active[issueIdentifier];
+    data.dispatches.completed[issueIdentifier] = {
+      issueIdentifier,
+      tier: active?.tier ?? result.tier,
+      status: result.status,
+      completedAt: result.completedAt,
+      prUrl: result.prUrl,
+      project: active?.project ?? result.project,
+    };
+    await writeDispatchState(filePath, data);
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+export async function updateDispatchStatus(
+  issueIdentifier: string,
+  status: ActiveDispatch["status"],
+  configPath?: string,
+): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readDispatchState(configPath);
+    const dispatch = data.dispatches.active[issueIdentifier];
+    if (dispatch) {
+      dispatch.status = status;
+      await writeDispatchState(filePath, data);
+    }
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+export function getActiveDispatch(
+  state: DispatchState,
+  issueIdentifier: string,
+): ActiveDispatch | null {
+  return state.dispatches.active[issueIdentifier] ?? null;
+}
+
+export function listActiveDispatches(state: DispatchState): ActiveDispatch[] {
+  return Object.values(state.dispatches.active);
+}
+
+export function listStaleDispatches(
+  state: DispatchState,
+  maxAgeMs: number,
+): ActiveDispatch[] {
+  const now = Date.now();
+  return Object.values(state.dispatches.active).filter((d) => {
+    const age = now - new Date(d.dispatchedAt).getTime();
+    return age > maxAgeMs;
+  });
+}
+
+/**
+ * Remove completed dispatches older than maxAgeMs.
+ * Returns the number of entries pruned.
+ */
+export async function pruneCompleted(
+  maxAgeMs: number,
+  configPath?: string,
+): Promise<number> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readDispatchState(configPath);
+    const now = Date.now();
+    let pruned = 0;
+    for (const [key, entry] of Object.entries(data.dispatches.completed)) {
+      const age = now - new Date(entry.completedAt).getTime();
+      if (age > maxAgeMs) {
+        delete data.dispatches.completed[key];
+        pruned++;
+      }
+    }
+    if (pruned > 0) await writeDispatchState(filePath, data);
+    return pruned;
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+/**
+ * Remove an active dispatch (e.g. when worktree is gone and branch is gone).
+ */
+export async function removeActiveDispatch(
+  issueIdentifier: string,
+  configPath?: string,
+): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readDispatchState(configPath);
+    delete data.dispatches.active[issueIdentifier];
+    await writeDispatchState(filePath, data);
+  } finally {
+    await releaseLock(filePath);
+  }
+}

package/src/gemini-tool.ts

@@ -0,0 +1,238 @@
+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 GEMINI_BIN = "/home/claw/.npm-global/bin/gemini";
+
+/**
+ * Map a Gemini CLI stream-json JSONL event to a Linear activity.
+ *
+ * Gemini event types:
+ *   init → message(user) → message(assistant) → tool_use → tool_result → result
+ */
+function mapGeminiEventToActivity(event: any): ActivityContent | null {
+  const type = event?.type;
+
+  // Assistant message (delta text)
+  if (type === "message" && event.role === "assistant") {
+    const text = event.content;
+    if (text) return { type: "thought", body: text.slice(0, 1000) };
+    return null;
+  }
+
+  // Tool use — running a command or tool
+  if (type === "tool_use") {
+    const toolName = event.tool_name ?? "tool";
+    const params = event.parameters ?? {};
+    let paramSummary: string;
+    if (params.command) {
+      paramSummary = String(params.command).slice(0, 200);
+    } else if (params.file_path) {
+      paramSummary = String(params.file_path);
+    } else if (params.description) {
+      paramSummary = String(params.description).slice(0, 200);
+    } else {
+      paramSummary = JSON.stringify(params).slice(0, 200);
+    }
+    return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
+  }
+
+  // Tool result
+  if (type === "tool_result") {
+    const status = event.status ?? "unknown";
+    const output = event.output ?? "";
+    const truncated = output.length > 300 ? output.slice(0, 300) + "..." : output;
+    return {
+      type: "action",
+      action: `Tool ${status}`,
+      parameter: truncated || "(no output)",
+    };
+  }
+
+  // Final result
+  if (type === "result") {
+    const stats = event.stats;
+    const parts: string[] = ["Gemini completed"];
+    if (stats) {
+      if (stats.duration_ms) parts.push(`${Math.round(stats.duration_ms / 1000)}s`);
+      if (stats.total_tokens) parts.push(`${stats.total_tokens} tokens`);
+      if (stats.tool_calls) parts.push(`${stats.tool_calls} tool calls`);
+    }
+    return { type: "thought", body: parts.join(" — ") };
+  }
+
+  return null;
+}
+
+/**
+ * Run Gemini CLI with JSONL streaming, mapping events to Linear activities.
+ */
+export async function runGemini(
+  api: OpenClawPluginApi,
+  params: CliToolParams,
+  pluginConfig?: Record<string, unknown>,
+): Promise<CliResult> {
+  api.logger.info(`gemini_run params: ${JSON.stringify(params).slice(0, 500)}`);
+
+  const prompt = extractPrompt(params);
+  if (!prompt) {
+    return {
+      success: false,
+      output: `gemini_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(`gemini_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
+
+  const timeout = timeoutMs ?? (pluginConfig?.geminiTimeoutMs as number) ?? DEFAULT_TIMEOUT_MS;
+  const workingDir = params.workingDir ?? (pluginConfig?.geminiBaseRepo as string) ?? DEFAULT_BASE_REPO;
+
+  const linearApi = buildLinearApi(api, agentSessionId);
+
+  if (linearApi && agentSessionId) {
+    await linearApi.emitActivity(agentSessionId, {
+      type: "thought",
+      body: `Starting Gemini: "${prompt.slice(0, 100)}${prompt.length > 100 ? "..." : ""}"`,
+    }).catch(() => {});
+  }
+
+  // Build gemini command — no -C flag, use cwd in spawn options
+  const args = [
+    "-p", prompt,
+    "-o", "stream-json",
+    "--yolo",
+  ];
+  if (model ?? pluginConfig?.geminiModel) {
+    args.push("-m", (model ?? pluginConfig?.geminiModel) as string);
+  }
+
+  api.logger.info(`Gemini exec: ${GEMINI_BIN} ${args.join(" ").slice(0, 200)}...`);
+
+  return new Promise<CliResult>((resolve) => {
+    const child = spawn(GEMINI_BIN, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: workingDir,
+      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 {
+        // Non-JSON lines (e.g. "YOLO mode" warnings) — skip
+        return;
+      }
+
+      // Collect assistant text for final output
+      if (event.type === "message" && event.role === "assistant") {
+        const text = event.content;
+        if (text) collectedMessages.push(text);
+      }
+
+      // Collect tool use/result for final output
+      if (event.type === "tool_use") {
+        const toolName = event.tool_name ?? "tool";
+        const cmd = event.parameters?.command ?? event.parameters?.description ?? "";
+        if (cmd) collectedCommands.push(`\`${toolName}\`: ${String(cmd).slice(0, 200)}`);
+      }
+
+      if (event.type === "tool_result") {
+        const output = event.output ?? "";
+        const status = event.status ?? "unknown";
+        const truncOutput = output.length > 500 ? output.slice(0, 500) + "..." : output;
+        if (truncOutput) {
+          collectedCommands.push(
+            `→ ${status}${truncOutput ? "\n```\n" + truncOutput + "\n```" : ""}`
+          );
+        }
+      }
+
+      // Stream activity to Linear
+      const activity = mapGeminiEventToActivity(event);
+      if (activity && linearApi && agentSessionId) {
+        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+          api.logger.warn(`Failed to emit Gemini 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(`Gemini timed out after ${timeout}ms`);
+        resolve({
+          success: false,
+          output: `Gemini timed out after ${Math.round(timeout / 1000)}s. Partial output:\n${output}`,
+          error: "timeout",
+        });
+        return;
+      }
+
+      if (code !== 0) {
+        api.logger.warn(`Gemini exited with code ${code}`);
+        resolve({
+          success: false,
+          output: `Gemini failed (exit ${code}):\n${output}`,
+          error: `exit ${code}`,
+        });
+        return;
+      }
+
+      api.logger.info(`Gemini completed successfully`);
+      resolve({ success: true, output });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      rl.close();
+      api.logger.error(`Gemini spawn error: ${err}`);
+      resolve({
+        success: false,
+        output: `Failed to start Gemini: ${err.message}`,
+        error: err.message,
+      });
+    });
+  });
+}
+