@calltelemetry/openclaw-linear 0.9.14 → 0.9.16

package/src/infra/tmux.ts

@@ -0,0 +1,158 @@
+import { execFileSync } from "node:child_process";
+
+/**
+ * Check if tmux is available on the system.
+ */
+export function isTmuxAvailable(): boolean {
+  try {
+    execFileSync("tmux", ["-V"], { encoding: "utf8", timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a new tmux session with given name.
+ * Uses 200x50 terminal size for consistent capture-pane output.
+ */
+export function createSession(name: string, cwd: string): void {
+  execFileSync("tmux", [
+    "new-session", "-d", "-s", name, "-x", "200", "-y", "50",
+  ], { cwd, encoding: "utf8", timeout: 10_000 });
+}
+
+/**
+ * Set up pipe-pane to stream terminal output to a file.
+ * Filters for JSON lines only (lines starting with "{") to extract JSONL
+ * from raw PTY output (which includes ANSI sequences, prompts, etc).
+ */
+export function setupPipePane(name: string, logPath: string): void {
+  execFileSync("tmux", [
+    "pipe-pane", "-t", name, "-O",
+    `grep --line-buffered "^{" >> ${shellEscapeForTmux(logPath)}`,
+  ], { encoding: "utf8", timeout: 5000 });
+}
+
+/**
+ * Send text to the tmux session's active pane (injects into stdin).
+ * Appends Enter key to execute the command.
+ */
+export function sendKeys(name: string, text: string): void {
+  execFileSync("tmux", [
+    "send-keys", "-t", name, text, "Enter",
+  ], { encoding: "utf8", timeout: 5000 });
+}
+
+/**
+ * Send raw text without appending Enter (for steering prompts
+ * where the Enter should be part of the text itself).
+ */
+export function sendKeysRaw(name: string, text: string): void {
+  execFileSync("tmux", [
+    "send-keys", "-t", name, "-l", text,
+  ], { encoding: "utf8", timeout: 5000 });
+}
+
+/**
+ * Capture the visible pane content (ANSI-stripped).
+ * Returns the last `lines` lines of the terminal.
+ */
+export function capturePane(name: string, lines = 50): string {
+  return execFileSync("tmux", [
+    "capture-pane", "-t", name, "-p", "-S", `-${lines}`,
+  ], { encoding: "utf8", timeout: 5000 }).trimEnd();
+}
+
+/**
+ * Check if a tmux session exists.
+ */
+export function sessionExists(name: string): boolean {
+  try {
+    execFileSync("tmux", ["has-session", "-t", name], {
+      encoding: "utf8",
+      timeout: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Kill a tmux session.
+ */
+export function killSession(name: string): void {
+  try {
+    execFileSync("tmux", ["kill-session", "-t", name], {
+      encoding: "utf8",
+      timeout: 10_000,
+    });
+  } catch {
+    // Session may already be dead
+  }
+}
+
+/**
+ * List all tmux sessions matching a prefix.
+ * Returns session names.
+ */
+export function listSessions(prefix?: string): string[] {
+  try {
+    const output = execFileSync("tmux", [
+      "list-sessions", "-F", "#{session_name}",
+    ], { encoding: "utf8", timeout: 5000 });
+    const sessions = output.trim().split("\n").filter(Boolean);
+    if (prefix) return sessions.filter(s => s.startsWith(prefix));
+    return sessions;
+  } catch {
+    return [];  // tmux server not running
+  }
+}
+
+/**
+ * Wait for a tmux session to exit (poll-based).
+ * Resolves when the session no longer exists or timeout is reached.
+ */
+export function waitForExit(name: string, timeoutMs: number): Promise<void> {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const check = () => {
+      if (!sessionExists(name) || Date.now() - start > timeoutMs) {
+        resolve();
+        return;
+      }
+      setTimeout(check, 1000);
+    };
+    check();
+  });
+}
+
+/**
+ * Build a tmux session name from dispatch context.
+ * Format: lnr-{issueIdentifier}-{backend}-{attempt}
+ */
+export function buildSessionName(
+  issueIdentifier: string,
+  backend: string,
+  attempt: number,
+): string {
+  // Sanitize identifier for tmux (replace dots/spaces with dashes)
+  const safe = issueIdentifier.replace(/[^a-zA-Z0-9-]/g, "-");
+  return `lnr-${safe}-${backend}-${attempt}`;
+}
+
+/**
+ * Escape a string for safe use in tmux pipe-pane shell commands.
+ */
+function shellEscapeForTmux(s: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Escape a string for safe use as a shell argument in sendKeys.
+ * Wraps in single quotes and escapes internal single quotes.
+ */
+export function shellEscape(s: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}

package/src/infra/token-refresh-timer.ts

@@ -0,0 +1,44 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { refreshTokenProactively } from "../api/linear-api.js";
+
+let refreshInterval: ReturnType<typeof setInterval> | null = null;
+
+const REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+
+/**
+ * Start the proactive token refresh timer.
+ * Runs immediately on start, then every 6 hours.
+ */
+export function startTokenRefreshTimer(
+  api: OpenClawPluginApi,
+  pluginConfig?: Record<string, unknown>,
+): void {
+  if (refreshInterval) return; // Already running
+
+  const doRefresh = async () => {
+    try {
+      const result = await refreshTokenProactively(pluginConfig);
+      if (result.refreshed) {
+        api.logger.info(`Linear token refresh: ${result.reason}`);
+      } else {
+        api.logger.debug(`Linear token refresh skipped: ${result.reason}`);
+      }
+    } catch (err) {
+      api.logger.warn(`Linear token refresh failed: ${err}`);
+    }
+  };
+
+  // Run immediately
+  void doRefresh();
+
+  // Then every 6 hours
+  refreshInterval = setInterval(doRefresh, REFRESH_INTERVAL_MS);
+  api.logger.info(`Linear token refresh timer started (every ${REFRESH_INTERVAL_MS / 3600000}h)`);
+}
+
+export function stopTokenRefreshTimer(): void {
+  if (refreshInterval) {
+    clearInterval(refreshInterval);
+    refreshInterval = null;
+  }
+}

package/src/pipeline/active-session.ts

@@ -2,7 +2,7 @@
  * active-session.ts — Idempotent registry of active Linear agent sessions.
  *
  * When the pipeline starts work on an issue, it registers the session here.
- * Any tool (code_run, etc.) can look up the active session for the current
+ * Any tool (cli_codex, cli_claude, etc.) can look up the active session for the current
  * issue to stream activities without relying on the LLM agent to pass params.
  *
  * This runs in the gateway process. Tool execution also happens in the gateway,
@@ -96,6 +96,24 @@ export function getCurrentSession(): ActiveSession | null {
   return null;
 }
 
+/**
+ * Look up the most recent active session for a given agent ID.
+ * When multiple sessions exist for the same agent, returns the most
+ * recently started one. This is the primary lookup for tool execution
+ * contexts where the agent ID is known but the issue isn't.
+ */
+export function getActiveSessionByAgentId(agentId: string): ActiveSession | null {
+  let best: ActiveSession | null = null;
+  for (const session of sessions.values()) {
+    if (session.agentId === agentId) {
+      if (!best || session.startedAt > best.startedAt) {
+        best = session;
+      }
+    }
+  }
+  return best;
+}
+
 /**
  * Hydrate the in-memory session Map from dispatch-state.json.
  * Called on startup by the dispatch service to restore sessions

package/src/pipeline/artifacts.ts

@@ -307,3 +307,45 @@ export function resolveOrchestratorWorkspace(
     return join(home, ".openclaw", "workspace");
   }
 }
+
+/**
+ * Read worker output artifacts for all attempts.
+ */
+export function readWorkerOutputs(worktreePath: string, maxAttempt: number): string[] {
+  const outputs: string[] = [];
+  for (let i = 0; i <= maxAttempt; i++) {
+    try {
+      outputs.push(readFileSync(join(clawDir(worktreePath), `worker-${i}.md`), "utf-8"));
+    } catch {
+      outputs.push("(not found)");
+    }
+  }
+  return outputs;
+}
+
+/**
+ * Read audit verdict artifacts for all attempts.
+ */
+export function readAuditVerdicts(worktreePath: string, maxAttempt: number): string[] {
+  const verdicts: string[] = [];
+  for (let i = 0; i <= maxAttempt; i++) {
+    try {
+      verdicts.push(readFileSync(join(clawDir(worktreePath), `audit-${i}.json`), "utf-8"));
+    } catch {
+      verdicts.push("(not found)");
+    }
+  }
+  return verdicts;
+}
+
+/**
+ * Read the interaction log entries.
+ */
+export function readLog(worktreePath: string): string[] {
+  try {
+    const raw = readFileSync(join(clawDir(worktreePath), "log.jsonl"), "utf-8");
+    return raw.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}

package/src/pipeline/dispatch-state.ts

@@ -69,6 +69,8 @@ export interface CompletedDispatch {
   prUrl?: string;
   project?: string;
   totalAttempts?: number;
+  worktreePath?: string;
+  cleanedUp?: boolean;
 }
 
 /** Maps session keys to dispatch context for agent_end hook lookup */
@@ -370,6 +372,7 @@ export async function completeDispatch(
       prUrl: result.prUrl,
       project: active?.project ?? result.project,
       totalAttempts: active?.attempt ?? 0,
+      worktreePath: active?.worktreePath,
     };
     await writeDispatchState(filePath, data);
   } finally {

package/src/pipeline/guidance.test.ts

@@ -6,6 +6,7 @@ import {
   getCachedGuidanceForTeam,
   formatGuidanceAppendix,
   isGuidanceEnabled,
+  resolveGuidance,
   _resetGuidanceCacheForTesting,
 } from "./guidance.js";
 
@@ -220,3 +221,55 @@ describe("isGuidanceEnabled", () => {
     expect(isGuidanceEnabled({ enableGuidance: true }, undefined)).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// resolveGuidance
+// ---------------------------------------------------------------------------
+
+describe("resolveGuidance", () => {
+  it("extracts guidance from webhook payload and caches it", () => {
+    const result = resolveGuidance("team-1", { guidance: "Use TypeScript." });
+    expect(result).toBe("Use TypeScript.");
+    // Should also be cached now
+    expect(getCachedGuidanceForTeam("team-1")).toBe("Use TypeScript.");
+  });
+
+  it("falls back to cache when payload has no guidance", () => {
+    cacheGuidanceForTeam("team-1", "Cached guidance");
+    const result = resolveGuidance("team-1", {});
+    expect(result).toBe("Cached guidance");
+  });
+
+  it("returns null when no guidance anywhere", () => {
+    const result = resolveGuidance("team-1", {});
+    expect(result).toBeNull();
+  });
+
+  it("returns null when guidance is disabled for team", () => {
+    cacheGuidanceForTeam("team-1", "Should be ignored");
+    const config = { teamGuidanceOverrides: { "team-1": false } };
+    const result = resolveGuidance("team-1", { guidance: "Direct guidance" }, config);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when teamId is undefined and no payload guidance", () => {
+    const result = resolveGuidance(undefined, {});
+    expect(result).toBeNull();
+  });
+
+  it("extracts from payload even with undefined teamId", () => {
+    const result = resolveGuidance(undefined, { guidance: "Global guidance" });
+    expect(result).toBe("Global guidance");
+  });
+
+  it("returns null when payload is null and cache is empty", () => {
+    const result = resolveGuidance("team-1", null);
+    expect(result).toBeNull();
+  });
+
+  it("uses cached guidance when payload is null", () => {
+    cacheGuidanceForTeam("team-1", "Cached");
+    const result = resolveGuidance("team-1", null);
+    expect(result).toBe("Cached");
+  });
+});

package/src/pipeline/guidance.ts

@@ -127,6 +127,44 @@ export function formatGuidanceAppendix(guidance: string | null): string {
   ].join("\n");
 }
 
+// ---------------------------------------------------------------------------
+// Proactive resolution (webhook → cache → null)
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve guidance for a team through all available sources.
+ * Chain: webhook payload → cache → null
+ *
+ * This replaces ad-hoc cache lookups with a single resolution function.
+ * When the cache expires and no webhook guidance is available, returns null.
+ */
+export function resolveGuidance(
+  teamId: string | undefined,
+  payload: Record<string, unknown> | null,
+  pluginConfig?: Record<string, unknown>,
+): string | null {
+  // Check if guidance is enabled for this team
+  if (!isGuidanceEnabled(pluginConfig, teamId)) return null;
+
+  // 1. Try extracting from webhook payload (freshest source)
+  if (payload) {
+    const extracted = extractGuidance(payload);
+    if (extracted.guidance) {
+      // Cache for future Comment webhook paths
+      if (teamId) cacheGuidanceForTeam(teamId, extracted.guidance);
+      return extracted.guidance;
+    }
+  }
+
+  // 2. Try cache
+  if (teamId) {
+    const cached = getCachedGuidanceForTeam(teamId);
+    if (cached) return cached;
+  }
+
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Config toggle
 // ---------------------------------------------------------------------------

package/src/pipeline/memory-search.ts

@@ -0,0 +1,40 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { runAgent } from "../agent/agent.js";
+
+/**
+ * Search agent memory by running a short read-only agent session.
+ *
+ * The agent has access to memory_search, read, glob, grep tools
+ * (readOnly mode allows these). It returns search results as text.
+ *
+ * @param api - OpenClaw plugin API
+ * @param agentId - Agent ID to use for the session
+ * @param query - Search query string
+ * @param timeoutMs - Max time for the search session (default 15s)
+ * @returns Text output from the memory search, or empty string on failure
+ */
+export async function searchMemoryViaAgent(
+  api: OpenClawPluginApi,
+  agentId: string,
+  query: string,
+  timeoutMs = 15_000,
+): Promise<string> {
+  try {
+    const result = await runAgent({
+      api,
+      agentId,
+      sessionId: `memory-search-${Date.now()}`,
+      message: [
+        `Search your memory for information relevant to: "${query}"`,
+        `Return ONLY the search results as a bulleted list, one result per line.`,
+        `Include the most relevant content snippets. No commentary or explanation.`,
+        `If no results found, return exactly: "No relevant memories found."`,
+      ].join("\n"),
+      timeoutMs,
+      readOnly: true,
+    });
+    return result.success ? result.output : "";
+  } catch {
+    return "";
+  }
+}