itermbot 1.0.2 → 1.0.4

package/src/iterm/direct-command-router.ts

@@ -0,0 +1,274 @@
+import {
+  normalizeToolList,
+} from "@easynet/agent-common/utils";
+import { AgentContextTokens } from "@easynet/agent-common/context";
+import { normalizeToolInvokeResult, stringifyToolResult } from "../chat/tool-result.js";
+
+type RuntimeLike = {
+  context: {
+    get<T>(token: unknown): T;
+  };
+};
+
+type ToolLike = {
+  name: string;
+  invoke: (args: unknown) => Promise<unknown>;
+};
+
+export interface DirectTargetCommand {
+  command: string;
+  reason: string;
+}
+
+export interface DirectTargetHint {
+  windowId?: number;
+  tabIndex?: number;
+  sessionId?: string;
+}
+
+export interface DirectCommandIntentRule {
+  pattern?: string;
+  command?: string;
+  reason?: string;
+}
+const runtimeOutputCache = new WeakMap<object, string>();
+
+function getCachedRawOutput(runtime: RuntimeLike): string {
+  return runtimeOutputCache.get(runtime as unknown as object) ?? "";
+}
+
+function setCachedRawOutput(runtime: RuntimeLike, output: string): void {
+  runtimeOutputCache.set(runtime as unknown as object, output);
+}
+
+export function setDirectCommandIntentRules(_rules: DirectCommandIntentRule[] | null | undefined): void {}
+
+function isToolLike(tool: unknown): tool is ToolLike {
+  return Boolean(
+    tool
+      && typeof tool === "object"
+      && typeof (tool as { name?: unknown }).name === "string"
+      && typeof (tool as { invoke?: unknown }).invoke === "function",
+  );
+}
+
+function findItermRunCommandTool(runtime: RuntimeLike): ToolLike | null {
+  const toolsRaw = runtime.context.get<unknown>(AgentContextTokens.Tools);
+  const tools = normalizeToolList<ToolLike>(toolsRaw, isToolLike);
+  const found = tools.find((tool) => tool.name.includes("itermRunCommandInSession"));
+  return found ?? null;
+}
+
+function isLikelyShellCommand(input: string): boolean {
+  const trimmed = input.trim();
+  if (!trimmed) return false;
+  if (trimmed.includes("\n")) return false;
+  if (trimmed.length > 220) return false;
+  if (/[?.!。，！？]$/.test(trimmed)) return false;
+  if (/[|&;<>$`]/.test(trimmed)) return true;
+  if (/^(\.\/|\/|~\/)/.test(trimmed)) return true;
+
+  const parts = trimmed.split(/\s+/);
+  if (parts.length === 1) {
+    const token = parts[0] ?? "";
+    if (!/^[A-Za-z0-9_./-]+$/.test(token)) return false;
+    return token.includes("/");
+  }
+
+  const hasFlag = parts.some((part) => part.startsWith("-"));
+  const hasPathLike = parts.some((part) => /[/.]/.test(part));
+  const hasAssign = parts.some((part) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(part));
+  const hasQuote = /['"]/.test(trimmed);
+  return hasFlag || hasPathLike || hasAssign || hasQuote;
+}
+
+function hasDefiniteShellSyntax(input: string): boolean {
+  const trimmed = input.trim();
+  if (!trimmed) return false;
+  if (/[|&;<>$`]/.test(trimmed)) return true;
+  if (/^(\.\/|\/|~\/)/.test(trimmed)) return true;
+  const parts = trimmed.split(/\s+/);
+  if (parts.length <= 1) return false;
+  const hasFlag = parts.some((part) => part.startsWith("-"));
+  const hasPathLike = parts.some((part) => /[/.]/.test(part));
+  const hasAssign = parts.some((part) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(part));
+  const hasQuote = /['"]/.test(trimmed);
+  return hasFlag || hasPathLike || hasAssign || hasQuote;
+}
+
+export function detectDirectTargetPanelCommand(input: string): DirectTargetCommand | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (isLikelyShellCommand(trimmed)) {
+    return {
+      command: trimmed,
+      reason: "raw_shell_command",
+    };
+  }
+
+  return null;
+}
+
+function extractToolOutput(output: unknown): {
+  outputText: string;
+  readError: string | null;
+} {
+  const stripMarkers = (text: string): string =>
+    text
+      .split("\n")
+      .filter((line) => !/__ITB_(BEGIN|END)_[A-Za-z0-9_]+/.test(line))
+      .join("\n")
+      .trim();
+
+  const normalized = output;
+  const result =
+    normalized && typeof normalized === "object" && "result" in normalized
+      ? (normalized as { result?: unknown }).result
+      : normalized;
+
+  if (result && typeof result === "object") {
+    const record = result as Record<string, unknown>;
+    if (typeof record.output === "string" && record.output.trim()) {
+      return { outputText: stripMarkers(record.output), readError: null };
+    }
+    if (typeof record.readError === "string" && record.readError.trim()) {
+      return { outputText: "", readError: record.readError.trim() };
+    }
+  }
+
+  try {
+    return { outputText: stringifyToolResult(result ?? normalized), readError: null };
+  } catch {
+    return { outputText: String(result ?? normalized), readError: null };
+  }
+}
+
+function buildExecutionSummary(command: string, outputText: string): string {
+  const lines = outputText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const totalLines = lines.length;
+  const preview = lines.slice(0, 3);
+  const singleLineValue = totalLines === 1 ? lines[0] ?? "" : "";
+  return [
+    "### Command Result",
+    `- Command: \`${command}\``,
+    `- Captured lines: **${totalLines}**`,
+    ...(singleLineValue ? [`- Value: \`${singleLineValue}\``] : []),
+    ...(preview.length > 0
+      ? [
+        "- Preview:",
+        ...preview.map((line) => `- \`${line}\``),
+      ]
+      : []),
+    "- Raw output: hidden by default",
+    "",
+    "_Use `show raw output` if you want the full captured output._",
+  ].join("\n");
+}
+
+function formatDirectCommandResult(args: {
+  command: string;
+  outputText: string;
+  readError: string | null;
+}): string {
+  if (args.readError) {
+    return [
+      "### Command Error",
+      `- Command: \`${args.command}\``,
+      `- Error: ${args.readError}`,
+    ].join("\n");
+  }
+  if (!args.outputText.trim()) {
+    return [
+      "### Command Result",
+      `- Command: \`${args.command}\``,
+      "- Output: _(empty)_",
+    ].join("\n");
+  }
+  return buildExecutionSummary(args.command, args.outputText);
+}
+
+async function finalizeDirectCommandResult(args: {
+  command: string;
+  outputText: string;
+  readError: string | null;
+}): Promise<string> {
+  return formatDirectCommandResult({
+    command: args.command,
+    outputText: args.outputText,
+    readError: args.readError,
+  });
+}
+
+function truncateOutputLines(text: string, maxLines = 300): { text: string; truncated: boolean } {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return { text, truncated: false };
+  return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
+}
+
+function formatRawOutputMarkdown(rawText: string): string {
+  const clipped = truncateOutputLines(rawText, 300);
+  return [
+    "### Raw Output",
+    "```text",
+    clipped.text,
+    "```",
+    ...(clipped.truncated ? ["", "_Output truncated to 300 lines._"] : []),
+  ].join("\n");
+}
+
+async function runAndFormatDirectCommand(args: {
+  tool: ToolLike;
+  command: string;
+  input: string;
+  runtime: RuntimeLike;
+  targetHint?: DirectTargetHint;
+}): Promise<string> {
+  const out = normalizeToolInvokeResult(await args.tool.invoke({
+    command: args.command,
+    maxOutputLines: 300,
+    ...(args.targetHint?.windowId != null ? { windowId: args.targetHint.windowId } : {}),
+    ...(args.targetHint?.tabIndex != null ? { tabIndex: args.targetHint.tabIndex } : {}),
+    ...(args.targetHint?.sessionId ? { sessionId: args.targetHint.sessionId } : {}),
+  }));
+  const extracted = extractToolOutput(out);
+  setCachedRawOutput(args.runtime, extracted.outputText);
+  const formatted = await finalizeDirectCommandResult({
+    command: args.command,
+    outputText: extracted.outputText,
+    readError: extracted.readError,
+  });
+  return formatted;
+}
+
+function resolveDirectCommand(directIntent: DirectTargetCommand | null): string {
+  if (directIntent?.command) return directIntent.command;
+  return "";
+}
+
+function shouldBypassWithNoCommand(command: string): boolean {
+  return !command.trim();
+}
+
+export async function tryHandleDirectTargetPanelCommand(
+  input: string,
+  runtime: RuntimeLike,
+  targetHint?: DirectTargetHint,
+): Promise<string | null> {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const directIntent = detectDirectTargetPanelCommand(trimmed);
+  if (!hasDefiniteShellSyntax(trimmed)) return null;
+  const tool = findItermRunCommandTool(runtime);
+  if (!tool) return null;
+
+  const command = resolveDirectCommand(directIntent);
+  if (shouldBypassWithNoCommand(command)) return null;
+
+  return runAndFormatDirectCommand({
+    tool,
+    command,
+    input: trimmed,
+    runtime,
+    targetHint,
+  });
+}

