@calltelemetry/openclaw-linear 0.9.15 → 0.9.17

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

@@ -0,0 +1,141 @@
+import { execSync } from "node:child_process";
+import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { jsonResult } from "openclaw/plugin-sdk";
+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 [
+    {
+      name: "steer_agent",
+      label: "Steer Agent",
+      description:
+        "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: {
+          issueId: {
+            type: "string",
+            description: "The Linear issue ID of the active agent session.",
+          },
+          message: {
+            type: "string",
+            description: "The message to send to the agent.",
+          },
+        },
+        required: ["issueId", "message"],
+      },
+      async execute(params: { issueId: string; message: string }) {
+        const session = getActiveTmuxSession(params.issueId);
+        if (!session) {
+          return jsonResult({ error: `No active tmux session for issue ${params.issueId}` });
+        }
+
+        if (session.steeringMode === "one-shot") {
+          return jsonResult({
+            error: `Agent ${session.backend} is in one-shot mode — steering via stdin is not supported.`,
+          });
+        }
+
+        try {
+          execSync(
+            `tmux send-keys -t ${shellEscape(session.sessionName)} ${shellEscape(params.message)} Enter`,
+            { stdio: "ignore", timeout: 5_000 },
+          );
+          return jsonResult({
+            success: true,
+            sessionName: session.sessionName,
+            backend: session.backend,
+          });
+        } catch (err) {
+          return jsonResult({ error: `Failed to steer agent: ${err}` });
+        }
+      },
+    },
+    {
+      name: "capture_agent_output",
+      label: "Capture Agent Output",
+      description:
+        "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: "The Linear issue ID of the active agent session.",
+          },
+          lines: {
+            type: "number",
+            description: "Number of lines to capture (default: 50).",
+          },
+        },
+        required: ["issueId"],
+      },
+      async execute(params: { issueId: string; lines?: number }) {
+        const session = getActiveTmuxSession(params.issueId);
+        if (!session) {
+          return jsonResult({ error: `No active tmux session for issue ${params.issueId}` });
+        }
+
+        try {
+          const output = capturePane(session.sessionName, params.lines ?? 50);
+          return jsonResult({
+            sessionName: session.sessionName,
+            backend: session.backend,
+            output: output || "(empty pane)",
+          });
+        } catch (err) {
+          return jsonResult({ error: `Failed to capture output: ${err}` });
+        }
+      },
+    },
+    {
+      name: "abort_agent",
+      label: "Abort Agent",
+      description:
+        "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: "The Linear issue ID of the active agent session.",
+          },
+        },
+        required: ["issueId"],
+      },
+      async execute(params: { issueId: string }) {
+        const session = getActiveTmuxSession(params.issueId);
+        if (!session) {
+          return jsonResult({ error: `No active tmux session for issue ${params.issueId}` });
+        }
+
+        try {
+          execSync(
+            `tmux kill-session -t ${shellEscape(session.sessionName)}`,
+            { stdio: "ignore", timeout: 5_000 },
+          );
+          return jsonResult({
+            success: true,
+            killed: session.sessionName,
+            backend: session.backend,
+          });
+        } catch (err) {
+          return jsonResult({ error: `Failed to abort agent: ${err}` });
+        }
+      },
+    },
+  ];
+}

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,
   ];
 }