itermbot 1.0.2 → 1.0.4

package/test/response-safety.test.mjs

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { enforceResponseSafety, enforceResponseSafetyWithMode } from "../dist/chat/response-safety.js";
+
+test("enforceResponseSafety redacts destructive commands", () => {
+  const input = [
+    "Use rm -rf ./tmp and sudo rm /var/tmp to clean.",
+    "Alternative: find /var/lib -maxdepth 5 -print | xargs rm -rf",
+  ].join("\n");
+  const out = enforceResponseSafety(input);
+  assert.equal(out.includes("rm -rf"), false);
+  assert.equal(out.includes("sudo rm"), false);
+  assert.equal(out.includes("[redacted-destructive-command]"), true);
+  assert.equal(out.includes("Safety-preserving workflow"), false);
+  assert.equal(out.includes("Safety note:"), true);
+});
+
+test("enforceResponseSafety keeps normal text unchanged", () => {
+  const input = "Use your preferred inspection command to validate environment state.";
+  const out = enforceResponseSafety(input);
+  assert.equal(out, input);
+});
+
+test("enforceResponseSafetyWithMode off keeps dangerous text unchanged", () => {
+  const input = "run rm -rf ./tmp now";
+  const out = enforceResponseSafetyWithMode(input, "off");
+  assert.equal(out, input);
+});
+
+test("enforceResponseSafetyWithMode balanced redacts but keeps structure", () => {
+  const input = "run rm -rf ./tmp now";
+  const out = enforceResponseSafetyWithMode(input, "balanced");
+  assert.equal(out.includes("rm -rf"), false);
+  assert.equal(out.includes("[redacted-destructive-command]"), true);
+  assert.equal(out.includes("Safety-preserving workflow"), false);
+});
+
+test("enforceResponseSafetyWithMode strict removes redacted lines and adds generic workflow", () => {
+  const input = "run rm -rf ./tmp now";
+  const out = enforceResponseSafetyWithMode(input, "strict");
+  assert.equal(out.includes("rm -rf"), false);
+  assert.equal(out.includes("[redacted-destructive-command]"), false);
+  assert.equal(out.includes("Safety-preserving workflow"), true);
+});

package/test/session-hint.test.mjs

