@calltelemetry/openclaw-linear 0.9.16 → 0.9.17

package/src/infra/tmux.ts

@@ -1,11 +1,11 @@
-import { execFileSync } from "node:child_process";
+import { execSync } from "node:child_process";
 
 /**
  * Check if tmux is available on the system.
  */
 export function isTmuxAvailable(): boolean {
   try {
-    execFileSync("tmux", ["-V"], { encoding: "utf8", timeout: 5000 });
+    execSync("tmux -V", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -13,146 +13,32 @@ export function isTmuxAvailable(): boolean {
 }
 
 /**
- * Create a new tmux session with given name.
- * Uses 200x50 terminal size for consistent capture-pane output.
+ * Build a deterministic tmux session name from issue identifier, backend, and index.
  */
-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 });
+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}`;
 }
 
 /**
- * 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).
+ * Escape a string for safe shell interpolation (single-quote wrapping).
  */
-export function setupPipePane(name: string, logPath: string): void {
-  execFileSync("tmux", [
-    "pipe-pane", "-t", name, "-O",
-    `grep --line-buffered "^{" >> ${shellEscapeForTmux(logPath)}`,
-  ], { encoding: "utf8", timeout: 5000 });
+export function shellEscape(value: string): string {
+  // Wrap in single quotes, escaping any embedded single quotes
+  return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
 /**
- * Send text to the tmux session's active pane (injects into stdin).
- * Appends Enter key to execute the command.
+ * Capture the last N lines from a tmux session pane.
  */
-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[] {
+export function capturePane(sessionName: string, lines: number): 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;
+    return execSync(
+      `tmux capture-pane -t ${shellEscape(sessionName)} -p -S -${lines}`,
+      { encoding: "utf8", timeout: 5_000 },
+    ).trimEnd();
   } catch {
-    return [];  // tmux server not running
+    return "";
   }
 }
-
-/**
- * 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/tools/planner-tools.ts

@@ -408,6 +408,7 @@ export function createPlannerTools(): AnyAgentTool[] {
           priority: { type: "number", description: "New priority: 1=Urgent, 2=High, 3=Medium, 4=Low" },
           labelIds: {
             type: "array",
+            items: { type: "string" },
             description: "Label IDs to set",
           },
         },

package/src/tools/steering-tools.ts

@@ -1,176 +1,141 @@
+import { execSync } from "node:child_process";
 import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { jsonResult } from "openclaw/plugin-sdk";
-import { getActiveTmuxSession, unregisterTmuxSession } from "../infra/tmux-runner.js";
-import { sendKeys, capturePane, killSession } from "../infra/tmux.js";
+import { getActiveTmuxSession } from "../infra/tmux-runner.js";
+import { capturePane, shellEscape } from "../infra/tmux.js";
 
+/**
+ * Create steering tools for interacting with active tmux agent sessions.
+ *
+ * - steer_agent: Send input to an active agent session via tmux send-keys
+ * - capture_agent_output: Capture recent output from an agent's tmux pane
+ * - abort_agent: Kill an active agent's tmux session
+ */
 export function createSteeringTools(
   api: OpenClawPluginApi,
   _ctx: Record<string, unknown>,
 ): AnyAgentTool[] {
   return [
-    // Tool 1: steer_agent
     {
       name: "steer_agent",
       label: "Steer Agent",
       description:
-        "Send a message to the running coding agent. Only works for Claude/Gemini " +
-        "(stdin-pipe mode). Codex is one-shot and cannot be steered mid-run. " +
-        "Use this to inject precise, actionable instructions — do NOT forward raw user text.",
+        "Send a message to an active coding agent running in a tmux session. " +
+        "Use this to provide information, answer questions, or redirect the agent's approach.",
       parameters: {
         type: "object",
         properties: {
-          text: {
+          issueId: {
             type: "string",
-            description: "The text to inject into the agent's stdin. Should be a precise, actionable instruction.",
+            description: "The Linear issue ID of the active agent session.",
           },
-          issueId: {
+          message: {
             type: "string",
-            description: "Linear issue UUID of the running agent session.",
+            description: "The message to send to the agent.",
           },
         },
-        required: ["text", "issueId"],
+        required: ["issueId", "message"],
       },
-      execute: async (_toolCallId: string, params: { text: string; issueId: string }) => {
-        const { text, issueId } = params;
-        const session = getActiveTmuxSession(issueId);
+      async execute(params: { issueId: string; message: string }) {
+        const session = getActiveTmuxSession(params.issueId);
         if (!session) {
-          return jsonResult({
-            success: false,
-            error: "no_active_session",
-            message: `No active tmux session found for issue ${issueId}. The agent may have already completed.`,
-          });
+          return jsonResult({ error: `No active tmux session for issue ${params.issueId}` });
         }
+
         if (session.steeringMode === "one-shot") {
           return jsonResult({
-            success: false,
-            error: "one_shot_mode",
-            message: `Cannot steer ${session.backend} — it runs in one-shot mode (Codex exec). ` +
-              `You can abort and re-dispatch with updated instructions, or wait for it to complete.`,
-            backend: session.backend,
+            error: `Agent ${session.backend} is in one-shot mode — steering via stdin is not supported.`,
           });
         }
+
         try {
-          sendKeys(session.sessionName, text);
-          api.logger.info(`steer_agent: sent ${text.length} chars to ${session.sessionName}`);
+          execSync(
+            `tmux send-keys -t ${shellEscape(session.sessionName)} ${shellEscape(params.message)} Enter`,
+            { stdio: "ignore", timeout: 5_000 },
+          );
           return jsonResult({
             success: true,
-            message: `Sent steering input to ${session.backend} agent (${session.issueIdentifier}).`,
-            backend: session.backend,
             sessionName: session.sessionName,
+            backend: session.backend,
           });
         } catch (err) {
-          api.logger.error(`steer_agent error: ${err}`);
-          return jsonResult({
-            success: false,
-            error: "send_failed",
-            message: `Failed to send keys to tmux session: ${err}`,
-          });
+          return jsonResult({ error: `Failed to steer agent: ${err}` });
         }
       },
-    } as unknown as AnyAgentTool,
-
-    // Tool 2: capture_agent_output
+    },
     {
       name: "capture_agent_output",
       label: "Capture Agent Output",
       description:
-        "Capture the last N lines of terminal output from the running coding agent. " +
-        "Use this to check what the agent is doing before deciding whether to steer, respond, or abort.",
+        "Capture the last 50 lines of output from an active coding agent's tmux session. " +
+        "Use this to see what the agent is currently doing before deciding how to steer it.",
       parameters: {
         type: "object",
         properties: {
           issueId: {
             type: "string",
-            description: "Linear issue UUID of the running agent session.",
+            description: "The Linear issue ID of the active agent session.",
           },
           lines: {
             type: "number",
-            description: "Number of lines to capture (default: 50, max: 200).",
+            description: "Number of lines to capture (default: 50).",
           },
         },
         required: ["issueId"],
       },
-      execute: async (_toolCallId: string, params: { issueId: string; lines?: number }) => {
-        const { issueId, lines } = params;
-        const session = getActiveTmuxSession(issueId);
+      async execute(params: { issueId: string; lines?: number }) {
+        const session = getActiveTmuxSession(params.issueId);
         if (!session) {
-          return jsonResult({
-            success: false,
-            error: "no_active_session",
-            message: `No active tmux session found for issue ${issueId}.`,
-          });
+          return jsonResult({ error: `No active tmux session for issue ${params.issueId}` });
         }
+
         try {
-          const lineCount = Math.min(lines ?? 50, 200);
-          const output = capturePane(session.sessionName, lineCount);
+          const output = capturePane(session.sessionName, params.lines ?? 50);
           return jsonResult({
-            success: true,
-            backend: session.backend,
-            issueIdentifier: session.issueIdentifier,
             sessionName: session.sessionName,
-            output: output || "(no output captured)",
-            linesCaptured: lineCount,
+            backend: session.backend,
+            output: output || "(empty pane)",
           });
         } catch (err) {
-          api.logger.error(`capture_agent_output error: ${err}`);
-          return jsonResult({
-            success: false,
-            error: "capture_failed",
-            message: `Failed to capture pane output: ${err}`,
-          });
+          return jsonResult({ error: `Failed to capture output: ${err}` });
         }
       },
-    } as unknown as AnyAgentTool,
-
-    // Tool 3: abort_agent
+    },
     {
       name: "abort_agent",
       label: "Abort Agent",
       description:
-        "Kill the running coding agent session. Use when the user wants to stop, retry with different instructions, " +
-        "or when the agent is stuck. Works for all backends (Claude, Codex, Gemini).",
+        "Kill an active coding agent's tmux session. Use this when the user wants to stop a running agent.",
       parameters: {
         type: "object",
         properties: {
           issueId: {
             type: "string",
-            description: "Linear issue UUID of the running agent session.",
+            description: "The Linear issue ID of the active agent session.",
           },
         },
         required: ["issueId"],
       },
-      execute: async (_toolCallId: string, params: { issueId: string }) => {
-        const { issueId } = params;
-        const session = getActiveTmuxSession(issueId);
+      async execute(params: { issueId: string }) {
+        const session = getActiveTmuxSession(params.issueId);
         if (!session) {
-          return jsonResult({
-            success: false,
-            error: "no_active_session",
-            message: `No active tmux session found for issue ${issueId}. It may have already completed.`,
-          });
+          return jsonResult({ error: `No active tmux session for issue ${params.issueId}` });
         }
+
         try {
-          killSession(session.sessionName);
-          unregisterTmuxSession(issueId);
-          api.logger.info(`abort_agent: killed ${session.sessionName} (${session.backend})`);
+          execSync(
+            `tmux kill-session -t ${shellEscape(session.sessionName)}`,
+            { stdio: "ignore", timeout: 5_000 },
+          );
           return jsonResult({
             success: true,
-            message: `Killed ${session.backend} agent for ${session.issueIdentifier}. ` +
-              `The session has been terminated. You can re-dispatch with updated instructions.`,
+            killed: session.sessionName,
             backend: session.backend,
-            issueIdentifier: session.issueIdentifier,
           });
         } catch (err) {
-          api.logger.error(`abort_agent error: ${err}`);
-          // Still try to unregister even if kill fails
-          unregisterTmuxSession(issueId);
-          return jsonResult({
-            success: false,
-            error: "kill_failed",
-            message: `Failed to kill tmux session: ${err}. Session unregistered from registry.`,
-          });
+          return jsonResult({ error: `Failed to abort agent: ${err}` });
         }
       },
-    } as unknown as AnyAgentTool,
+    },
   ];
 }

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

@@ -1,44 +0,0 @@
-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/memory-search.ts

@@ -1,40 +0,0 @@
-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 "";
-  }
-}