@calltelemetry/openclaw-linear 0.9.15 → 0.9.16

package/src/tools/gemini-tool.ts

@@ -1,17 +1,22 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
+import path from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import type { ActivityContent } from "../api/linear-api.js";
 import {
   buildLinearApi,
   resolveSession,
   extractPrompt,
-  DEFAULT_TIMEOUT_MS,
   DEFAULT_BASE_REPO,
+  formatActivityLogLine,
+  createProgressEmitter,
   type CliToolParams,
   type CliResult,
+  type OnProgressUpdate,
 } from "./cli-shared.js";
 import { InactivityWatchdog, resolveWatchdogConfig } from "../agent/watchdog.js";
+import { isTmuxAvailable, buildSessionName, shellEscape } from "../infra/tmux.js";
+import { runInTmux } from "../infra/tmux-runner.js";
 
 const GEMINI_BIN = "gemini";
 
@@ -43,7 +48,7 @@ function mapGeminiEventToActivity(event: any): ActivityContent | null {
     } else if (params.description) {
       paramSummary = String(params.description).slice(0, 200);
     } else {
-      paramSummary = JSON.stringify(params).slice(0, 200);
+      paramSummary = JSON.stringify(params).slice(0, 500);
     }
     return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
   }
@@ -52,7 +57,7 @@ function mapGeminiEventToActivity(event: any): ActivityContent | null {
   if (type === "tool_result") {
     const status = event.status ?? "unknown";
     const output = event.output ?? "";
-    const truncated = output.length > 300 ? output.slice(0, 300) + "..." : output;
+    const truncated = output.length > 1000 ? output.slice(0, 1000) + "..." : output;
     return {
       type: "action",
       action: `Tool ${status}`,
@@ -82,6 +87,7 @@ export async function runGemini(
   api: OpenClawPluginApi,
   params: CliToolParams,
   pluginConfig?: Record<string, unknown>,
+  onUpdate?: OnProgressUpdate,
 ): Promise<CliResult> {
   api.logger.info(`gemini_run params: ${JSON.stringify(params).slice(0, 500)}`);
 
@@ -95,7 +101,7 @@ export async function runGemini(
   }
 
   const { model, timeoutMs } = params;
-  const { agentSessionId, issueIdentifier } = resolveSession(params);
+  const { agentSessionId, issueId, issueIdentifier } = resolveSession(params);
 
   api.logger.info(`gemini_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
 
@@ -123,8 +129,47 @@ export async function runGemini(
     args.push("-m", (model ?? pluginConfig?.geminiModel) as string);
   }
 
-  api.logger.info(`Gemini exec: ${GEMINI_BIN} ${args.join(" ").slice(0, 200)}...`);
+  const fullCommand = `${GEMINI_BIN} ${args.join(" ")}`;
+  api.logger.info(`Gemini exec: ${fullCommand.slice(0, 200)}...`);
+
+  const progressHeader = `[gemini] ${workingDir}\n$ ${fullCommand.slice(0, 500)}\n\nPrompt: ${prompt}`;
+
+  // --- tmux path: run inside a tmux session with pipe-pane streaming ---
+  const tmuxEnabled = pluginConfig?.enableTmux !== false;
+  if (tmuxEnabled && isTmuxAvailable()) {
+    const sessionName = buildSessionName(issueIdentifier ?? "unknown", "gemini", 0);
+    const tmuxIssueId = issueId ?? sessionName;
+    const modelArgs = (model ?? pluginConfig?.geminiModel)
+      ? `-m ${shellEscape((model ?? pluginConfig?.geminiModel) as string)}`
+      : "";
+    const cmdStr = [
+      GEMINI_BIN,
+      "-p", shellEscape(prompt),
+      "-o", "stream-json",
+      "--yolo",
+      modelArgs,
+    ].filter(Boolean).join(" ");
+
+    return runInTmux({
+      issueId: tmuxIssueId,
+      issueIdentifier: issueIdentifier ?? "unknown",
+      sessionName,
+      command: cmdStr,
+      cwd: workingDir,
+      timeoutMs: timeout,
+      watchdogMs: wdConfig.inactivityMs,
+      logPath: path.join(workingDir, ".claw", `tmux-${sessionName}.jsonl`),
+      mapEvent: mapGeminiEventToActivity,
+      linearApi: linearApi ?? undefined,
+      agentSessionId: agentSessionId ?? undefined,
+      steeringMode: "stdin-pipe",
+      logger: api.logger,
+      onUpdate,
+      progressHeader,
+    });
+  }
 
+  // --- fallback: direct spawn ---
   return new Promise<CliResult>((resolve) => {
     const child = spawn(GEMINI_BIN, args, {
       stdio: ["ignore", "pipe", "pipe"],
@@ -159,6 +204,9 @@ export async function runGemini(
     const collectedCommands: string[] = [];
     let stderrOutput = "";
 
+    const progress = createProgressEmitter({ header: progressHeader, onUpdate });
+    progress.emitHeader();
+
     const rl = createInterface({ input: child.stdout! });
     rl.on("line", (line) => {
       if (!line.trim()) return;
@@ -196,12 +244,15 @@ export async function runGemini(
         }
       }
 
-      // Stream activity to Linear
+      // Stream activity to Linear + session progress
       const activity = mapGeminiEventToActivity(event);
-      if (activity && linearApi && agentSessionId) {
-        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
-          api.logger.warn(`Failed to emit Gemini activity: ${err}`);
-        });
+      if (activity) {
+        if (linearApi && agentSessionId) {
+          linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+            api.logger.warn(`Failed to emit Gemini activity: ${err}`);
+          });
+        }
+        progress.push(formatActivityLogLine(activity));
       }
     });
 

package/src/tools/steering-tools.ts

@@ -0,0 +1,176 @@
+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";
+
+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.",
+      parameters: {
+        type: "object",
+        properties: {
+          text: {
+            type: "string",
+            description: "The text to inject into the agent's stdin. Should be a precise, actionable instruction.",
+          },
+          issueId: {
+            type: "string",
+            description: "Linear issue UUID of the running agent session.",
+          },
+        },
+        required: ["text", "issueId"],
+      },
+      execute: async (_toolCallId: string, params: { text: string; issueId: string }) => {
+        const { text, issueId } = params;
+        const session = getActiveTmuxSession(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.`,
+          });
+        }
+        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,
+          });
+        }
+        try {
+          sendKeys(session.sessionName, text);
+          api.logger.info(`steer_agent: sent ${text.length} chars to ${session.sessionName}`);
+          return jsonResult({
+            success: true,
+            message: `Sent steering input to ${session.backend} agent (${session.issueIdentifier}).`,
+            backend: session.backend,
+            sessionName: session.sessionName,
+          });
+        } 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}`,
+          });
+        }
+      },
+    } 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.",
+      parameters: {
+        type: "object",
+        properties: {
+          issueId: {
+            type: "string",
+            description: "Linear issue UUID of the running agent session.",
+          },
+          lines: {
+            type: "number",
+            description: "Number of lines to capture (default: 50, max: 200).",
+          },
+        },
+        required: ["issueId"],
+      },
+      execute: async (_toolCallId: string, params: { issueId: string; lines?: number }) => {
+        const { issueId, lines } = params;
+        const session = getActiveTmuxSession(issueId);
+        if (!session) {
+          return jsonResult({
+            success: false,
+            error: "no_active_session",
+            message: `No active tmux session found for issue ${issueId}.`,
+          });
+        }
+        try {
+          const lineCount = Math.min(lines ?? 50, 200);
+          const output = capturePane(session.sessionName, lineCount);
+          return jsonResult({
+            success: true,
+            backend: session.backend,
+            issueIdentifier: session.issueIdentifier,
+            sessionName: session.sessionName,
+            output: output || "(no output captured)",
+            linesCaptured: lineCount,
+          });
+        } catch (err) {
+          api.logger.error(`capture_agent_output error: ${err}`);
+          return jsonResult({
+            success: false,
+            error: "capture_failed",
+            message: `Failed to capture pane 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).",
+      parameters: {
+        type: "object",
+        properties: {
+          issueId: {
+            type: "string",
+            description: "Linear issue UUID of the running agent session.",
+          },
+        },
+        required: ["issueId"],
+      },
+      execute: async (_toolCallId: string, params: { issueId: string }) => {
+        const { issueId } = params;
+        const session = getActiveTmuxSession(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.`,
+          });
+        }
+        try {
+          killSession(session.sessionName);
+          unregisterTmuxSession(issueId);
+          api.logger.info(`abort_agent: killed ${session.sessionName} (${session.backend})`);
+          return jsonResult({
+            success: true,
+            message: `Killed ${session.backend} agent for ${session.issueIdentifier}. ` +
+              `The session has been terminated. You can re-dispatch with updated instructions.`,
+            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.`,
+          });
+        }
+      },
+    } as unknown as AnyAgentTool,
+  ];
+}

