octoflow-core 1.0.0

package/dist/subpath-ssh.cjs

@@ -0,0 +1,1203 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/subpath-ssh.ts
+var subpath_ssh_exports = {};
+__export(subpath_ssh_exports, {
+  SshProcessRunner: () => SshProcessRunner
+});
+module.exports = __toCommonJS(subpath_ssh_exports);
+
+// src/domain/errors/base.ts
+var ERROR_CLASS_BY_CODE = /* @__PURE__ */ new Map();
+function registerErrorClass(code, factory) {
+  ERROR_CLASS_BY_CODE.set(code, factory);
+}
+var exposeStackConfig = false;
+function shouldExposeStack() {
+  return exposeStackConfig;
+}
+function ctxString(ctx, key, fallback = "") {
+  const value = ctx?.[key];
+  return typeof value === "string" ? value : fallback;
+}
+function ctxNumber(ctx, key, fallback = 0) {
+  const value = ctx?.[key];
+  return typeof value === "number" ? value : fallback;
+}
+function serializeCause(cause) {
+  if (!cause) return void 0;
+  if (cause instanceof OctoFlowError) {
+    return { name: cause.name, message: cause.message, code: cause.code };
+  }
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message };
+  }
+  if (typeof cause === "string") {
+    return { message: cause };
+  }
+  try {
+    return { message: JSON.stringify(cause) };
+  } catch {
+    return { message: Object.prototype.toString.call(cause) };
+  }
+}
+var OctoFlowError = class extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}) {
+    super(message);
+    this.name = "OctoFlowError";
+    this.code = code;
+    this.context = Object.freeze({ ...context });
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    const payload = {
+      name: this.name,
+      code: this.code,
+      message: this.message
+    };
+    if (Object.keys(this.context).length > 0) payload.context = this.context;
+    const cause = serializeCause(this.cause);
+    if (cause) payload.cause = cause;
+    if (shouldExposeStack() && this.stack) payload.stack = this.stack;
+    return payload;
+  }
+};
+
+// src/domain/errors/agent.ts
+var AgentRunError = class extends OctoFlowError {
+  text;
+  exitCode;
+  backendName;
+  constructor(text, exitCode, backendName) {
+    super(
+      "AGENT_RUN_ERROR",
+      `[${backendName}] run failed (exit ${exitCode}): ${text.slice(0, 200)}`,
+      { text, exitCode, backendName }
+    );
+    this.name = "AgentRunError";
+    this.text = text;
+    this.exitCode = exitCode;
+    this.backendName = backendName;
+  }
+};
+registerErrorClass(
+  "AGENT_RUN_ERROR",
+  (p) => new AgentRunError(
+    ctxString(p.context, "text"),
+    ctxNumber(p.context, "exitCode"),
+    ctxString(p.context, "backendName")
+  )
+);
+var AgentTimeoutError = class extends OctoFlowError {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super("AGENT_TIMEOUT", `CLI process timed out after ${timeoutMs}ms`, {
+      timeoutMs
+    });
+    this.name = "AgentTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+registerErrorClass(
+  "AGENT_TIMEOUT",
+  (p) => new AgentTimeoutError(ctxNumber(p.context, "timeoutMs"))
+);
+var UnsafeCommandError = class extends OctoFlowError {
+  command;
+  reason;
+  constructor(command, reason) {
+    super("UNSAFE_COMMAND", `Blocked unsafe command "${command}": ${reason}`, {
+      command,
+      reason
+    });
+    this.name = "UnsafeCommandError";
+    this.command = command;
+    this.reason = reason;
+  }
+};
+registerErrorClass(
+  "UNSAFE_COMMAND",
+  (p) => new UnsafeCommandError(
+    ctxString(p.context, "command"),
+    ctxString(p.context, "reason")
+  )
+);
+var SshConnectionError = class extends OctoFlowError {
+  constructor(message) {
+    super("SSH_CONNECTION_ERROR", message);
+    this.name = "SshConnectionError";
+  }
+};
+registerErrorClass(
+  "SSH_CONNECTION_ERROR",
+  (p) => new SshConnectionError(p.message)
+);
+
+// src/config/tools.ts
+var TOOL_ICONS = {
+  Bash: "\u{1F4BB}",
+  Read: "\u{1F4D6}",
+  Edit: "\u270F\uFE0F",
+  Write: "\u{1F4DD}",
+  Grep: "\u{1F50D}",
+  Glob: "\u{1F4C2}",
+  WebFetch: "\u{1F310}",
+  WebSearch: "\u{1F310}",
+  Skill: "\u26A1",
+  Task: "\u{1F500}"
+};
+function getToolIcon(name, extraIcons) {
+  const allIcons = extraIcons ? { ...TOOL_ICONS, ...extraIcons } : TOOL_ICONS;
+  if (allIcons[name]) return allIcons[name];
+  for (const [key, icon] of Object.entries(allIcons)) {
+    if (name.toLowerCase().includes(key.toLowerCase())) return icon;
+  }
+  if (name.startsWith("mcp__")) return "\u{1F50C}";
+  return "\u{1F527}";
+}
+
+// src/domain/contracts/messages.ts
+function createUsage(inputTokens, outputTokens, opts) {
+  return {
+    inputTokens,
+    outputTokens,
+    ...opts?.cachedInputTokens ? { cachedInputTokens: opts.cachedInputTokens } : {},
+    ...opts?.cacheWriteTokens ? { cacheWriteTokens: opts.cacheWriteTokens } : {},
+    ...opts?.cache ? { cache: opts.cache } : {}
+  };
+}
+function parseError(backend, line, err) {
+  return {
+    type: "parse_error",
+    backend,
+    raw: line,
+    reason: err instanceof Error ? err.message : String(err)
+  };
+}
+
+// src/adapters/agents/parsers/lifecycle.ts
+var DIRECT_LIFECYCLE_STATES = /* @__PURE__ */ new Map([
+  ["auth-required", "auth-required"],
+  ["auth_required", "auth-required"],
+  ["authentication-required", "auth-required"],
+  ["authentication_required", "auth-required"],
+  ["login-required", "auth-required"],
+  ["login_required", "auth-required"],
+  ["input-required", "input-required"],
+  ["input_required", "input-required"],
+  ["clarification-required", "input-required"],
+  ["clarification_required", "input-required"],
+  ["approval-required", "input-required"],
+  ["approval_required", "input-required"]
+]);
+function normalizeLifecycleKey(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase().replace(/\s+/g, "-");
+  return normalized.length > 0 ? normalized : null;
+}
+function detectLifecycleState(value) {
+  const normalized = normalizeLifecycleKey(value);
+  if (!normalized) return null;
+  return DIRECT_LIFECYCLE_STATES.get(normalized) ?? null;
+}
+function detectLifecycleFromText(text) {
+  if (!text) return null;
+  if (/(authentication required|auth required|login required|please log in|please login|api key required|access token required|device auth)/i.test(
+    text
+  )) {
+    return "auth-required";
+  }
+  if (/(input required|need more information|need more info|please confirm|which file|clarification required|approval required|waiting for input)/i.test(
+    text
+  )) {
+    return "input-required";
+  }
+  return null;
+}
+function detectLifecycleEvent(input) {
+  const state = detectLifecycleState(input.status) ?? detectLifecycleState(input.subtype) ?? detectLifecycleState(input.type) ?? (input.isError ? detectLifecycleFromText(input.text) : null);
+  if (!state) return null;
+  return {
+    type: state,
+    text: input.text,
+    sessionId: input.sessionId
+  };
+}
+
+// src/adapters/agents/parsers/anthropic.ts
+var anthropicParser = {
+  name: "anthropic",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    if (!line.trim()) return null;
+    try {
+      const data = JSON.parse(line);
+      const lifecycle = detectLifecycleEvent({
+        type: data.type,
+        subtype: data.subtype,
+        status: data.status,
+        text: data.text ?? data.result,
+        isError: data.isError ?? data.is_error,
+        sessionId: data.sessionId ?? data.session_id
+      });
+      if (lifecycle) return lifecycle;
+      if (data.type === "text" || data.type === "result" || data.type === "input-required" || data.type === "auth-required") {
+        return data;
+      }
+      return null;
+    } catch (err) {
+      return parseError("anthropic", line, err);
+    }
+  },
+  getToolIcon(name) {
+    return TOOL_ICONS[name] || "\u{1F527}";
+  }
+};
+var anthropic_default = anthropicParser;
+
+// src/adapters/agents/parsers/claude.ts
+var claudeParser = {
+  name: "claude",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    if (!line.trim()) return null;
+    try {
+      const data = JSON.parse(line);
+      if (data.type === "system" && data.subtype === "init" && data.session_id) {
+        return { type: "init", sessionId: data.session_id };
+      }
+      const lifecycle = detectLifecycleEvent({
+        type: data.type,
+        subtype: data.subtype,
+        status: data.status,
+        text: data.result,
+        isError: data.is_error,
+        sessionId: data.session_id
+      });
+      if (lifecycle) return lifecycle;
+      if (data.type === "stream_event") {
+        const event = data.event;
+        if (event?.type === "content_block_delta" && event.delta?.type === "thinking_delta") {
+          return { type: "thinking", text: event.delta.thinking };
+        }
+        if (event?.type === "content_block_delta" && event.delta?.type === "text_delta") {
+          return { type: "text", text: event.delta.text };
+        }
+        if (event?.type === "content_block_start" && event.content_block?.type === "tool_use") {
+          const toolName = event.content_block.name || "tool";
+          const args = event.content_block.input;
+          const toolCallId = event.content_block.id;
+          return {
+            type: "tool",
+            name: toolName,
+            icon: getToolIcon(toolName),
+            ...args ? { args } : {},
+            ...toolCallId ? { toolCallId } : {}
+          };
+        }
+        if (event?.type === "content_block_start" && event.content_block?.type === "thinking") {
+          return { type: "thinking_start" };
+        }
+      }
+      if (data.type === "result") {
+        let text = data.result || "";
+        if (!text && data.structured_output !== void 0) {
+          try {
+            text = JSON.stringify(data.structured_output);
+          } catch {
+            text = "";
+          }
+        }
+        return {
+          type: "result",
+          text,
+          isError: !!data.is_error,
+          usage: data.usage ? createUsage(data.usage.input_tokens, data.usage.output_tokens) : null,
+          costUsd: data.total_cost_usd || null,
+          // result lines also carry session_id — capture it so resume works
+          // even if the system/init line was somehow missing
+          sessionId: data.session_id || void 0
+        };
+      }
+      return null;
+    } catch (err) {
+      return parseError("claude", line, err);
+    }
+  },
+  getToolIcon(name) {
+    return getToolIcon(name);
+  }
+};
+var claude_default = claudeParser;
+
+// src/adapters/agents/parsers/codex.ts
+var CODEX_ICONS = {
+  command_execution: "\u{1F4BB}",
+  shell: "\u{1F4BB}"
+};
+function toolIcon(name) {
+  return getToolIcon(name, CODEX_ICONS);
+}
+var codexParser = {
+  name: "codex-cli",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    if (!line.trim()) return null;
+    try {
+      const data = JSON.parse(line);
+      const lifecycle = detectLifecycleEvent({
+        type: data.type,
+        status: data.status,
+        text: data.item?.text,
+        sessionId: data.thread_id
+      });
+      if (lifecycle) return lifecycle;
+      if (data.type === "thread.started") {
+        return { type: "init", sessionId: data.thread_id };
+      }
+      if (data.type === "item.completed" && data.item) {
+        if (data.item.type === "reasoning") {
+          return { type: "thinking", text: data.item.text || "" };
+        }
+        if (data.item.type === "agent_message") {
+          return { type: "text", text: data.item.text || "" };
+        }
+        if (data.item.type === "command_execution") {
+          return {
+            type: "tool",
+            name: "Bash",
+            icon: "\u{1F4BB}",
+            ...data.item.arguments ? { args: data.item.arguments } : data.item.command ? { args: { command: data.item.command } } : {},
+            ...data.item.call_id ? { toolCallId: data.item.call_id } : {}
+          };
+        }
+      }
+      if (data.type === "item.started" && data.item?.type === "command_execution") {
+        return {
+          type: "tool",
+          name: "Bash",
+          icon: toolIcon("Bash"),
+          ...data.item.arguments ? { args: data.item.arguments } : data.item.command ? { args: { command: data.item.command } } : {},
+          ...data.item.call_id ? { toolCallId: data.item.call_id } : {}
+        };
+      }
+      if (data.type === "turn.completed") {
+        return {
+          type: "result",
+          text: "",
+          isError: false,
+          usage: data.usage ? createUsage(data.usage.input_tokens, data.usage.output_tokens) : null
+        };
+      }
+      return null;
+    } catch (err) {
+      return parseError("codex-cli", line, err);
+    }
+  },
+  getToolIcon(name) {
+    return toolIcon(name);
+  }
+};
+var codex_default = codexParser;
+
+// src/adapters/agents/parsers/cursor.ts
+var CURSOR_ICONS = {
+  shell: "\u{1F4BB}",
+  read: "\u{1F4D6}",
+  edit: "\u270F\uFE0F",
+  write: "\u{1F4DD}",
+  grep: "\u{1F50D}"
+};
+function toolIcon2(name) {
+  return getToolIcon(name, CURSOR_ICONS);
+}
+function extractToolArgs(toolCall) {
+  if (!toolCall) return void 0;
+  for (const key of Object.keys(toolCall)) {
+    if (key.endsWith("ToolCall")) {
+      const value = toolCall[key];
+      if (value && typeof value === "object") {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function extractToolName(toolCall) {
+  if (!toolCall) return "tool";
+  if (toolCall.shellToolCall) return "Bash";
+  if (toolCall.readToolCall) return "Read";
+  if (toolCall.editToolCall) return "Edit";
+  if (toolCall.writeToolCall) return "Write";
+  if (toolCall.grepToolCall) return "Grep";
+  if (toolCall.globToolCall) return "Glob";
+  for (const key of Object.keys(toolCall)) {
+    if (key.endsWith("ToolCall")) {
+      const name = key.replace("ToolCall", "");
+      return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+  }
+  return "tool";
+}
+var cursorParser = {
+  name: "cursor-cli",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    if (!line.trim()) return null;
+    try {
+      const data = JSON.parse(line);
+      const lifecycle = detectLifecycleEvent({
+        type: data.type,
+        subtype: data.subtype,
+        status: data.status,
+        text: data.text ?? data.result ?? data.message?.content?.find((block) => block.type === "text")?.text,
+        isError: data.is_error,
+        sessionId: data.session_id
+      });
+      if (lifecycle) return lifecycle;
+      if (data.type === "thinking" && data.subtype === "start") {
+        return { type: "thinking_start" };
+      }
+      if (data.type === "thinking" && data.subtype === "delta") {
+        return { type: "thinking", text: data.text || "" };
+      }
+      if (data.type === "tool_call" && data.subtype === "started") {
+        const name = extractToolName(data.tool_call);
+        const args = extractToolArgs(data.tool_call);
+        return {
+          type: "tool",
+          name,
+          icon: toolIcon2(name),
+          ...args ? { args } : {},
+          ...data.tool_call_id ? { toolCallId: data.tool_call_id } : {}
+        };
+      }
+      if (data.type === "tool_call" && (data.subtype === "result" || data.subtype === "output")) {
+        return {
+          type: "tool_call_result",
+          text: data.output ?? data.result ?? "",
+          isError: !!data.is_error,
+          ...data.tool_call_id ? { toolCallId: data.tool_call_id } : {}
+        };
+      }
+      if (data.type === "tool_call" && (data.subtype === "stop" || data.subtype === "stopped" || data.subtype === "completed")) {
+        return {
+          type: "tool_call_stop",
+          ...data.tool_call_id ? { toolCallId: data.tool_call_id } : {}
+        };
+      }
+      if (data.type === "assistant" && data.message?.content) {
+        if (data.timestamp_ms == null) return null;
+        const textContent = data.message.content.find(
+          (block) => block.type === "text"
+        );
+        if (textContent?.text) return { type: "text", text: textContent.text };
+      }
+      if (data.type === "result") {
+        return {
+          type: "result",
+          text: data.result || "",
+          isError: !!data.is_error,
+          sessionId: data.session_id || void 0
+        };
+      }
+      if (data.type === "system" && data.subtype === "init") {
+        return { type: "init", sessionId: data.session_id };
+      }
+      return null;
+    } catch (err) {
+      return parseError("cursor-cli", line, err);
+    }
+  },
+  getToolIcon(name) {
+    return toolIcon2(name);
+  }
+};
+var cursor_default = cursorParser;
+
+// src/adapters/agents/parsers/gemini-cli.ts
+var geminiCliParser = {
+  name: "gemini-cli",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch (err) {
+      return parseError("gemini-cli", line, err);
+    }
+    switch (event.type) {
+      case "init":
+        return {
+          type: "init",
+          ...event.session_id ? { sessionId: event.session_id } : {}
+        };
+      case "message":
+        if (event.role !== "assistant") return null;
+        return { type: "text", text: event.content ?? "" };
+      case "tool_use":
+        return {
+          type: "tool",
+          name: event.tool_name ?? "unknown",
+          icon: getToolIcon(event.tool_name ?? "", {}),
+          ...event.tool_id ? { toolCallId: event.tool_id } : {},
+          ...event.parameters ? { args: event.parameters } : {}
+        };
+      case "error":
+        if (event.severity === "warning") return null;
+        return {
+          type: "result",
+          isError: true,
+          text: event.message ?? "Gemini CLI error"
+        };
+      case "result": {
+        if (event.status === "error") {
+          return {
+            type: "result",
+            isError: true,
+            text: event.error?.message ?? "Gemini CLI returned an error"
+          };
+        }
+        const stats = event.stats;
+        const usage = stats?.input_tokens != null && stats?.output_tokens != null ? createUsage(stats.input_tokens, stats.output_tokens, {
+          cachedInputTokens: stats.cached ?? 0
+        }) : null;
+        return { type: "result", isError: false, text: "", usage };
+      }
+      // tool_result is CLI-internal (shows what the tool returned to the model).
+      // Ignored — the tool_use event already surfaces the call to consumers.
+      default:
+        return null;
+    }
+  },
+  getToolIcon(name) {
+    return getToolIcon(name, {});
+  }
+};
+var gemini_cli_default = geminiCliParser;
+
+// src/adapters/agents/parsers/ollama.ts
+function toUsage(data) {
+  if (typeof data.prompt_eval_count !== "number" && typeof data.eval_count !== "number") {
+    return null;
+  }
+  return createUsage(data.prompt_eval_count ?? 0, data.eval_count ?? 0);
+}
+var ollamaParser = {
+  name: "ollama",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    if (!line.trim()) return null;
+    try {
+      const data = JSON.parse(line);
+      if (typeof data.error === "string" && data.error.length > 0) {
+        return {
+          type: "result",
+          text: data.error,
+          isError: true,
+          usage: toUsage(data)
+        };
+      }
+      const thinking = data.message?.thinking ?? data.thinking;
+      if (typeof thinking === "string" && thinking.length > 0) {
+        return { type: "thinking", text: thinking };
+      }
+      const text = data.message?.content ?? data.response;
+      if (typeof text === "string" && text.length > 0) {
+        return { type: "text", text };
+      }
+      const firstTool = data.message?.tool_calls?.[0];
+      const toolName = firstTool?.function?.name;
+      if (typeof toolName === "string" && toolName.length > 0) {
+        const args = firstTool?.function?.arguments;
+        return {
+          type: "tool",
+          name: toolName,
+          icon: getToolIcon(toolName),
+          ...args ? { args } : {}
+        };
+      }
+      if (data.done) {
+        return {
+          type: "result",
+          text: "",
+          isError: false,
+          usage: toUsage(data)
+        };
+      }
+      return null;
+    } catch (err) {
+      return parseError("ollama", line, err);
+    }
+  },
+  getToolIcon(name) {
+    return getToolIcon(name);
+  }
+};
+var ollama_default = ollamaParser;
+
+// src/adapters/agents/parsers/openai.ts
+var openaiParser = {
+  name: "openai",
+  toolIcons: TOOL_ICONS,
+  parseLine(line) {
+    if (!line.trim()) return null;
+    try {
+      const data = JSON.parse(line);
+      const lifecycle = detectLifecycleEvent({
+        type: data.type,
+        subtype: data.subtype,
+        status: data.status,
+        text: data.text ?? data.result,
+        isError: data.isError ?? data.is_error,
+        sessionId: data.sessionId ?? data.session_id
+      });
+      if (lifecycle) return lifecycle;
+      if (data.type === "text" || data.type === "result" || data.type === "input-required" || data.type === "auth-required") {
+        return data;
+      }
+      return null;
+    } catch (err) {
+      return parseError("openai", line, err);
+    }
+  },
+  getToolIcon(name) {
+    return TOOL_ICONS[name] || "\u{1F527}";
+  }
+};
+var openai_default = openaiParser;
+
+// src/adapters/agents/parsers/index.ts
+var parsers = /* @__PURE__ */ new Map([
+  ["claude", claude_default],
+  ["cursor", cursor_default],
+  ["codex", codex_default],
+  ["gemini-cli", gemini_cli_default],
+  ["openai", openai_default],
+  ["ollama", ollama_default],
+  ["anthropic", anthropic_default]
+]);
+function getStreamParser(name) {
+  return parsers.get(name);
+}
+
+// src/adapters/agents/runtime/command-safety.ts
+var ANSI_PATTERN = new RegExp(
+  `${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`,
+  "g"
+);
+var ZERO_WIDTH_RE = /[\u200B-\u200D\u2060\uFEFF\u00AD]/g;
+var DANGEROUS_PATTERNS = [
+  {
+    description: "recursive delete",
+    pattern: /\brm\b[^\n]*(?:\s-[a-z]*r[a-z]*|\s--recursive)(?:\s|$)/
+  },
+  { description: "delete root path", pattern: /\brm\s+-[^\n]*\s+\/(?:\s|$)/ },
+  {
+    description: "remote script execution",
+    pattern: /\b(?:curl|wget)\b[^\n]*\|\s*(?:ba)?sh\b/
+  },
+  { description: "shell eval", pattern: /\b(?:bash|sh|zsh|ksh)\s+-c\b/ },
+  {
+    description: "inline script execution",
+    pattern: /\b(?:python|perl|ruby|node)\s+-[ec]\b/
+  },
+  {
+    description: "system configuration write",
+    pattern: /\b(?:tee|cp|mv|install|sed)\b[^\n]*\/etc\//
+  },
+  {
+    description: "dangerous chmod",
+    pattern: /\bchmod\b[^\n]*\b(?:777|666|a\+w|o\+w)\b/
+  }
+];
+function normalizeCommand(raw) {
+  return raw.replace(ANSI_PATTERN, "").replaceAll("\0", "").normalize("NFKC").replace(ZERO_WIDTH_RE, "").toLowerCase();
+}
+function checkCommandSafety(command, args) {
+  const normalized = normalizeCommand([command, ...args].join(" "));
+  for (const rule of DANGEROUS_PATTERNS) {
+    if (rule.pattern.test(normalized)) {
+      return {
+        safe: false,
+        reason: rule.description
+      };
+    }
+  }
+  return { safe: true };
+}
+
+// src/adapters/agents/runtime/ssh-runner-internal.ts
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_ssh2 = require("ssh2");
+
+// src/adapters/agents/runtime/shell-utils.ts
+var SAFE_ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSafeEnvKey(key) {
+  if (!SAFE_ENV_KEY.test(key)) {
+    throw new Error(`Unsafe environment variable name: ${key}`);
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/adapters/agents/runtime/ssh-runner-internal.ts
+var SshConnectionPool = class {
+  idleTtlMs;
+  maxIdle;
+  idle = /* @__PURE__ */ new Map();
+  active = /* @__PURE__ */ new Set();
+  disposed = false;
+  constructor(options = {}) {
+    this.idleTtlMs = options.idleTtlMs ?? 6e4;
+    this.maxIdle = options.maxIdle ?? 4;
+  }
+  async acquire(key, factory) {
+    if (this.disposed) {
+      throw new SshConnectionError("SSH connection pool is disposed");
+    }
+    const bucket = this.idle.get(key);
+    while (bucket && bucket.length > 0) {
+      const entry2 = bucket.shift();
+      if (entry2.idleTimer) clearTimeout(entry2.idleTimer);
+      this.active.add(entry2);
+      return entry2;
+    }
+    const created = await factory();
+    const entry = {
+      conn: created.conn,
+      bastion: created.bastion,
+      idleSince: 0
+    };
+    this.attachEvictionListeners(key, entry);
+    this.active.add(entry);
+    return entry;
+  }
+  release(key, entry) {
+    this.active.delete(entry);
+    if (this.disposed) {
+      this.closeEntry(entry);
+      return;
+    }
+    const bucket = this.idle.get(key) ?? [];
+    if (bucket.length >= this.maxIdle) {
+      this.closeEntry(entry);
+      return;
+    }
+    entry.idleSince = Date.now();
+    entry.idleTimer = setTimeout(() => {
+      const current = this.idle.get(key);
+      if (!current) return;
+      const idx = current.indexOf(entry);
+      if (idx === -1) return;
+      current.splice(idx, 1);
+      this.closeEntry(entry);
+    }, this.idleTtlMs);
+    if (typeof entry.idleTimer.unref === "function") entry.idleTimer.unref();
+    bucket.push(entry);
+    this.idle.set(key, bucket);
+  }
+  evict(key, entry) {
+    this.active.delete(entry);
+    const bucket = this.idle.get(key);
+    if (bucket) {
+      const idx = bucket.indexOf(entry);
+      if (idx !== -1) bucket.splice(idx, 1);
+    }
+    this.closeEntry(entry);
+  }
+  dispose() {
+    this.disposed = true;
+    for (const bucket of this.idle.values()) {
+      for (const entry of bucket) this.closeEntry(entry);
+    }
+    this.idle.clear();
+    for (const entry of this.active) this.closeEntry(entry);
+    this.active.clear();
+    return Promise.resolve();
+  }
+  attachEvictionListeners(key, entry) {
+    const handler = () => this.evict(key, entry);
+    entry.conn.once("error", handler);
+    entry.conn.once("end", handler);
+    entry.conn.once("close", handler);
+    entry.bastion?.once("error", handler);
+    entry.bastion?.once("end", handler);
+    entry.bastion?.once("close", handler);
+  }
+  closeEntry(entry) {
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
+    try {
+      entry.conn.end();
+    } catch {
+    }
+    if (entry.bastion) {
+      try {
+        entry.bastion.end();
+      } catch {
+      }
+    }
+  }
+};
+function verifyHostKey(key, fingerprint, label) {
+  if (!fingerprint) {
+    if (process.env.NODE_ENV === "production") {
+      throw new SshConnectionError(
+        `SSH ${label} hostFingerprint is required in production. Set hostFingerprint in SshRunnerOptions or use NODE_ENV=development for local testing.`
+      );
+    }
+    return true;
+  }
+  const actual = import_node_crypto.default.createHash("sha256").update(key).digest("hex");
+  return actual === fingerprint;
+}
+function buildRemoteCommand(plan) {
+  if (!plan.command) throw new Error("Execution plan is missing command");
+  const envPrefix = Object.entries(plan.env ?? {}).map(([k, v]) => {
+    assertSafeEnvKey(k);
+    return `${k}=${shellQuote(String(v))}`;
+  }).join(" ");
+  const args = (plan.args ?? []).map(shellQuote).join(" ");
+  const cmd = `${plan.command} ${args}`.trim();
+  const inDirectory = plan.cwd ? `cd ${shellQuote(plan.cwd)} && ${cmd}` : cmd;
+  return envPrefix ? `${envPrefix} ${inDirectory}` : inDirectory;
+}
+function openConnection(config) {
+  return new Promise((resolve, reject) => {
+    const client = new import_ssh2.Client();
+    client.on("ready", () => resolve(client));
+    client.on(
+      "error",
+      (err) => reject(new SshConnectionError(`SSH connection failed: ${err.message}`))
+    );
+    client.connect(config);
+  });
+}
+
+// src/adapters/agents/runtime/runner.ts
+var import_node_child_process = require("node:child_process");
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+var EventDispatchQueue = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+  }
+  onEvent;
+  callbackErrors = [];
+  queue = Promise.resolve();
+  dispatch(event) {
+    if (!this.onEvent) return;
+    this.queue = this.queue.then(() => this.onEvent?.(event)).catch((error) => {
+      this.callbackErrors.push(error);
+    });
+  }
+  async flush() {
+    await this.queue;
+    if (this.callbackErrors.length === 0) return;
+    if (this.callbackErrors.length === 1) throw toError(this.callbackErrors[0]);
+    throw new AggregateError(
+      this.callbackErrors.map(toError),
+      `EventDispatchQueue: ${this.callbackErrors.length} callback errors`
+    );
+  }
+};
+var Semaphore = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  active = 0;
+  queue = [];
+  acquire() {
+    if (this.active < this.limit) {
+      this.active++;
+      return Promise.resolve(this.makeRelease());
+    }
+    return new Promise((resolve) => {
+      this.queue.push(() => {
+        this.active++;
+        resolve(this.makeRelease());
+      });
+    });
+  }
+  makeRelease() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.active--;
+      const next = this.queue.shift();
+      if (next) next();
+    };
+  }
+};
+function mergeFinalText(events) {
+  const resultTexts = events.filter((event) => event.type === "result" && event.text).map((event) => event.text || "");
+  if (resultTexts.length > 0) {
+    const lastResultText = resultTexts[resultTexts.length - 1] || "";
+    if (lastResultText.length > 0) return lastResultText;
+  }
+  return events.filter((event) => event.type === "text" && event.text).map((event) => event.text || "").join("");
+}
+function collectLines(buffer, onLine) {
+  let rest = buffer;
+  let newlineIndex = rest.indexOf("\n");
+  while (newlineIndex !== -1) {
+    const line = rest.slice(0, newlineIndex);
+    onLine(line);
+    rest = rest.slice(newlineIndex + 1);
+    newlineIndex = rest.indexOf("\n");
+  }
+  return rest;
+}
+
+// src/adapters/agents/runtime/ssh-runner.ts
+var SshProcessRunner = class {
+  opts;
+  semaphore;
+  pool;
+  constructor(opts) {
+    this.opts = opts;
+    this.semaphore = new Semaphore(opts.maxConcurrent ?? 4);
+    if (opts.pool) {
+      this.pool = new SshConnectionPool(opts.pool === true ? {} : opts.pool);
+    }
+  }
+  dispose() {
+    return this.pool?.dispose() ?? Promise.resolve();
+  }
+  async run(plan, onEvent, signal) {
+    const release = await this.semaphore.acquire();
+    try {
+      return await this.runInternal(plan, onEvent, signal);
+    } finally {
+      release();
+    }
+  }
+  async runInternal(plan, onEvent, signal) {
+    const { opts } = this;
+    if (!plan.command) throw new Error("Execution plan is missing command");
+    const args = plan.args ?? [];
+    if (plan.runtimePolicy?.backend === "custom" && plan.runtimePolicy.approvalMode !== "off") {
+      const safety = checkCommandSafety(plan.command, args);
+      if (!safety.safe) {
+        throw new UnsafeCommandError(
+          plan.command,
+          safety.reason ?? "command matched an unsafe pattern"
+        );
+      }
+    }
+    const parser = getStreamParser(plan.parser);
+    if (!parser) throw new Error(`Unknown parser: ${plan.parser}`);
+    const baseConfig = {
+      host: opts.host,
+      port: opts.port ?? 22,
+      username: opts.username,
+      privateKey: opts.privateKey,
+      passphrase: opts.passphrase,
+      keepaliveInterval: opts.keepaliveInterval ?? 1e4,
+      keepaliveCountMax: opts.keepaliveCountMax ?? 6,
+      readyTimeout: opts.connectTimeout ?? 3e4,
+      hostVerifier: (key) => verifyHostKey(key, opts.hostFingerprint, "target host")
+    };
+    const factory = async () => {
+      if (opts.bastionHost) {
+        const bastion2 = await openConnection({
+          host: opts.bastionHost,
+          port: opts.bastionPort ?? 22,
+          username: opts.bastionUsername ?? opts.username,
+          privateKey: opts.bastionPrivateKey ?? opts.privateKey,
+          readyTimeout: opts.connectTimeout ?? 3e4,
+          hostVerifier: (key) => verifyHostKey(key, opts.bastionHostFingerprint, "bastion host")
+        });
+        const tunnelStream = await new Promise((resolve, reject) => {
+          bastion2.forwardOut(
+            "127.0.0.1",
+            0,
+            opts.host,
+            opts.port ?? 22,
+            (err, stream) => {
+              if (err) {
+                reject(
+                  new SshConnectionError(
+                    `Bastion forwardOut failed: ${err.message}`
+                  )
+                );
+              } else {
+                resolve(stream);
+              }
+            }
+          );
+        });
+        const conn3 = await openConnection({
+          ...baseConfig,
+          sock: tunnelStream
+        });
+        return { conn: conn3, bastion: bastion2 };
+      }
+      const conn2 = await openConnection(baseConfig);
+      return { conn: conn2 };
+    };
+    if (this.pool) {
+      const key = `${opts.host}:${opts.port ?? 22}:${opts.username}`;
+      const entry = await this.pool.acquire(key, factory);
+      let evicted = false;
+      try {
+        return await this.runExec(entry.conn, plan, parser, onEvent, signal);
+      } catch (err) {
+        if (err instanceof SshConnectionError) {
+          this.pool.evict(key, entry);
+          evicted = true;
+        }
+        throw err;
+      } finally {
+        if (!evicted) this.pool.release(key, entry);
+      }
+    }
+    const { conn, bastion } = await factory();
+    try {
+      return await this.runExec(conn, plan, parser, onEvent, signal);
+    } finally {
+      conn.end();
+      bastion?.end();
+    }
+  }
+  runExec(conn, plan, parser, onEvent, signal) {
+    const timeoutMs = plan.timeoutMs ?? 6e5;
+    const remoteCommand = buildRemoteCommand(plan);
+    return new Promise((resolve, reject) => {
+      conn.exec(
+        remoteCommand,
+        { pty: this.opts.pty ?? false },
+        (err, channel) => {
+          if (err) {
+            reject(new SshConnectionError(`SSH exec failed: ${err.message}`));
+            return;
+          }
+          let stdout = "";
+          let stderr = "";
+          let pending = "";
+          let sessionId = null;
+          const events = [];
+          const eventDispatch = new EventDispatchQueue(onEvent);
+          let settled = false;
+          const settle = (fn) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            fn();
+          };
+          const abort = () => settle(() => {
+            channel.destroy();
+            reject(new SshConnectionError("SSH process canceled"));
+          });
+          const timer = setTimeout(
+            () => settle(() => {
+              channel.destroy();
+              reject(
+                new SshConnectionError(
+                  `SSH process timed out after ${timeoutMs}ms`
+                )
+              );
+            }),
+            timeoutMs
+          );
+          if (signal?.aborted) {
+            abort();
+            return;
+          }
+          signal?.addEventListener("abort", abort, { once: true });
+          channel.setEncoding("utf8");
+          channel.stderr.setEncoding("utf8");
+          channel.on("data", (chunk) => {
+            stdout += chunk;
+            pending += chunk;
+            pending = collectLines(pending, (line) => {
+              const event = parser.parseLine(line);
+              if (!event) return;
+              events.push(event);
+              if (event.sessionId) sessionId = event.sessionId;
+              eventDispatch.dispatch(event);
+            });
+          });
+          channel.stderr.on("data", (chunk) => {
+            stderr += chunk;
+          });
+          channel.on(
+            "close",
+            (exitCode) => settle(() => {
+              void (async () => {
+                if (pending.length > 0) {
+                  const event = parser.parseLine(pending);
+                  if (event) {
+                    events.push(event);
+                    if (event.sessionId) sessionId = event.sessionId;
+                    eventDispatch.dispatch(event);
+                  }
+                }
+                await eventDispatch.flush();
+                if (!sessionId && plan.sessionId) sessionId = plan.sessionId;
+                resolve({
+                  exitCode: exitCode ?? 0,
+                  stdout,
+                  stderr,
+                  events,
+                  finalText: mergeFinalText(events),
+                  sessionId,
+                  runnerSessionName: null
+                });
+              })().catch((error) => {
+                reject(
+                  error instanceof Error ? error : new Error(String(error))
+                );
+              });
+            })
+          );
+          if (plan.stdin) channel.write(plan.stdin);
+          channel.end();
+        }
+      );
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SshProcessRunner
+});
+//# sourceMappingURL=subpath-ssh.cjs.map