package/src/iterm/session-hint.ts

@@ -0,0 +1,49 @@
+import type { StartupResult } from "../startup/colors.js";
+import type { PromptTemplates } from "../config.js";
+
+function buildTargetSessionSection(startup: StartupResult): string {
+  if (!startup.targetSessionId) return "";
+  return [
+    "## Target Panel Session",
+    "Routed target panel (may change at runtime):",
+    `- sessionId: "${startup.targetSessionId}"`,
+    `- windowId: ${String(startup.windowId)}`,
+    `- tabIndex: ${String(startup.tabIndex)}`,
+    "Never use `windowId: 0` and never guess IDs.",
+  ].join("\n");
+}
+
+function buildTargetOsSection(targetOs: string): string {
+  if (!targetOs) return "";
+  return [
+    "## Target System OS",
+    `- os: ${targetOs}`,
+    "- Commands in plans must be compatible with this OS unless tool evidence suggests otherwise.",
+  ].join("\n");
+}
+
+/**
+ * Build the full system prompt by prepending iTerm policy and session info
+ * to an optional base prompt. Called before createReactAgentRuntime().
+ */
+export function buildSystemPrompt(
+  templates: PromptTemplates | undefined,
+  startup: StartupResult,
+  basePrompt = "",
+  options?: { targetOs?: string },
+): string {
+  const template = templates?.systemPrompt?.trim() ?? "";
+  const targetOs = options?.targetOs?.trim() ?? "";
+  const rendered = template
+    .replaceAll("{{targetSessionSection}}", buildTargetSessionSection(startup))
+    .replaceAll("{{targetOsSection}}", buildTargetOsSection(targetOs))
+    .trim();
+
+  const parts: string[] = [];
+  if (rendered) parts.push(rendered);
+  if (basePrompt.trim()) parts.push(basePrompt.trim());
+  return parts
+    .join("\n\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}

package/src/iterm/target-panel-policy.ts

@@ -0,0 +1,341 @@
+const BLOCKED_SHORT_NAMES = new Set([
+  "listDir",
+  "readText",
+  "writeText",
+  "runCommand",
+  "gitRead",
+  "gitAdd",
+  "gitCommit",
+  "gitDiff",
+  "gitPull",
+  "gitPush",
+  "gitSwitchBranch",
+  "gitLogHistory",
+]);
+
+type ToolLike = {
+  name: string;
+  invoke: (args: unknown) => Promise<unknown>;
+};
+
+type ToolContainer = unknown[] | { tools?: unknown[] };
+type CommandMapping = {
+  command: string;
+  maxOutputLines?: number;
+  meta?: Record<string, unknown>;
+};
+
+type RedirectedDirEntry = {
+  name: string;
+  kind: "file" | "directory" | "symlink" | "other";
+  size: number;
+  mtime: string;
+};
+
+export interface TargetPanelHint {
+  windowId?: number;
+  tabIndex?: number;
+  sessionId?: string;
+}
+
+let targetPanelHint: TargetPanelHint | null = null;
+
+export function setTargetPanelHint(hint: TargetPanelHint | null): void {
+  targetPanelHint = hint;
+}
+
+function shortName(name: string): string {
+  const parts = name.split(".");
+  return parts[parts.length - 1] ?? name;
+}
+
+function shouldBlockTool(name: string): boolean {
+  if (name.includes("itermRunCommandInSession")) return false;
+  if (name.includes("iterm")) return true;
+  return BLOCKED_SHORT_NAMES.has(shortName(name));
+}
+
+function policyError(toolName: string): Error {
+  return new Error(
+    `Tool "${toolName}" is blocked in iTermBot policy. `
+      + "Use itermRunCommandInSession on target panel, then analyze returned output.",
+  );
+}
+
+function asRecord(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+  return input as Record<string, unknown>;
+}
+
+function quoteForBash(value: string): string {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+function asBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function asBoundedInt(value: unknown, fallback: number, min: number, max: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return Math.max(min, Math.min(max, normalized));
+}
+
+function buildListDirCommand(args: Record<string, unknown>): CommandMapping {
+  const path = typeof args.path === "string" && args.path.trim() ? args.path.trim() : ".";
+  const recursive = asBoolean(args.recursive, false);
+  const includeHidden = asBoolean(args.includeHidden, false);
+  const maxDepth = asBoundedInt(args.maxDepth, 3, 1, 20);
+  const maxEntries = asBoundedInt(args.maxEntries, 200, 1, 2000);
+  const quotedPath = quoteForBash(path);
+  return {
+    command: recursive
+      ? `find ${quotedPath} -maxdepth ${maxDepth} -mindepth 1 -print`
+      : includeHidden
+        ? `ls -1A ${quotedPath}`
+        : `ls -1 ${quotedPath}`,
+    maxOutputLines: Math.min(maxEntries + 50, 3000),
+    meta: { requestedPath: path },
+  };
+}
+
+function buildReadTextCommand(args: Record<string, unknown>): { command: string; maxOutputLines: number } | null {
+  const path = typeof args.path === "string" ? args.path.trim() : "";
+  if (!path) return null;
+  const maxBytes = asBoundedInt(args.maxBytes, 24_000, 256, 200_000);
+  const maxLines = asBoundedInt(Math.floor(maxBytes / 120), 200, 20, 2000);
+  return {
+    command: `sed -n '1,${maxLines}p' ${quoteForBash(path)}`,
+    maxOutputLines: Math.min(maxLines + 40, 2500),
+  };
+}
+
+function buildRunCommandCommand(args: Record<string, unknown>): { command: string } | null {
+  if (typeof args.command === "string" && args.command.trim()) return { command: args.command.trim() };
+  if (typeof args.cmd === "string" && args.cmd.trim()) return { command: args.cmd.trim() };
+  if (Array.isArray(args.cmdArray) && args.cmdArray.length > 0) {
+    const joined = args.cmdArray.map((part) => String(part)).join(" ").trim();
+    if (joined) return { command: joined };
+  }
+  return null;
+}
+
+function toItermCommandArgs(toolName: string, args: unknown): CommandMapping | null {
+  const tool = shortName(toolName);
+  const record = asRecord(args);
+  if (tool === "listDir") return buildListDirCommand(record);
+  if (tool === "readText") return buildReadTextCommand(record);
+  if (tool === "runCommand") return buildRunCommandCommand(record);
+  if (tool === "itermListWindows") return { command: "pwd" };
+  if (tool === "itermListCurrentWindowSessions") return { command: "pwd" };
+  if (tool === "itermGetSessionInfo") return { command: "pwd" };
+  return null;
+}
+
+function isRedirectableTool(toolName: string): boolean {
+  return (
+    toolName === "listDir"
+    || toolName === "readText"
+    || toolName === "runCommand"
+    || toolName === "itermListWindows"
+    || toolName === "itermListCurrentWindowSessions"
+    || toolName === "itermGetSessionInfo"
+  );
+}
+
+function isToolLike(tool: unknown): tool is ToolLike {
+  return Boolean(
+    tool
+      && typeof tool === "object"
+      && typeof (tool as { name?: unknown }).name === "string"
+      && typeof (tool as { invoke?: unknown }).invoke === "function",
+  );
+}
+
+function findItermCommandTool(tools: unknown[]): ToolLike | null {
+  const tool = tools.find((item) => isToolLike(item) && item.name.includes("itermRunCommandInSession"));
+  return isToolLike(tool) ? tool : null;
+}
+
+function getOutputText(output: unknown): string {
+  const root = asRecord(output);
+  const result = asRecord(root?.result);
+  const text = result?.output;
+  return typeof text === "string" ? text : "";
+}
+
+function extractCommandResultMeta(output: unknown): {
+  outputText?: string;
+  commandCompleted?: boolean;
+  exitCode?: number;
+  readError?: string;
+  sessionId?: string;
+} {
+  const root = asRecord(output);
+  const result = asRecord(root?.result);
+  return {
+    ...(typeof result.output === "string" ? { outputText: result.output } : {}),
+    ...(typeof result.commandCompleted === "boolean" ? { commandCompleted: result.commandCompleted } : {}),
+    ...(typeof result.exitCode === "number" ? { exitCode: result.exitCode } : {}),
+    ...(typeof result.readError === "string" ? { readError: result.readError } : {}),
+    ...(typeof result.sessionId === "string" ? { sessionId: result.sessionId } : {}),
+  };
+}
+
+function parseListDirResolutionMeta(rawOutput: unknown, requestedPath: string): {
+  requestedPath: string;
+  resolvedPath: string;
+  pathFallbackUsed: boolean;
+} {
+  return {
+    requestedPath,
+    resolvedPath: requestedPath,
+    pathFallbackUsed: false,
+  };
+}
+
+function normalizeListEntryName(line: string, resolvedPath: string): string {
+  const trimmed = line.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("./")) return trimmed.slice(2);
+  if (resolvedPath !== "." && trimmed.startsWith(`${resolvedPath}/`)) {
+    return trimmed.slice(resolvedPath.length + 1);
+  }
+  if (trimmed.startsWith("/")) return trimmed.split("/").filter(Boolean).slice(-1)[0] ?? trimmed;
+  return trimmed;
+}
+
+function parseListDirEntries(rawOutput: unknown, resolvedPath: string): RedirectedDirEntry[] {
+  const output = getOutputText(rawOutput);
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => normalizeListEntryName(line, resolvedPath))
+    .filter(Boolean)
+    .map((name) => ({
+      name,
+      kind: "other" as const,
+      size: 0,
+      mtime: "",
+    }));
+}
+
+async function invokeRedirect(blockedName: string, blockedArgs: unknown, commandTool: ToolLike | null): Promise<unknown> {
+  const mapped = toItermCommandArgs(blockedName, blockedArgs);
+  if (!mapped || !commandTool || typeof commandTool.invoke !== "function") {
+    throw policyError(blockedName);
+  }
+  const hint = targetPanelHint;
+  const invokeArgs = {
+    command: mapped.command,
+    ...(typeof mapped.maxOutputLines === "number" ? { maxOutputLines: mapped.maxOutputLines } : {}),
+    ...(hint?.windowId != null ? { windowId: hint.windowId } : {}),
+    ...(hint?.tabIndex != null ? { tabIndex: hint.tabIndex } : {}),
+    ...(hint?.sessionId ? { sessionId: hint.sessionId } : {}),
+  };
+  const output = await commandTool.invoke(invokeArgs);
+  const blockedToolShortName = shortName(blockedName);
+  const redirectMeta =
+    blockedToolShortName === "listDir"
+      ? parseListDirResolutionMeta(
+        output,
+        typeof mapped.meta?.requestedPath === "string" ? mapped.meta.requestedPath : ".",
+      )
+      : {};
+  const commandResultMeta = extractCommandResultMeta(output);
+  const resolvedListPath =
+    blockedToolShortName === "listDir" && typeof (redirectMeta as { resolvedPath?: unknown }).resolvedPath === "string"
+      ? (redirectMeta as { resolvedPath: string }).resolvedPath
+      : ".";
+  const listDirEntries =
+    blockedToolShortName === "listDir"
+      ? parseListDirEntries(output, resolvedListPath)
+      : [];
+  return {
+    result: {
+      blockedTool: blockedName,
+      redirectedTool: commandTool.name,
+      redirected: true,
+      originalArgs: asRecord(blockedArgs),
+      mappedCommand: mapped.command,
+      ...redirectMeta,
+      ...commandResultMeta,
+      ...(blockedToolShortName === "listDir"
+        ? {
+          path: resolvedListPath,
+          entries: listDirEntries,
+          totalEntries: listDirEntries.length,
+          truncated: false,
+        }
+        : {}),
+      targetHint: hint ?? undefined,
+      output,
+    },
+    evidence: [
+      {
+        type: "policy",
+        ref: "target-panel-policy",
+        summary: `Redirected ${blockedName} to ${String(commandTool.name)} with target-panel command execution`,
+        createdAt: new Date().toISOString(),
+      },
+    ],
+  };
+}
+
+function blockedResult(toolName: string): unknown {
+  return {
+    result: {
+      blocked: true,
+      blockedTool: toolName,
+      requiredTool: "itermRunCommandInSession",
+      message:
+        `Tool "${toolName}" is blocked in iTermBot policy. `
+        + "Use itermRunCommandInSession on target panel, then analyze returned output.",
+      suggestedCommand: "pwd",
+    },
+    evidence: [
+      {
+        type: "policy",
+        ref: "target-panel-policy",
+        summary: `Blocked ${toolName}; returned policy guidance for target-panel command execution`,
+        createdAt: new Date().toISOString(),
+      },
+    ],
+  };
+}
+
+function normalizeTools(input: ToolContainer): unknown[] {
+  if (Array.isArray(input)) return input;
+  if (input && typeof input === "object" && Array.isArray((input as { tools?: unknown[] }).tools)) {
+    return (input as { tools: unknown[] }).tools;
+  }
+  return [];
+}
+
+export function enforceTargetPanelExecutionPolicy(tools: ToolContainer): () => void {
+  const unpatchFns: Array<() => void> = [];
+  const allTools = normalizeTools(tools);
+  const itermCommandTool = findItermCommandTool(allTools);
+
+  for (const tool of allTools) {
+    if (!isToolLike(tool)) continue;
+    if (!shouldBlockTool(tool.name)) continue;
+
+    const originalInvoke = tool.invoke.bind(tool);
+    tool.invoke = async (args: unknown): Promise<unknown> => {
+      const toolShortName = shortName(tool.name);
+      if (isRedirectableTool(toolShortName)) {
+        return invokeRedirect(tool.name, args, itermCommandTool);
+      }
+      return blockedResult(tool.name);
+    };
+    unpatchFns.push(() => {
+      tool.invoke = originalInvoke;
+    });
+  }
+
+  return () => {
+    for (const unpatch of unpatchFns) unpatch();
+  };
+}