package/src/tools/tools.test.ts

@@ -7,7 +7,16 @@
 import { describe, expect, it, vi } from "vitest";
 
 vi.mock("./code-tool.js", () => ({
-  createCodeTool: vi.fn(() => ({ name: "code_run", execute: vi.fn() })),
+  createCodeTools: vi.fn(() => [
+    { name: "cli_codex", execute: vi.fn() },
+    { name: "cli_claude", execute: vi.fn() },
+    { name: "cli_gemini", execute: vi.fn() },
+  ]),
+  createCodeTool: vi.fn(() => [
+    { name: "cli_codex", execute: vi.fn() },
+    { name: "cli_claude", execute: vi.fn() },
+    { name: "cli_gemini", execute: vi.fn() },
+  ]),
 }));
 
 vi.mock("./orchestration-tools.js", () => ({
@@ -21,8 +30,16 @@ vi.mock("./linear-issues-tool.js", () => ({
   createLinearIssuesTool: vi.fn(() => ({ name: "linear_issues", execute: vi.fn() })),
 }));
 
+vi.mock("./steering-tools.js", () => ({
+  createSteeringTools: vi.fn(() => [
+    { name: "steer_agent", execute: vi.fn() },
+    { name: "capture_agent_output", execute: vi.fn() },
+    { name: "abort_agent", execute: vi.fn() },
+  ]),
+}));
+
 import { createLinearTools } from "./tools.js";
-import { createCodeTool } from "./code-tool.js";
+import { createCodeTools } from "./code-tool.js";
 import { createOrchestrationTools } from "./orchestration-tools.js";
 import { createLinearIssuesTool } from "./linear-issues-tool.js";
 
@@ -43,16 +60,21 @@ function makeApi(pluginConfig?: Record<string, unknown>) {
 // ── Tests ──────────────────────────────────────────────────────────
 
 describe("createLinearTools", () => {
-  it("returns code_run, spawn_agent, ask_agent, and linear_issues tools", () => {
+  it("returns cli_codex, cli_claude, cli_gemini, orchestration, linear_issues, and steering tools", () => {
     const api = makeApi();
     const tools = createLinearTools(api, {});
 
-    expect(tools).toHaveLength(4);
+    expect(tools).toHaveLength(9);
     const names = tools.map((t: any) => t.name);
-    expect(names).toContain("code_run");
+    expect(names).toContain("cli_codex");
+    expect(names).toContain("cli_claude");
+    expect(names).toContain("cli_gemini");
     expect(names).toContain("spawn_agent");
     expect(names).toContain("ask_agent");
     expect(names).toContain("linear_issues");
+    expect(names).toContain("steer_agent");
+    expect(names).toContain("capture_agent_output");
+    expect(names).toContain("abort_agent");
   });
 
   it("includes orchestration tools by default", () => {
@@ -67,28 +89,32 @@ describe("createLinearTools", () => {
     const api = makeApi({ enableOrchestration: false });
     const tools = createLinearTools(api, {});
 
-    expect(tools).toHaveLength(2);
+    expect(tools).toHaveLength(7);
     const names = tools.map((t: any) => t.name);
-    expect(names).toContain("code_run");
+    expect(names).toContain("cli_codex");
+    expect(names).toContain("cli_claude");
+    expect(names).toContain("cli_gemini");
     expect(names).toContain("linear_issues");
+    expect(names).toContain("steer_agent");
     expect(createOrchestrationTools).not.toHaveBeenCalled();
   });
 
-  it("handles code_run creation failure gracefully", () => {
-    vi.mocked(createCodeTool).mockImplementationOnce(() => {
+  it("handles CLI tools creation failure gracefully", () => {
+    vi.mocked(createCodeTools).mockImplementationOnce(() => {
       throw new Error("CLI not found");
     });
 
     const api = makeApi();
     const tools = createLinearTools(api, {});
 
-    expect(tools).toHaveLength(3);
+    expect(tools).toHaveLength(6);
     const names = tools.map((t: any) => t.name);
     expect(names).toContain("spawn_agent");
     expect(names).toContain("ask_agent");
     expect(names).toContain("linear_issues");
+    expect(names).toContain("steer_agent");
     expect(api.logger.warn).toHaveBeenCalledWith(
-      expect.stringContaining("code_run tool not available"),
+      expect.stringContaining("CLI coding tools not available"),
     );
   });
 
@@ -100,10 +126,13 @@ describe("createLinearTools", () => {
     const api = makeApi();
     const tools = createLinearTools(api, {});
 
-    expect(tools).toHaveLength(2);
+    expect(tools).toHaveLength(7);
     const names = tools.map((t: any) => t.name);
-    expect(names).toContain("code_run");
+    expect(names).toContain("cli_codex");
+    expect(names).toContain("cli_claude");
+    expect(names).toContain("cli_gemini");
     expect(names).toContain("linear_issues");
+    expect(names).toContain("steer_agent");
     expect(api.logger.warn).toHaveBeenCalledWith(
       expect.stringContaining("Orchestration tools not available"),
     );
@@ -117,11 +146,14 @@ describe("createLinearTools", () => {
     const api = makeApi();
     const tools = createLinearTools(api, {});
 
-    expect(tools).toHaveLength(3);
+    expect(tools).toHaveLength(8);
     const names = tools.map((t: any) => t.name);
-    expect(names).toContain("code_run");
+    expect(names).toContain("cli_codex");
+    expect(names).toContain("cli_claude");
+    expect(names).toContain("cli_gemini");
     expect(names).toContain("spawn_agent");
     expect(names).toContain("ask_agent");
+    expect(names).toContain("steer_agent");
     expect(api.logger.warn).toHaveBeenCalledWith(
       expect.stringContaining("linear_issues tool not available"),
     );

package/src/tools/tools.ts

@@ -1,17 +1,18 @@
 import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { createCodeTool } from "./code-tool.js";
+import { createCodeTools } from "./code-tool.js";
 import { createOrchestrationTools } from "./orchestration-tools.js";
 import { createLinearIssuesTool } from "./linear-issues-tool.js";
+import { createSteeringTools } from "./steering-tools.js";
 
 export function createLinearTools(api: OpenClawPluginApi, ctx: Record<string, unknown>): any[] {
   const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
 
-  // Unified code_run tool — dispatches to configured backend (claude/codex/gemini)
+  // Per-backend coding CLI tools: cli_codex, cli_claude, cli_gemini
   const codeTools: AnyAgentTool[] = [];
   try {
-    codeTools.push(createCodeTool(api, ctx));
+    codeTools.push(...createCodeTools(api, ctx));
   } catch (err) {
-    api.logger.warn(`code_run tool not available: ${err}`);
+    api.logger.warn(`CLI coding tools not available: ${err}`);
   }
 
   // Orchestration tools (conditional on config — defaults to enabled)
@@ -33,9 +34,21 @@ export function createLinearTools(api: OpenClawPluginApi, ctx: Record<string, un
     api.logger.warn(`linear_issues tool not available: ${err}`);
   }
 
+  // Steering tools (steer/capture/abort active tmux agent sessions)
+  const steeringTools: AnyAgentTool[] = [];
+  const enableTmux = pluginConfig?.enableTmux !== false;
+  if (enableTmux) {
+    try {
+      steeringTools.push(...createSteeringTools(api, ctx));
+    } catch (err) {
+      api.logger.warn(`Steering tools not available: ${err}`);
+    }
+  }
+
   return [
     ...codeTools,
     ...orchestrationTools,
     ...linearIssuesTools,
+    ...steeringTools,
   ];
 }