@@ -0,0 +1,78 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildSystemPrompt } from "../dist/iterm/session-hint.js";
+
+test("buildSystemPrompt renders policy, target session, and base prompt", () => {
+  const startup = {
+    chatSessionId: "chat-1",
+    targetSessionId: "target-9",
+    windowId: 42,
+    tabIndex: 3,
+    colorSnapshots: [],
+  };
+  const templates = {
+    systemPrompt: [
+      "Only use target panel tools.",
+      "{{targetSessionSection}}",
+      "Response safety policy:",
+      "- Keep to evidence.",
+    ].join("\n\n"),
+  };
+
+  const out = buildSystemPrompt(templates, startup, "Base instruction");
+  assert.match(out, /Only use target panel tools\./);
+  assert.match(out, /## Target Panel Session/);
+  assert.match(out, /sessionId: "target-9"/);
+  assert.match(out, /windowId: 42/);
+  assert.match(out, /tabIndex: 3/);
+  assert.match(out, /Response safety policy:/);
+  assert.match(out, /Base instruction/);
+});
+
+test("buildSystemPrompt omits target section when targetSessionId is missing", () => {
+  const startup = {
+    chatSessionId: "chat-1",
+    targetSessionId: null,
+    windowId: null,
+    tabIndex: null,
+    colorSnapshots: [],
+  };
+  const templates = {
+    systemPrompt: [
+      "Only use target panel tools.",
+      "{{targetSessionSection}}",
+      "Response safety policy:",
+      "- Keep to evidence.",
+    ].join("\n\n"),
+  };
+
+  const out = buildSystemPrompt(templates, startup, "Base instruction");
+  assert.match(out, /Only use target panel tools\./);
+  assert.doesNotMatch(out, /## Target Panel Session/);
+  assert.match(out, /Response safety policy:/);
+  assert.match(out, /Base instruction/);
+});
+
+test("buildSystemPrompt includes target os section when provided", () => {
+  const startup = {
+    chatSessionId: "chat-1",
+    targetSessionId: "target-9",
+    windowId: 42,
+    tabIndex: 3,
+    colorSnapshots: [],
+  };
+  const templates = {
+    systemPrompt: [
+      "Only use target panel tools.",
+      "{{targetSessionSection}}",
+      "{{targetOsSection}}",
+      "Response safety policy:",
+      "- Keep to evidence.",
+    ].join("\n\n"),
+  };
+
+  const out = buildSystemPrompt(templates, startup, "Base instruction", { targetOs: "linux" });
+  assert.match(out, /## Target System OS/);
+  assert.match(out, /- os: linux/);
+  assert.match(out, /Commands in plans must be compatible with this OS/);
+});

package/test/startup-colors.test.mjs

@@ -0,0 +1,145 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  applyStartupPanelColorsWithDeps,
+  CHAT_BG,
+  CHAT_FG,
+  TARGET_BG,
+  TARGET_FG,
+} from "../dist/startup/colors.js";
+
+function makeListResult(result) {
+  return Promise.resolve({ result });
+}
+
+test("applyStartupPanelColorsWithDeps returns empty result when no sessions exist", async () => {
+  const errors = [];
+  const deps = {
+    getProcessTty: () => "/dev/ttys001",
+    listCurrentWindowSessions: () => makeListResult({ count: 0, windowId: null, sessions: [] }),
+    splitPane: async () => ({ result: {} }),
+    setSessionColors: async () => ({ result: {} }),
+    captureSessionColors: () => null,
+    onError: (message) => errors.push(String(message)),
+  };
+
+  const out = await applyStartupPanelColorsWithDeps(deps);
+  assert.equal(out.chatSessionId, null);
+  assert.equal(out.targetSessionId, null);
+  assert.deepEqual(out.colorSnapshots, []);
+  assert.equal(errors.length, 0);
+});
+
+test("applyStartupPanelColorsWithDeps auto-splits single panel and colors both sessions", async () => {
+  const splitCalls = [];
+  const colorCalls = [];
+  let listCalls = 0;
+  const deps = {
+    getProcessTty: () => "/dev/ttys001",
+    listCurrentWindowSessions: async () => {
+      listCalls += 1;
+      if (listCalls === 1) {
+        return makeListResult({
+          count: 1,
+          windowId: 12,
+          sessions: [
+            { windowId: 12, tabIndex: 0, sessionId: "chat", tty: "/dev/ttys001", isCurrentSession: true },
+          ],
+        });
+      }
+      return makeListResult({
+        count: 2,
+        windowId: 12,
+        sessions: [
+          { windowId: 12, tabIndex: 0, sessionId: "chat", tty: "/dev/ttys001", isCurrentSession: true },
+          { windowId: 12, tabIndex: 0, sessionId: "target", tty: "/dev/ttys002", isCurrentSession: false },
+        ],
+      });
+    },
+    splitPane: async (args) => {
+      splitCalls.push(args);
+      return { result: { ok: true } };
+    },
+    setSessionColors: async (args) => {
+      colorCalls.push(args);
+      return { result: { ok: true } };
+    },
+    captureSessionColors: ({ sessionId }) => ({
+      windowId: 12,
+      tabIndex: 0,
+      sessionId,
+      background: [1, 2, 3],
+      foreground: [4, 5, 6],
+    }),
+    onError: () => {},
+  };
+
+  const out = await applyStartupPanelColorsWithDeps(deps);
+
+  assert.equal(splitCalls.length, 1);
+  assert.equal(colorCalls.length, 2);
+  assert.equal(out.chatSessionId, "chat");
+  assert.equal(out.targetSessionId, "target");
+  assert.equal(out.windowId, 12);
+  assert.equal(out.tabIndex, 0);
+  assert.equal(out.colorSnapshots.length, 2);
+
+  const chatCall = colorCalls.find((c) => c.sessionId === "chat");
+  const targetCall = colorCalls.find((c) => c.sessionId === "target");
+  assert.equal(chatCall.backgroundHex, CHAT_BG);
+  assert.equal(chatCall.foregroundHex, CHAT_FG);
+  assert.equal(targetCall.backgroundHex, TARGET_BG);
+  assert.equal(targetCall.foregroundHex, TARGET_FG);
+});
+
+test("applyStartupPanelColorsWithDeps returns empty and logs when chat session cannot be identified", async () => {
+  const errors = [];
+  const deps = {
+    getProcessTty: () => "/dev/ttys999",
+    listCurrentWindowSessions: () =>
+      makeListResult({
+        count: 1,
+        windowId: 3,
+        sessions: [{ windowId: 3, tabIndex: 0, sessionId: "other", tty: "/dev/ttys001", isCurrentSession: false }],
+      }),
+    splitPane: async () => ({ result: {} }),
+    setSessionColors: async () => ({ result: {} }),
+    captureSessionColors: () => null,
+    onError: (message) => errors.push(String(message)),
+  };
+
+  const out = await applyStartupPanelColorsWithDeps(deps);
+  assert.equal(out.chatSessionId, null);
+  assert.equal(out.targetSessionId, null);
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /could not identify chat session/i);
+});
+
+test("applyStartupPanelColorsWithDeps logs color apply failure and continues", async () => {
+  const errors = [];
+  const deps = {
+    getProcessTty: () => "/dev/ttys001",
+    listCurrentWindowSessions: () =>
+      makeListResult({
+        count: 2,
+        windowId: 5,
+        sessions: [
+          { windowId: 5, tabIndex: 1, sessionId: "chat", tty: "/dev/ttys001", isCurrentSession: true },
+          { windowId: 5, tabIndex: 1, sessionId: "target", tty: "/dev/ttys002", isCurrentSession: false },
+        ],
+      }),
+    splitPane: async () => ({ result: {} }),
+    setSessionColors: async ({ sessionId }) => {
+      if (sessionId === "target") throw new Error("set failed");
+      return { result: { ok: true } };
+    },
+    captureSessionColors: () => null,
+    onError: (message, error) => errors.push(`${String(message)} ${String(error ?? "")}`.trim()),
+  };
+
+  const out = await applyStartupPanelColorsWithDeps(deps);
+  assert.equal(out.chatSessionId, "chat");
+  assert.equal(out.targetSessionId, "target");
+  assert.equal(errors.some((e) => /failed to set color/i.test(e)), true);
+});
+

package/test/target-panel-policy.test.mjs

@@ -0,0 +1,180 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { enforceTargetPanelExecutionPolicy, setTargetPanelHint } from "../dist/iterm/target-panel-policy.js";
+
+function createTool(name, invoke) {
+  return { name, invoke };
+}
+
+test("redirects listDir to itermRunCommandInSession", async () => {
+  const calls = [];
+  const itermTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+    async (args) => {
+      calls.push(args);
+      return {
+        result: {
+          ok: true,
+          args,
+          output: "./README.md\n./src",
+          commandCompleted: true,
+          exitCode: 0,
+          sessionId: "target-session",
+        },
+      };
+    },
+  );
+  const blockedTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+    async () => ({ result: { shouldNotReach: true } }),
+  );
+  const ctx = { tools: [blockedTool, itermTool] };
+
+  const unpatch = enforceTargetPanelExecutionPolicy(ctx);
+  const out = await blockedTool.invoke({
+    path: ".",
+    recursive: true,
+    includeHidden: false,
+    maxDepth: 2,
+    maxEntries: 50,
+  });
+  unpatch();
+
+  assert.equal(calls.length, 1);
+  assert.equal(typeof calls[0].command, "string");
+  assert.equal(calls[0].command.includes("find"), true);
+  assert.equal(calls[0].command.includes("-mindepth 1"), true);
+  assert.equal(calls[0].command.includes("&&"), false);
+  assert.equal(calls[0].command.includes("||"), false);
+  assert.equal(out?.result?.redirected, true);
+  assert.equal(out?.result?.requestedPath, ".");
+  assert.equal(out?.result?.resolvedPath, ".");
+  assert.equal(out?.result?.pathFallbackUsed, false);
+  assert.equal(out?.result?.outputText, "./README.md\n./src");
+  assert.equal(out?.result?.commandCompleted, true);
+  assert.equal(out?.result?.exitCode, 0);
+  assert.equal(out?.result?.sessionId, "target-session");
+  assert.deepEqual(out?.result?.entries, [
+    { name: "README.md", kind: "other", size: 0, mtime: "" },
+    { name: "src", kind: "other", size: 0, mtime: "" },
+  ]);
+  assert.equal(out?.result?.totalEntries, 2);
+  assert.equal(out?.result?.truncated, false);
+  assert.equal(
+    out?.result?.redirectedTool,
+    "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+  );
+});
+
+test("listDir redirect keeps requested path metadata when target path is missing", async () => {
+  const itermTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+    async () => ({
+      result: {
+        output: "ls: sandbox: No such file or directory",
+      },
+    }),
+  );
+  const blockedTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+    async () => ({ result: { shouldNotReach: true } }),
+  );
+  const ctx = { tools: [blockedTool, itermTool] };
+
+  const unpatch = enforceTargetPanelExecutionPolicy(ctx);
+  const out = await blockedTool.invoke({ path: "sandbox", recursive: true });
+  unpatch();
+
+  assert.equal(out?.result?.requestedPath, "sandbox");
+  assert.equal(out?.result?.resolvedPath, "sandbox");
+  assert.equal(out?.result?.pathFallbackUsed, false);
+  assert.equal(out?.result?.outputText, "ls: sandbox: No such file or directory");
+  assert.deepEqual(out?.result?.entries, [
+    { name: "ls: sandbox: No such file or directory", kind: "other", size: 0, mtime: "" },
+  ]);
+});
+
+test("keeps non-redirectable blocked tools rejected", async () => {
+  const itermTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+    async () => ({ result: { ok: true } }),
+  );
+  const gitReadTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.gitRead",
+    async () => ({ result: { shouldNotReach: true } }),
+  );
+  const ctx = { tools: [gitReadTool, itermTool] };
+
+  const unpatch = enforceTargetPanelExecutionPolicy(ctx);
+  const out = await gitReadTool.invoke({});
+  unpatch();
+  assert.equal(out?.result?.blocked, true);
+  assert.equal(out?.result?.requiredTool, "itermRunCommandInSession");
+});
+
+test("throws clear policy error when redirectable tool has no itermRunCommandInSession", async () => {
+  const blockedTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+    async () => ({ result: { shouldNotReach: true } }),
+  );
+  const ctx = { tools: [blockedTool] };
+
+  const unpatch = enforceTargetPanelExecutionPolicy(ctx);
+  await assert.rejects(
+    () =>
+      blockedTool.invoke({
+        path: ".",
+        recursive: false,
+      }),
+    /blocked in iTermBot policy/i,
+  );
+  unpatch();
+});
+
+test("unpatch restores original invoke behavior", async () => {
+  const itermTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+    async () => ({ result: { ok: true } }),
+  );
+  const blockedTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.runCommand",
+    async (args) => ({ result: { original: true, args } }),
+  );
+  const ctx = { tools: [blockedTool, itermTool] };
+
+  const unpatch = enforceTargetPanelExecutionPolicy(ctx);
+  const redirected = await blockedTool.invoke({ command: "pwd" });
+  assert.equal(redirected?.result?.redirected, true);
+
+  unpatch();
+  const restored = await blockedTool.invoke({ command: "pwd" });
+  assert.equal(restored?.result?.original, true);
+});
+
+test("redirect includes target panel hint when configured", async () => {
+  const calls = [];
+  const itermTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+    async (args) => {
+      calls.push(args);
+      return { result: { ok: true } };
+    },
+  );
+  const blockedTool = createTool(
+    "npm.easynet.agent.tool.buildin.0.0.70.runCommand",
+    async () => ({ result: { shouldNotReach: true } }),
+  );
+  const ctx = { tools: [blockedTool, itermTool] };
+
+  setTargetPanelHint({ windowId: 9, tabIndex: 2, sessionId: "target-session" });
+  const unpatch = enforceTargetPanelExecutionPolicy(ctx);
+  const out = await blockedTool.invoke({ command: "pwd" });
+  unpatch();
+  setTargetPanelHint(null);
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].windowId, 9);
+  assert.equal(calls[0].tabIndex, 2);
+  assert.equal(calls[0].sessionId, "target-session");
+  assert.equal(out?.result?.redirected, true);
+});

