@calltelemetry/openclaw-linear 0.9.15 → 0.9.17

package/src/infra/multi-repo.ts

@@ -1,10 +1,11 @@
 /**
  * multi-repo.ts — Multi-repo resolution for dispatches spanning multiple git repos.
  *
- * Three-tier resolution:
+ * Four-tier resolution:
  * 1. Issue body markers: <!-- repos: api, frontend --> or [repos: api, frontend]
  * 2. Linear labels: repo:api, repo:frontend
- * 3. Config default: Falls back to single codexBaseRepo
+ * 3. Team mapping: teamMappings[teamKey].repos from plugin config
+ * 4. Config default: Falls back to single codexBaseRepo
  */
 
 import { existsSync, statSync } from "node:fs";
@@ -18,7 +19,55 @@ export interface RepoConfig {
 
 export interface RepoResolution {
   repos: RepoConfig[];
-  source: "issue_body" | "labels" | "config_default";
+  source: "issue_body" | "labels" | "team_mapping" | "config_default";
+}
+
+/**
+ * Enriched repo entry — filesystem path + optional GitHub identity.
+ * Supports both plain string paths (backward compat) and objects.
+ */
+export interface RepoEntry {
+  path: string;
+  github?: string;      // "owner/repo" format
+  hostname?: string;    // defaults to "github.com"
+}
+
+/**
+ * Parse the repos config, normalizing both string and object formats.
+ * String values become { path: value }, objects pass through.
+ */
+export function getRepoEntries(pluginConfig?: Record<string, unknown>): Record<string, RepoEntry> {
+  const repos = pluginConfig?.repos as Record<string, string | Record<string, unknown>> | undefined;
+  if (!repos) return {};
+  const result: Record<string, RepoEntry> = {};
+  for (const [name, value] of Object.entries(repos)) {
+    if (typeof value === "string") {
+      result[name] = { path: value };
+    } else if (value && typeof value === "object") {
+      result[name] = {
+        path: (value as any).path as string,
+        github: (value as any).github as string | undefined,
+        hostname: (value as any).hostname as string | undefined,
+      };
+    }
+  }
+  return result;
+}
+
+/**
+ * Build candidate repositories for Linear's issueRepositorySuggestions API.
+ * Extracts GitHub identity from enriched repo entries.
+ */
+export function buildCandidateRepositories(
+  pluginConfig?: Record<string, unknown>,
+): Array<{ hostname: string; repositoryFullName: string }> {
+  const entries = getRepoEntries(pluginConfig);
+  return Object.values(entries)
+    .filter(e => e.github)
+    .map(e => ({
+      hostname: e.hostname ?? "github.com",
+      repositoryFullName: e.github!,
+    }));
 }
 
 /**
@@ -28,6 +77,7 @@ export function resolveRepos(
   description: string | null | undefined,
   labels: string[],
   pluginConfig?: Record<string, unknown>,
+  teamKey?: string,
 ): RepoResolution {
   // 1. Check issue body for repo markers
   // Match: <!-- repos: name1, name2 --> or [repos: name1, name2]
@@ -62,7 +112,21 @@ export function resolveRepos(
     return { repos, source: "labels" };
   }
 
-  // 3. Config default: single repo
+  // 3. Team mapping: teamMappings[teamKey].repos
+  if (teamKey) {
+    const teamMappings = pluginConfig?.teamMappings as Record<string, Record<string, unknown>> | undefined;
+    const teamRepoNames = teamMappings?.[teamKey]?.repos as string[] | undefined;
+    if (teamRepoNames && teamRepoNames.length > 0) {
+      const repoMap = getRepoMap(pluginConfig);
+      const repos = teamRepoNames.map(name => ({
+        name,
+        path: repoMap[name] ?? resolveRepoPath(name, pluginConfig),
+      }));
+      return { repos, source: "team_mapping" };
+    }
+  }
+
+  // 4. Config default: single repo
   const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? path.join(homedir(), "ai-workspace");
   return {
     repos: [{ name: "default", path: baseRepo }],
@@ -71,8 +135,12 @@ export function resolveRepos(
 }
 
 function getRepoMap(pluginConfig?: Record<string, unknown>): Record<string, string> {
-  const repos = pluginConfig?.repos as Record<string, string> | undefined;
-  return repos ?? {};
+  const entries = getRepoEntries(pluginConfig);
+  const result: Record<string, string> = {};
+  for (const [name, entry] of Object.entries(entries)) {
+    result[name] = entry.path;
+  }
+  return result;
 }
 
 function resolveRepoPath(name: string, pluginConfig?: Record<string, unknown>): string {

package/src/infra/tmux-runner.ts

@@ -0,0 +1,225 @@
+import { execSync, spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { mkdirSync, createWriteStream } from "node:fs";
+import { dirname } from "node:path";
+import type { ActivityContent, LinearAgentApi } from "../api/linear-api.js";
+import type { CliResult, OnProgressUpdate } from "../tools/cli-shared.js";
+import { formatActivityLogLine, createProgressEmitter } from "../tools/cli-shared.js";
+import { InactivityWatchdog } from "../agent/watchdog.js";
+import { shellEscape } from "./tmux.js";
+
+export interface TmuxSession {
+  sessionName: string;
+  backend: string;
+  issueIdentifier: string;
+  issueId: string;
+  steeringMode: string;
+}
+
+export interface RunInTmuxOptions {
+  issueId: string;
+  issueIdentifier: string;
+  sessionName: string;
+  command: string;
+  cwd: string;
+  timeoutMs: number;
+  watchdogMs: number;
+  logPath: string;
+  mapEvent: (event: any) => ActivityContent | null;
+  linearApi?: LinearAgentApi;
+  agentSessionId?: string;
+  steeringMode: "stdin-pipe" | "one-shot";
+  logger: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void; debug?: (msg: string) => void };
+  onUpdate?: OnProgressUpdate;
+  progressHeader: string;
+}
+
+// Track active tmux sessions by issueId
+const activeSessions = new Map<string, TmuxSession>();
+
+/**
+ * Get the active tmux session for a given issueId, or null if none.
+ */
+export function getActiveTmuxSession(issueId: string): TmuxSession | null {
+  return activeSessions.get(issueId) ?? null;
+}
+
+/**
+ * Run a command inside a tmux session with pipe-pane streaming to a JSONL log.
+ * Monitors the log file for events and streams them to Linear.
+ */
+export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
+  const {
+    issueId,
+    issueIdentifier,
+    sessionName,
+    command,
+    cwd,
+    timeoutMs,
+    watchdogMs,
+    logPath,
+    mapEvent,
+    linearApi,
+    agentSessionId,
+    steeringMode,
+    logger,
+    onUpdate,
+    progressHeader,
+  } = opts;
+
+  // Ensure log directory exists
+  mkdirSync(dirname(logPath), { recursive: true });
+
+  // Register active session
+  const session: TmuxSession = {
+    sessionName,
+    backend: sessionName.split("-").slice(-2, -1)[0] ?? "unknown",
+    issueIdentifier,
+    issueId,
+    steeringMode,
+  };
+  activeSessions.set(issueId, session);
+
+  const progress = createProgressEmitter({ header: progressHeader, onUpdate });
+  progress.emitHeader();
+
+  try {
+    // Create tmux session running the command, piping output to logPath
+    const tmuxCmd = [
+      `tmux new-session -d -s ${shellEscape(sessionName)} -c ${shellEscape(cwd)}`,
+      `${shellEscape(command)} 2>&1 | tee ${shellEscape(logPath)}`,
+    ].join(" ");
+
+    execSync(tmuxCmd, { stdio: "ignore", timeout: 10_000 });
+
+    // Tail the log file and process JSONL events
+    return await new Promise<CliResult>((resolve) => {
+      const tail = spawn("tail", ["-f", "-n", "+1", logPath], {
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+
+      let killed = false;
+      let killedByWatchdog = false;
+      const collectedMessages: string[] = [];
+
+      const timer = setTimeout(() => {
+        killed = true;
+        cleanup("timeout");
+      }, timeoutMs);
+
+      const watchdog = new InactivityWatchdog({
+        inactivityMs: watchdogMs,
+        label: `tmux:${sessionName}`,
+        logger,
+        onKill: () => {
+          killedByWatchdog = true;
+          killed = true;
+          cleanup("inactivity_timeout");
+        },
+      });
+      watchdog.start();
+
+      function cleanup(reason: string) {
+        clearTimeout(timer);
+        watchdog.stop();
+        tail.kill();
+
+        // Kill the tmux session
+        try {
+          execSync(`tmux kill-session -t ${shellEscape(sessionName)}`, {
+            stdio: "ignore",
+            timeout: 5_000,
+          });
+        } catch { /* session may already be gone */ }
+
+        activeSessions.delete(issueId);
+
+        const output = collectedMessages.join("\n\n") || "(no output)";
+
+        if (reason === "inactivity_timeout") {
+          logger.warn(`tmux session ${sessionName} killed by inactivity watchdog`);
+          resolve({
+            success: false,
+            output: `Agent killed by inactivity watchdog (no I/O for ${Math.round(watchdogMs / 1000)}s). Partial output:\n${output}`,
+            error: "inactivity_timeout",
+          });
+        } else if (reason === "timeout") {
+          logger.warn(`tmux session ${sessionName} timed out after ${Math.round(timeoutMs / 1000)}s`);
+          resolve({
+            success: false,
+            output: `Agent timed out after ${Math.round(timeoutMs / 1000)}s. Partial output:\n${output}`,
+            error: "timeout",
+          });
+        } else {
+          // Normal completion
+          resolve({ success: true, output });
+        }
+      }
+
+      const rl = createInterface({ input: tail.stdout! });
+      rl.on("line", (line) => {
+        if (!line.trim()) return;
+        watchdog.tick();
+
+        let event: any;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          collectedMessages.push(line);
+          return;
+        }
+
+        // Collect text for 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);
+              }
+            }
+          }
+        }
+
+        // Stream to Linear
+        const activity = mapEvent(event);
+        if (activity) {
+          if (linearApi && agentSessionId) {
+            linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+              logger.warn(`Failed to emit tmux activity: ${err}`);
+            });
+          }
+          progress.push(formatActivityLogLine(activity));
+        }
+
+        // Detect completion
+        if (event.type === "result") {
+          cleanup("done");
+          rl.close();
+        }
+      });
+
+      // Handle tail process ending (tmux session completed)
+      tail.on("close", () => {
+        if (!killed) {
+          cleanup("done");
+        }
+        rl.close();
+      });
+
+      tail.on("error", (err) => {
+        logger.error(`tmux tail error: ${err}`);
+        cleanup("error");
+        rl.close();
+      });
+    });
+  } catch (err) {
+    activeSessions.delete(issueId);
+    logger.error(`runInTmux failed: ${err}`);
+    return {
+      success: false,
+      output: `Failed to start tmux session: ${err}`,
+      error: String(err),
+    };
+  }
+}

package/src/infra/tmux.ts

@@ -0,0 +1,44 @@
+import { execSync } from "node:child_process";
+
+/**
+ * Check if tmux is available on the system.
+ */
+export function isTmuxAvailable(): boolean {
+  try {
+    execSync("tmux -V", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build a deterministic tmux session name from issue identifier, backend, and index.
+ */
+export function buildSessionName(identifier: string, backend: string, index: number): string {
+  // tmux session names can't contain dots or colons — sanitize
+  const safe = `${identifier}-${backend}-${index}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `claw-${safe}`;
+}
+
+/**
+ * Escape a string for safe shell interpolation (single-quote wrapping).
+ */
+export function shellEscape(value: string): string {
+  // Wrap in single quotes, escaping any embedded single quotes
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Capture the last N lines from a tmux session pane.
+ */
+export function capturePane(sessionName: string, lines: number): string {
+  try {
+    return execSync(
+      `tmux capture-pane -t ${shellEscape(sessionName)} -p -S -${lines}`,
+      { encoding: "utf8", timeout: 5_000 },
+    ).trimEnd();
+  } catch {
+    return "";
+  }
+}

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
 // ---------------------------------------------------------------------------