package/test/tool-call-recovery.test.mjs

@@ -0,0 +1,199 @@
+import test, { beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { AgentContextTokens } from "@easynet/agent-common/context";
+import { runWithTextToolCallRecovery } from "../dist/runtime/text-tool-call-recovery.js";
+
+beforeEach(() => {
+  delete process.env.ITB_BOOTSTRAP_EVIDENCE_COMMAND;
+});
+
+function makeRuntime({ tools = [], runImpl }) {
+  return {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) return tools;
+        return undefined;
+      },
+    },
+    run: runImpl,
+  };
+}
+
+test("runWithTextToolCallRecovery returns original text when no tool-call block", async () => {
+  const runtime = makeRuntime({
+    runImpl: async () => ({ text: "plain answer" }),
+  });
+  const out = await runWithTextToolCallRecovery(runtime, "hello", () => {});
+  assert.equal(out.recovered, false);
+  assert.equal(out.text, "plain answer");
+});
+
+test("runWithTextToolCallRecovery executes recovered tool call and formats deterministic recovery output", async () => {
+  const calls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+        async invoke(args) {
+          calls.push(args);
+          return { result: { output: "fileA\nfileB" } };
+        },
+      },
+    ],
+    runImpl: async (input) => {
+      if (input === "list all files and do analysis") {
+        return {
+          text: [
+            "<tool-call>",
+            "{\"name\":\"listDir\",\"arguments\":{\"path\":\".\",\"maxEntries\":10}}",
+            "</tool-call>",
+          ].join("\n"),
+        };
+      }
+      return { text: "should-not-be-used-for-finalize" };
+    },
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "list all files and do analysis", () => {});
+  assert.equal(out.recovered, true);
+  assert.equal(out.text.includes("fileA"), true);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].path, ".");
+  assert.equal(calls[0].maxEntries, 10);
+});
+
+test("runWithTextToolCallRecovery returns first-pass text when no tool-call block is present", async () => {
+  const calls = [];
+  const runtime = {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) {
+          return [
+            {
+              name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+              async invoke(args) {
+                calls.push(args);
+                return { result: { output: "/workspace\n" } };
+              },
+            },
+          ];
+        }
+        return undefined;
+      },
+    },
+    async run() {
+      return {
+        text: "need more context",
+        messages: [{ type: "ai", content: "need more context" }],
+      };
+    },
+  };
+
+  const out = await runWithTextToolCallRecovery(runtime, "list files", () => {});
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text, "need more context");
+});
+
+test("runWithTextToolCallRecovery does not execute fallback baseline commands", async () => {
+  const calls = [];
+  const runtime = {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) {
+          return [
+            {
+              name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+              async invoke(args) {
+                calls.push(args);
+                return { result: { output: "/workspace\n" } };
+              },
+            },
+          ];
+        }
+        return undefined;
+      },
+    },
+    async run() {
+      return {
+        text: "need more context",
+        messages: [{ type: "ai", content: "need more context" }],
+      };
+    },
+  };
+
+  const out = await runWithTextToolCallRecovery(runtime, "list files", () => {});
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text, "need more context");
+});
+
+test("runWithTextToolCallRecovery ignores available tools when response is plain text", async () => {
+  const calls = [];
+  const runtime = {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) {
+          return [
+            {
+              name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+              async invoke(args) {
+                calls.push(args);
+                return {
+                  result: {
+                    output: [
+                      "(py312) .../>df -h",
+                      "Filesystem        Size    Used   Avail Capacity iused ifree %iused  Mounted on",
+                      "/dev/disk3s5     460Gi   409Gi    27Gi    94%    9.7M  283M    3%   /System/Volumes/Data",
+                    ].join("\n"),
+                  },
+                };
+              },
+            },
+          ];
+        }
+        return undefined;
+      },
+    },
+    async run() {
+      return {
+        text: "need more context",
+        messages: [{ type: "ai", content: "need more context" }],
+      };
+    },
+  };
+
+  const out = await runWithTextToolCallRecovery(runtime, "investigate disk usage", () => {});
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text, "need more context");
+});
+
+test("runWithTextToolCallRecovery rethrows runtime invoke failures", async () => {
+  const runtime = {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) {
+          return [
+            {
+              name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+              async invoke(args) {
+                calls.push(args);
+                return { result: { output: "/workspace\n" } };
+              },
+            },
+          ];
+        }
+        return undefined;
+      },
+    },
+    async run() {
+      throw new Error("Agent invoke timed out after 90000ms");
+    },
+  };
+
+  await assert.rejects(
+    () => runWithTextToolCallRecovery(runtime, "investigate disk usage", () => {}),
+    /Agent invoke timed out after 90000ms/,
+  );
+});