@opentag/runner 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,10 +1,14 @@
+// src/claude-code.ts
+import { contextPointerLabel as contextPointerLabel2 } from "@opentag/core";
+
 // src/command.ts
 import { spawn } from "child_process";
 var nodeCommandRunner = {
   run(command, args, options = {}) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const child = spawn(command, args, {
         cwd: options.cwd,
+        env: options.env,
         stdio: ["pipe", "pipe", "pipe"]
       });
       const stdout = [];
@@ -13,12 +17,14 @@ var nodeCommandRunner = {
       child.stderr.on("data", (chunk) => stderr.push(chunk));
       child.on("error", reject);
       child.on("close", (exitCode) => {
-        resolve({
+        resolve2({
           exitCode: exitCode ?? 1,
           stdout: Buffer.concat(stdout).toString("utf8"),
           stderr: Buffer.concat(stderr).toString("utf8")
         });
       });
+      child.stdin.on("error", () => {
+      });
       if (options.input) {
         child.stdin.write(options.input);
       }
@@ -32,17 +38,199 @@ async function assertCommandSucceeded(result, label) {
   }
 }
 
+// src/executor-report.ts
+var EXECUTOR_REPORT_START = "OPENTAG_EXECUTOR_REPORT_START";
+var EXECUTOR_REPORT_END = "OPENTAG_EXECUTOR_REPORT_END";
+var REPORT_OUTCOMES = /* @__PURE__ */ new Set(["passed", "failed", "not_run"]);
+var MAX_REPORT_ITEMS = 8;
+var MAX_REPORT_TEXT_LENGTH = 600;
+function executorReportPromptLines() {
+  return [
+    "End with this exact machine-readable OpenTag executor report block. Put it last.",
+    "Replace every example value with the actual result. Use changes: [] if no files changed.",
+    "Use verification: [] if no checks ran. Use verification outcome exactly one of: passed, failed, not_run.",
+    EXECUTOR_REPORT_START,
+    JSON.stringify(
+      {
+        changes: [{ file: "README.md", summary: "Added one sentence describing the completed change." }],
+        verification: [{ command: "corepack pnpm test", outcome: "passed", summary: "Tests passed." }],
+        risks: []
+      },
+      null,
+      2
+    ),
+    EXECUTOR_REPORT_END
+  ];
+}
+function executorPolicyPromptLines() {
+  return [
+    "Work autonomously but keep the change narrow. Run relevant verification if you modify files.",
+    "OpenTag owns the source-control handoff after you finish.",
+    "Do not run, request, or recommend git add, git commit, git push, or gh pr create.",
+    "Do not ask the user to approve local source-control commands; summarize file changes and verification only.",
+    "OpenTag will publish the run branch and expose pull-request creation as a suggested action.",
+    ...executorReportPromptLines()
+  ];
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function cleanReportText(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.replace(/\s+/g, " ").trim();
+  return text.length > 0 ? text.slice(0, MAX_REPORT_TEXT_LENGTH) : void 0;
+}
+function cleanStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.map(cleanReportText).filter((item) => Boolean(item));
+  return items.length > 0 ? items.slice(0, MAX_REPORT_ITEMS) : void 0;
+}
+function normalizeReport(value) {
+  const record = asRecord(value);
+  if (!record || !Array.isArray(record["changes"])) return void 0;
+  const changes = record["changes"].map((item) => {
+    const change = asRecord(item);
+    if (!change) return void 0;
+    const summary = cleanReportText(change["summary"]);
+    if (!summary) return void 0;
+    const file = cleanReportText(change["file"]);
+    return file ? { file, summary } : { summary };
+  }).filter((item) => Boolean(item)).slice(0, MAX_REPORT_ITEMS);
+  if (record["changes"].length > 0 && changes.length === 0) return void 0;
+  const verificationRaw = record["verification"];
+  const verification = Array.isArray(verificationRaw) ? verificationRaw.map((item) => {
+    const check = asRecord(item);
+    if (!check || typeof check["outcome"] !== "string" || !REPORT_OUTCOMES.has(check["outcome"])) return void 0;
+    const command = cleanReportText(check["command"]);
+    const summary = cleanReportText(check["summary"]);
+    return {
+      ...command ? { command } : {},
+      outcome: check["outcome"],
+      ...summary ? { summary } : {}
+    };
+  }).filter((item) => Boolean(item)).slice(0, MAX_REPORT_ITEMS) : void 0;
+  if (Array.isArray(verificationRaw) && verificationRaw.length > 0 && (!verification || verification.length === 0)) {
+    return void 0;
+  }
+  const risks = cleanStringArray(record["risks"]);
+  const notes = cleanStringArray(record["notes"]);
+  return {
+    changes,
+    ...verification && verification.length > 0 ? { verification } : {},
+    ...risks ? { risks } : {},
+    ...notes ? { notes } : {}
+  };
+}
+function markerCandidate(output) {
+  const startIndex = output.lastIndexOf(EXECUTOR_REPORT_START);
+  if (startIndex < 0) return void 0;
+  const afterStart = output.slice(startIndex + EXECUTOR_REPORT_START.length);
+  const endIndex = afterStart.indexOf(EXECUTOR_REPORT_END);
+  return (endIndex >= 0 ? afterStart.slice(0, endIndex) : afterStart).trim();
+}
+function parseCandidate(candidate) {
+  try {
+    return normalizeReport(JSON.parse(candidate));
+  } catch {
+    return void 0;
+  }
+}
+function parseExecutorReport(output) {
+  const marker = markerCandidate(output);
+  if (marker) {
+    const parsed = parseCandidate(marker);
+    if (parsed) return parsed;
+  }
+  return parseCandidate(output.trim());
+}
+function deterministicSummary(input) {
+  if (input.changedFiles.length === 0) {
+    return `${input.executorName} completed without file changes.`;
+  }
+  return `${input.executorName} changed ${input.changedFiles.length} file(s). Changed files: ${input.changedFiles.join(", ")}.`;
+}
+function renderExecutorReportSummary(input) {
+  const lines = [];
+  if (input.report.changes.length > 0) {
+    lines.push("What changed:");
+    for (const change of input.report.changes) {
+      lines.push(`- ${change.file ? `\`${change.file}\`: ` : ""}${change.summary}`);
+    }
+  }
+  if (input.report.verification?.length) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Verified:");
+    for (const check of input.report.verification) {
+      const prefix = check.command ? `\`${check.command}\`: ${check.outcome}` : check.outcome;
+      lines.push(`- ${check.summary ? `${prefix} - ${check.summary}` : prefix}`);
+    }
+  }
+  if (input.report.risks?.length) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Risks:");
+    for (const risk of input.report.risks) {
+      lines.push(`- ${risk}`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : deterministicSummary(input);
+}
+
+// src/executor.ts
+import { contextPointerLabel } from "@opentag/core";
+function renderContextPacketForPrompt(packet) {
+  if (!packet) return [];
+  const lines = ["OpenTag context packet:", `- summary: ${packet.summary}`];
+  if (packet.intent) {
+    lines.push(`- intent: ${packet.intent.normalizedIntent}`);
+    lines.push(`- requested by: ${packet.intent.requestedBy.provider}:${packet.intent.requestedBy.providerUserId}`);
+  }
+  if (packet.sources?.length) {
+    lines.push("- selected sources:");
+    for (const source of packet.sources) {
+      lines.push(`  - [${source.role}] ${contextPointerLabel(source.pointer)}: ${source.pointer.uri}`);
+      lines.push(`    reason: ${source.reason}`);
+    }
+  }
+  if (packet.facts?.length) {
+    lines.push("- facts:");
+    for (const fact of packet.facts) {
+      lines.push(`  - ${fact.text}`);
+    }
+  }
+  if (packet.exclusions?.length) {
+    lines.push("- exclusions:");
+    for (const exclusion of packet.exclusions) {
+      lines.push(`  - ${exclusion}`);
+    }
+  }
+  return lines;
+}
+
 // src/git.ts
+import { mkdirSync } from "fs";
+import { dirname } from "path";
 var INTERNAL_ARTIFACT_ROOTS = [".omx", ".codex", ".claude"];
 function branchNameForRun(runId) {
   const safeRunId = runId.replace(/[^a-zA-Z0-9._-]/g, "-");
   return `opentag/${safeRunId}`;
 }
+var STATUS_PORCELAIN_Z_ARGS = ["-c", "core.quotePath=false", "status", "--porcelain", "-z"];
 function parseStatusEntries(statusOutput) {
-  return statusOutput.split("\n").map((line) => line.replace(/\r$/, "")).filter(Boolean).map((line) => ({
-    status: line.slice(0, 2),
-    path: line.slice(3).trim()
-  })).filter((entry) => entry.path.length > 0);
+  const records = statusOutput.split("\0");
+  const entries = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record) continue;
+    const status = record.slice(0, 2);
+    const path = record.slice(3);
+    const isRenameOrCopy = status.includes("R") || status.includes("C");
+    if (isRenameOrCopy) {
+      index += 1;
+    }
+    if (path.length === 0) continue;
+    entries.push({ status, path });
+  }
+  return entries;
 }
 function isInternalArtifactPath(path) {
   return INTERNAL_ARTIFACT_ROOTS.some((root) => path === root || path.startsWith(`${root}/`));
@@ -51,16 +239,42 @@ function parseChangedFiles(statusOutput) {
   return parseStatusEntries(statusOutput).map((entry) => entry.path).filter((path) => !isInternalArtifactPath(path));
 }
 async function createRunBranch(input) {
-  const result = await input.runner.run("git", ["checkout", "-B", input.branchName], { cwd: input.workspacePath });
+  const result = await input.runner.run("git", ["checkout", "-B", input.branchName, ...input.startPoint ? [input.startPoint] : []], { cwd: input.workspacePath });
   await assertCommandSucceeded(result, "create run branch");
 }
+function worktreePathForRun(input) {
+  const safeRunId = input.runId.replace(/[^a-zA-Z0-9._-]/g, "-");
+  const root = input.worktreeRoot ?? `${input.workspacePath.replace(/\/$/, "")}/.worktrees/opentag`;
+  return `${root.replace(/\/$/, "")}/${safeRunId}`;
+}
+async function createRunWorktree(input) {
+  mkdirSync(dirname(input.worktreePath), { recursive: true });
+  const result = await input.runner.run(
+    "git",
+    ["worktree", "add", "-B", input.branchName, input.worktreePath, input.baseBranch],
+    { cwd: input.workspacePath }
+  );
+  await assertCommandSucceeded(result, "create run worktree");
+}
+async function removeRunWorktree(input) {
+  const result = await input.runner.run("git", ["worktree", "remove", "--force", input.worktreePath], {
+    cwd: input.workspacePath
+  });
+  await assertCommandSucceeded(result, "remove run worktree");
+}
+async function deleteRunBranch(input) {
+  const result = await input.runner.run("git", ["branch", "-D", input.branchName], {
+    cwd: input.workspacePath
+  });
+  await assertCommandSucceeded(result, "delete empty run branch");
+}
 async function changedFiles(input) {
-  const result = await input.runner.run("git", ["status", "--porcelain"], { cwd: input.workspacePath });
+  const result = await input.runner.run("git", STATUS_PORCELAIN_Z_ARGS, { cwd: input.workspacePath });
   await assertCommandSucceeded(result, "read changed files");
   return parseChangedFiles(result.stdout);
 }
 async function cleanupInternalArtifacts(input) {
-  const statusResult = await input.runner.run("git", ["status", "--porcelain"], { cwd: input.workspacePath });
+  const statusResult = await input.runner.run("git", STATUS_PORCELAIN_Z_ARGS, { cwd: input.workspacePath });
   await assertCommandSucceeded(statusResult, "scan internal artifacts");
   const untrackedRoots = Array.from(
     new Set(
@@ -74,15 +288,138 @@ async function cleanupInternalArtifacts(input) {
   await assertCommandSucceeded(cleanResult, "clean internal artifacts");
   return untrackedRoots;
 }
+async function commitRunChanges(input) {
+  const files = await changedFiles({ runner: input.runner, workspacePath: input.workspacePath });
+  if (files.length === 0) return false;
+  const addResult = await input.runner.run("git", ["add", "--", ...files], {
+    cwd: input.workspacePath
+  });
+  await assertCommandSucceeded(addResult, "stage run changes");
+  const commitResult = await input.runner.run("git", ["commit", "-m", input.message], {
+    cwd: input.workspacePath
+  });
+  await assertCommandSucceeded(commitResult, "commit run changes");
+  return true;
+}
+async function commitChangedFiles(input) {
+  if (input.files.length === 0) return;
+  const addResult = await input.runner.run("git", ["add", "--", ...input.files], { cwd: input.workspacePath });
+  await assertCommandSucceeded(addResult, "stage changed files");
+  const commitResult = await input.runner.run("git", ["commit", "-m", input.message], { cwd: input.workspacePath });
+  await assertCommandSucceeded(commitResult, "commit changed files");
+}
 async function pushBranch(input) {
   const result = await input.runner.run("git", ["push", "-u", input.remote, input.branchName], { cwd: input.workspacePath });
   await assertCommandSucceeded(result, "push run branch");
 }
 
-// src/codex.ts
+// src/result.ts
+var MAX_EXECUTOR_SUMMARY_LENGTH = 4e3;
+var DIRECT_SOURCE_CONTROL_COMMAND_PATTERN = /^\s*(?:[-*]\s*)?(?:`{1,3})?\s*(?:git\s+(?:add|commit|push|checkout)|gh\s+pr\s+create)\b/i;
+var GIT_HANDOFF_PATTERNS = [
+  DIRECT_SOURCE_CONTROL_COMMAND_PATTERN,
+  /\b(?:interactive user approval|permission system)\b.*\b(?:git|source-control|commit|push|pull request|pr)\b/i,
+  /\b(?:git|source-control|commit|push|pull request|pr)\b.*\b(?:interactive user approval|permission system)\b/i,
+  /(?=.*\b(?:git\s+(?:add|commit|push|checkout)|gh\s+pr\s+create|commit|push|pull request|pr)\b)(?=.*\b(?:approval|approve|manual|need|needs|cannot|can't|please|requires?|required|finish|next action|remaining work|blocked|blocker|permission)\b)/i
+];
+var HANDOFF_HEADING_PATTERN = /^(?:#{1,6}\s*)?(?:\*\*)?\s*(?:blocker|recommended next action|next action|remaining work|manual steps|to finish)\b.*\b(?:git|source-control|commit|push|pull request|pr)\b/i;
+function looksLikeGitHandoff(line) {
+  return GIT_HANDOFF_PATTERNS.some((pattern) => pattern.test(line));
+}
+function stripGitHandoffTail(line) {
+  if (!looksLikeGitHandoff(line)) return line;
+  return line.replace(/\s*(?:Blocker|Recommended next action|Next action|Remaining work|Manual steps|To finish)\s*:.*$/i, "").trimEnd();
+}
+function cleanOrFallbackExecutorSummary(input) {
+  const rawSummary = input.output.slice(-MAX_EXECUTOR_SUMMARY_LENGTH).replace(/\r\n/g, "\n");
+  const filteredLines = [];
+  for (const rawLine of rawSummary.split("\n")) {
+    const trimmed = rawLine.trim();
+    if (HANDOFF_HEADING_PATTERN.test(trimmed)) continue;
+    const withoutHandoffTail = stripGitHandoffTail(rawLine);
+    if (looksLikeGitHandoff(withoutHandoffTail)) continue;
+    if (withoutHandoffTail.trim().length === 0 && trimmed.length > 0) continue;
+    filteredLines.push(withoutHandoffTail);
+  }
+  const summary = filteredLines.join("\n").replace(/(?:^|\n)\s*(?:To finish|Manual steps):\s*\n```[^\n]*\n\s*```/gi, "\n").replace(/```[^\n]*\n\s*```/g, "").replace(/\n{3,}/g, "\n\n").trim();
+  if (summary.length > 0) return summary;
+  if (input.changedFiles.length === 0) {
+    return `${input.executorName} completed without file changes.`;
+  }
+  return `${input.executorName} changed ${input.changedFiles.length} file(s). Changed files: ${input.changedFiles.join(", ")}.`;
+}
+function createExecutorRunResult(input) {
+  const proposalId = `proposal_${input.runId}`;
+  const report = parseExecutorReport(input.output);
+  const summary = report ? renderExecutorReportSummary({ ...input, report }) : cleanOrFallbackExecutorSummary(input);
+  const suggestedChanges = input.changedFiles.length > 0 ? [
+    {
+      proposalId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceRunId: input.runId,
+      summary: `${input.executorName} changed ${input.changedFiles.length} file(s) on branch ${input.branchName}.`,
+      intents: [
+        {
+          intentId: `${proposalId}_create_pr`,
+          domain: "pull_request",
+          action: "create_pull_request",
+          summary: `Create a pull request for branch ${input.branchName}.`,
+          params: {
+            title: `OpenTag run ${input.runId}`,
+            body: [
+              "## Summary",
+              "",
+              summary
+            ].join("\n"),
+            head: input.branchName,
+            base: input.baseBranch ?? "main",
+            changedFiles: input.changedFiles,
+            risks: ["Creates a pull request from the executor-produced branch; review the diff before merging."],
+            executorConditions: ["isolated branch exists"]
+          }
+        },
+        {
+          intentId: `${proposalId}_link_branch`,
+          domain: "artifact_links",
+          action: "link_artifact",
+          summary: `Link the run branch ${input.branchName} to the work item.`,
+          params: { title: "Run branch", uri: input.branchName }
+        },
+        {
+          intentId: `${proposalId}_request_review`,
+          domain: "review",
+          action: "request_review",
+          summary: "Request human review of the generated code changes.",
+          params: { changedFiles: input.changedFiles }
+        }
+      ],
+      preconditions: ["The local branch was generated from the checkout state available to the runner."]
+    }
+  ] : void 0;
+  return {
+    conclusion: "success",
+    summary,
+    changedFiles: input.changedFiles,
+    artifacts: [
+      ...input.changedFiles.length > 0 ? [{ kind: "patch", title: "Run branch", uri: input.branchName }] : [],
+      ...input.extraArtifacts ?? []
+    ],
+    ...suggestedChanges ? { suggestedChanges } : {},
+    nextAction: input.changedFiles.length > 0 ? {
+      summary: "Review the proposed pull request action and reply `apply 1` if the branch should become a PR.",
+      hint: {
+        kind: "create_pull_request",
+        targetId: proposalId,
+        selectedIntentIds: [`${proposalId}_create_pr`]
+      }
+    } : "No file changes were detected."
+  };
+}
+
+// src/claude-code.ts
 function contextLines(context) {
   if (!context.length) return "No additional context pointers were provided.";
-  return context.map((pointer) => `- ${pointer.kind}: ${pointer.uri}`).join("\n");
+  return context.map((pointer) => `- ${contextPointerLabel2(pointer)}: ${pointer.uri}`).join("\n");
 }
 function buildPrompt(input) {
   return [
@@ -92,29 +429,35 @@ function buildPrompt(input) {
     "User request:",
     input.rawText,
     "",
+    ...renderContextPacketForPrompt(input.contextPacket),
+    ...input.contextPacket ? [""] : [],
     "Context pointers:",
     contextLines(input.context),
     "",
-    "Work autonomously but keep the change narrow. Run relevant verification if you modify files. End with a concise summary."
+    ...executorPolicyPromptLines()
   ].join("\n");
 }
-function createCodexExecutor(options = {}) {
+function createClaudeCodeExecutor(options = {}) {
   const runner = options.runner ?? nodeCommandRunner;
-  const codexCommand = options.codexCommand ?? "codex";
+  const claudeCommand = options.claudeCommand ?? "claude";
   return {
-    id: "codex",
-    displayName: "Codex Executor",
+    id: "claude-code",
+    displayName: "Claude Code Executor",
     async canRun(input) {
-      const codexVersion = await runner.run(codexCommand, ["--version"], { cwd: input.workspacePath });
-      if (codexVersion.exitCode !== 0) {
-        return { ready: false, reason: `Codex CLI is not available: ${codexVersion.stderr || codexVersion.stdout}` };
+      try {
+        const claudeVersion = await runner.run(claudeCommand, ["--version"], { cwd: input.workspacePath });
+        if (claudeVersion.exitCode !== 0) {
+          return { ready: false, reason: `Claude Code CLI is not available: ${claudeVersion.stderr || claudeVersion.stdout}` };
+        }
+      } catch (error) {
+        return { ready: false, reason: `Claude Code CLI is not available: ${error instanceof Error ? error.message : String(error)}` };
       }
       const gitStatus = await runner.run("git", ["status", "--porcelain"], { cwd: input.workspacePath });
       if (gitStatus.exitCode !== 0) {
         return { ready: false, reason: `Workspace is not a git checkout: ${gitStatus.stderr || gitStatus.stdout}` };
       }
       if (gitStatus.stdout.trim().length > 0) {
-        return { ready: false, reason: "Workspace has uncommitted changes; refusing to run Codex executor." };
+        return { ready: false, reason: "Workspace has uncommitted changes; refusing to run Claude Code executor." };
       }
       return { ready: true };
     },
@@ -125,30 +468,38 @@ function createCodexExecutor(options = {}) {
         message: `Creating isolated branch ${branchName}`,
         at: (/* @__PURE__ */ new Date()).toISOString()
       });
-      await createRunBranch({ runner, workspacePath: input.workspacePath, branchName });
+      await createRunBranch({
+        runner,
+        workspacePath: input.workspacePath,
+        branchName,
+        ...input.baseBranch ? { startPoint: input.baseBranch } : {}
+      });
       await sink.emit({
         type: "executor.progress",
-        message: "Starting codex exec",
+        message: "Starting claude --print",
         at: (/* @__PURE__ */ new Date()).toISOString()
       });
       const args = [
-        "exec",
-        "--cd",
-        input.workspacePath,
-        "--full-auto",
-        "--ephemeral",
+        "--print",
+        "--input-format",
+        "text",
+        "--output-format",
+        "text",
+        "--no-session-persistence",
         ...options.model ? ["--model", options.model] : [],
-        "-"
+        ...options.permissionMode ? ["--permission-mode", options.permissionMode] : [],
+        ...options.dangerouslySkipPermissions ? ["--dangerously-skip-permissions"] : []
       ];
-      const codexResult = await runner.run(codexCommand, args, {
+      const claudeResult = await runner.run(claudeCommand, args, {
         cwd: input.workspacePath,
         input: buildPrompt({
           runId: input.runId,
           rawText: input.command.rawText,
-          context: input.context
+          context: input.context,
+          contextPacket: input.contextPacket
         })
       });
-      await assertCommandSucceeded(codexResult, "codex exec");
+      await assertCommandSucceeded(claudeResult, "claude --print");
       const cleanedArtifacts = await cleanupInternalArtifacts({ runner, workspacePath: input.workspacePath });
       if (cleanedArtifacts.length > 0) {
         await sink.emit({
@@ -160,24 +511,396 @@ function createCodexExecutor(options = {}) {
       const files = await changedFiles({ runner, workspacePath: input.workspacePath });
       await sink.emit({
         type: "executor.completed",
-        message: `Codex executor completed with ${files.length} changed file(s)`,
+        message: `Claude Code executor completed with ${files.length} changed file(s)`,
         at: (/* @__PURE__ */ new Date()).toISOString()
       });
-      const output = codexResult.stdout.trim() || codexResult.stderr.trim() || "Codex completed without textual output.";
-      return {
-        conclusion: "success",
-        summary: output.slice(-4e3),
-        changedFiles: files,
-        artifacts: [{ title: "Run branch", uri: branchName }],
-        verification: [
-          {
-            command: "codex exec",
-            outcome: "passed",
-            excerpt: output.slice(-1e3)
+      const output = claudeResult.stdout.trim() || claudeResult.stderr.trim() || "Claude Code completed without textual output.";
+      return createExecutorRunResult({
+        executorName: "Claude Code",
+        runId: input.runId,
+        branchName,
+        ...input.baseBranch ? { baseBranch: input.baseBranch } : {},
+        output,
+        changedFiles: files
+      });
+    },
+    async cancel() {
+      return;
+    }
+  };
+}
+
+// src/codex.ts
+import { contextPointerLabel as contextPointerLabel3 } from "@opentag/core";
+
+// src/security.ts
+import { fileURLToPath } from "url";
+import { isAbsolute, relative, resolve } from "path";
+var DEFAULT_SAFE_ENV_NAMES = [
+  "CI",
+  "COLORTERM",
+  "CODEX_HOME",
+  "FORCE_COLOR",
+  "HOME",
+  "LANG",
+  "LOGNAME",
+  "NO_COLOR",
+  "PATH",
+  "PWD",
+  "SHELL",
+  "SSL_CERT_DIR",
+  "SSL_CERT_FILE",
+  "TERM",
+  "TMP",
+  "TMPDIR",
+  "TEMP",
+  "USER",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME"
+];
+var SAFE_ENV_PREFIXES = ["LC_"];
+var SENSITIVE_ENV_PATTERNS = [
+  /TOKEN/,
+  /SECRET/,
+  /PASSWORD/,
+  /PASS$/,
+  /API[_-]?KEY/,
+  /CREDENTIAL/,
+  /COOKIE/,
+  /SESSION/,
+  /AUTH/,
+  /^AWS_/,
+  /^AZURE_/,
+  /^GCP_/,
+  /^GOOGLE_/,
+  /^OPENAI_/,
+  /^ANTHROPIC_/,
+  /^SLACK_/,
+  /^GITHUB_TOKEN$/,
+  /^GH_TOKEN$/,
+  /^SSH_/
+];
+var HIGH_RISK_TEXT_PATTERNS = [
+  {
+    code: "prompt.instruction_override",
+    pattern: /\b(ignore|disregard|forget)\s+(all\s+)?(previous|prior|system|developer|safety)\s+instructions\b/i,
+    message: "Request contains an instruction override pattern commonly used in prompt injection."
+  },
+  {
+    code: "prompt.secret_exfiltration",
+    pattern: /\b(print|dump|show|reveal|exfiltrate|send|upload|post|copy)\b[\s\S]{0,100}\b(secret|token|password|api[\s_-]?key|credential|environment variables?|env vars?)\b/i,
+    message: "Request appears to ask the runner to expose secrets or environment variables."
+  },
+  {
+    code: "prompt.sensitive_file_access",
+    pattern: /\b(cat|open|read|print|dump)\b[\s\S]{0,80}(~\/\.ssh|~\/\.aws|\.env\b|id_rsa|known_hosts|credentials\b)/i,
+    message: "Request appears to ask the runner to read sensitive local credential files."
+  }
+];
+function securityMode(policy) {
+  return policy?.mode ?? "enforce";
+}
+function isPathInside(childPath, parentPath) {
+  const child = resolve(childPath);
+  const parent = resolve(parentPath);
+  const pathFromParent = relative(parent, child);
+  return pathFromParent === "" || !pathFromParent.startsWith("..") && !isAbsolute(pathFromParent);
+}
+function fileContextPath(pointer, workspacePath) {
+  if (pointer.kind !== "file") return null;
+  if (pointer.uri.startsWith("file://")) {
+    return fileURLToPath(pointer.uri);
+  }
+  if (isAbsolute(pointer.uri)) {
+    return pointer.uri;
+  }
+  return resolve(workspacePath, pointer.uri);
+}
+function hasPermission(permissions, scope) {
+  return permissions?.some((permission) => permission.scope === scope) ?? false;
+}
+function needsWritePermission(command, executorId) {
+  if (executorId === "echo") return false;
+  return command.intent === "fix" || command.intent === "run";
+}
+function scanTextForHighRiskPatterns(input) {
+  const sources = [
+    { label: "command", text: input.command.rawText },
+    ...input.context.filter((pointer) => pointer.kind === "text").map((pointer) => ({ label: pointer.title ?? "text context", text: pointer.uri }))
+  ];
+  const findings = [];
+  for (const source of sources) {
+    for (const rule of HIGH_RISK_TEXT_PATTERNS) {
+      if (rule.pattern.test(source.text)) {
+        findings.push({
+          code: rule.code,
+          severity: "block",
+          message: `${rule.message} Source: ${source.label}.`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function assessRunnerSecurity(input) {
+  const mode = securityMode(input.policy);
+  if (mode === "off") {
+    return { allowed: true, mode, findings: [] };
+  }
+  const findings = [];
+  if (!isAbsolute(input.workspacePath)) {
+    findings.push({
+      code: "workspace.relative_path",
+      severity: "block",
+      message: "Workspace path must be absolute before a local executor can run."
+    });
+  }
+  const workspacePath = resolve(input.workspacePath);
+  const executionPath = resolve(input.executionPath ?? input.workspacePath);
+  if (input.policy?.allowedWorkspaceRoot && !isPathInside(workspacePath, input.policy.allowedWorkspaceRoot)) {
+    findings.push({
+      code: "workspace.outside_allowed_root",
+      severity: "block",
+      message: "Workspace path is outside the configured allowed workspace root."
+    });
+  }
+  if (input.policy?.allowedWorkspaceRoot && !isPathInside(executionPath, input.policy.allowedWorkspaceRoot)) {
+    findings.push({
+      code: "execution.outside_allowed_root",
+      severity: "block",
+      message: "Execution path is outside the configured allowed workspace root."
+    });
+  }
+  for (const pointer of input.context) {
+    const filePath = fileContextPath(pointer, workspacePath);
+    if (filePath && !isPathInside(filePath, workspacePath)) {
+      findings.push({
+        code: "context.file_outside_workspace",
+        severity: "block",
+        message: `File context is outside the mapped workspace: ${pointer.uri}`
+      });
+    }
+  }
+  if (needsWritePermission(input.command, input.executorId) && !hasPermission(input.permissions, "repo:write")) {
+    findings.push({
+      code: "permission.repo_write_required",
+      severity: "block",
+      message: "Write-capable commands require an explicit repo:write permission grant."
+    });
+  }
+  if (!input.policy?.allowUnsafePrompts) {
+    findings.push(...scanTextForHighRiskPatterns({ command: input.command, context: input.context }));
+  }
+  const hasBlockingFinding = findings.some((finding) => finding.severity === "block");
+  return {
+    allowed: mode === "audit" || !hasBlockingFinding,
+    mode,
+    findings
+  };
+}
+function isSensitiveEnvName(name) {
+  const upperName = name.toUpperCase();
+  return SENSITIVE_ENV_PATTERNS.some((pattern) => pattern.test(upperName));
+}
+function isSafeEnvName(name, policy) {
+  const upperName = name.toUpperCase();
+  const safeNames = new Set([...DEFAULT_SAFE_ENV_NAMES, ...policy?.extraSafeEnv ?? []].map((envName) => envName.toUpperCase()));
+  return safeNames.has(upperName) || SAFE_ENV_PREFIXES.some((prefix) => upperName.startsWith(prefix));
+}
+function scrubEnvironment(env = process.env, policy) {
+  if (securityMode(policy) === "off") return { ...env };
+  const scrubbed = {};
+  for (const [name, value] of Object.entries(env)) {
+    if (typeof value !== "string") continue;
+    if (isSensitiveEnvName(name)) continue;
+    if (!isSafeEnvName(name, policy)) continue;
+    scrubbed[name] = value;
+  }
+  return scrubbed;
+}
+function formatSecurityAssessment(assessment) {
+  if (assessment.findings.length === 0) {
+    return `OpenTag runner security assessment passed in ${assessment.mode} mode.`;
+  }
+  const prefix = assessment.allowed ? `OpenTag runner security assessment reported ${assessment.findings.length} finding(s) in ${assessment.mode} mode.` : "OpenTag runner security blocked this run.";
+  const details = assessment.findings.map((finding) => `${finding.code}: ${finding.message}`).join(" ");
+  return `${prefix} ${details}`;
+}
+
+// src/codex.ts
+function contextLines2(context) {
+  if (!context.length) return "No additional context pointers were provided.";
+  return context.map((pointer) => `- ${contextPointerLabel3(pointer)}: ${pointer.uri}`).join("\n");
+}
+function buildPrompt2(input) {
+  return [
+    "You are executing an OpenTag run in a local checkout.",
+    `Run ID: ${input.runId}`,
+    "",
+    "User request:",
+    input.rawText,
+    "",
+    ...renderContextPacketForPrompt(input.contextPacket),
+    ...input.contextPacket ? [""] : [],
+    "Context pointers:",
+    contextLines2(input.context),
+    "",
+    ...executorPolicyPromptLines()
+  ].join("\n");
+}
+function createCodexExecutor(options = {}) {
+  const runner = options.runner ?? nodeCommandRunner;
+  const codexCommand = options.codexCommand ?? "codex";
+  return {
+    id: "codex",
+    displayName: "Codex Executor",
+    async canRun(input) {
+      const codexVersion = await runner.run(codexCommand, ["--version"], { cwd: input.workspacePath });
+      if (codexVersion.exitCode !== 0) {
+        return { ready: false, reason: `Codex CLI is not available: ${codexVersion.stderr || codexVersion.stdout}` };
+      }
+      const gitRepo = await runner.run("git", ["rev-parse", "--show-toplevel"], { cwd: input.workspacePath });
+      if (gitRepo.exitCode !== 0) {
+        return { ready: false, reason: `Workspace is not a git checkout: ${gitRepo.stderr || gitRepo.stdout}` };
+      }
+      const baseBranch = input.baseBranch ?? "main";
+      const baseRef = await runner.run("git", ["rev-parse", "--verify", `${baseBranch}^{commit}`], {
+        cwd: input.workspacePath
+      });
+      if (baseRef.exitCode !== 0) {
+        return { ready: false, reason: `Base branch '${baseBranch}' is not available: ${baseRef.stderr || baseRef.stdout}` };
+      }
+      return { ready: true };
+    },
+    async run(input, sink) {
+      const security = options.security;
+      const worktreePath = worktreePathForRun({
+        workspacePath: input.workspacePath,
+        runId: input.runId,
+        ...input.worktreeRoot ? { worktreeRoot: input.worktreeRoot } : {}
+      });
+      const assessment = assessRunnerSecurity({
+        executorId: "codex",
+        workspacePath: input.workspacePath,
+        executionPath: worktreePath,
+        command: input.command,
+        context: input.context,
+        ...input.permissions ? { permissions: input.permissions } : {},
+        ...security ? { policy: security } : {}
+      });
+      if (assessment.findings.length > 0) {
+        await sink.emit({
+          type: assessment.allowed ? "executor.progress" : "executor.failed",
+          message: formatSecurityAssessment(assessment),
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      if (!assessment.allowed) {
+        return {
+          conclusion: "needs_human",
+          summary: formatSecurityAssessment(assessment),
+          nextAction: "Review the request and rerun with a narrower prompt or an explicit local policy override if appropriate."
+        };
+      }
+      const branchName = branchNameForRun(input.runId);
+      const baseBranch = input.baseBranch ?? "main";
+      const keepWorktree = input.keepWorktree ?? "on_failure";
+      let completed = false;
+      let changedFileCount;
+      await sink.emit({
+        type: "executor.started",
+        message: `Creating isolated worktree ${worktreePath} on ${branchName}`,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      try {
+        await createRunWorktree({
+          runner,
+          workspacePath: input.workspacePath,
+          worktreePath,
+          branchName,
+          baseBranch
+        });
+        await sink.emit({
+          type: "executor.progress",
+          message: "Starting codex exec",
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const args = [
+          "exec",
+          "--cd",
+          worktreePath,
+          "--full-auto",
+          "--ephemeral",
+          ...options.model ? ["--model", options.model] : [],
+          "-"
+        ];
+        const codexResult = await runner.run(codexCommand, args, {
+          cwd: worktreePath,
+          env: scrubEnvironment(void 0, security),
+          input: buildPrompt2({
+            runId: input.runId,
+            rawText: input.command.rawText,
+            context: input.context,
+            contextPacket: input.contextPacket
+          })
+        });
+        await assertCommandSucceeded(codexResult, "codex exec");
+        const cleanedArtifacts = await cleanupInternalArtifacts({ runner, workspacePath: worktreePath });
+        if (cleanedArtifacts.length > 0) {
+          await sink.emit({
+            type: "executor.progress",
+            message: `Cleaned internal artifacts: ${cleanedArtifacts.join(", ")}`,
+            at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        const files = await changedFiles({ runner, workspacePath: worktreePath });
+        changedFileCount = files.length;
+        if (files.length > 0) {
+          await sink.emit({
+            type: "executor.progress",
+            message: `Committing ${files.length} changed file(s) to ${branchName}`,
+            at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          await commitRunChanges({
+            runner,
+            workspacePath: worktreePath,
+            message: `OpenTag run ${input.runId}`
+          });
+        }
+        completed = true;
+        await sink.emit({
+          type: "executor.completed",
+          message: `Codex executor completed with ${files.length} changed file(s)`,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const output = codexResult.stdout.trim() || codexResult.stderr.trim() || "Codex completed without textual output.";
+        return createExecutorRunResult({
+          executorName: "Codex",
+          runId: input.runId,
+          branchName,
+          ...input.baseBranch ? { baseBranch: input.baseBranch } : {},
+          output,
+          changedFiles: files,
+          extraArtifacts: keepWorktree === "always" ? [{ title: "Run worktree", uri: worktreePath }] : []
+        });
+      } finally {
+        const shouldRemove = keepWorktree === "never" || keepWorktree === "on_failure" && completed;
+        if (shouldRemove) {
+          try {
+            await removeRunWorktree({ runner, workspacePath: input.workspacePath, worktreePath });
+            if (completed && changedFileCount === 0) {
+              await deleteRunBranch({ runner, workspacePath: input.workspacePath, branchName });
+            }
+          } catch (error) {
+            await sink.emit({
+              type: "executor.progress",
+              message: `Could not clean up run worktree or branch for ${worktreePath}: ${error instanceof Error ? error.message : String(error)}`,
+              at: (/* @__PURE__ */ new Date()).toISOString()
+            });
           }
-        ],
-        nextAction: files.length > 0 ? "Review the local branch and create a pull request." : "No file changes were detected."
-      };
+        }
+      }
     },
     async cancel() {
       return;
@@ -216,7 +939,11 @@ function createEchoExecutor() {
             outcome: "passed",
             excerpt: input.command.rawText
           }
-        ]
+        ],
+        nextAction: {
+          summary: "No external state change is suggested for the echo executor result.",
+          hint: { kind: "none" }
+        }
       };
     },
     async cancel() {
@@ -225,17 +952,31 @@ function createEchoExecutor() {
   };
 }
 export {
+  DEFAULT_SAFE_ENV_NAMES,
+  STATUS_PORCELAIN_Z_ARGS,
   assertCommandSucceeded,
+  assessRunnerSecurity,
   branchNameForRun,
   changedFiles,
   cleanupInternalArtifacts,
+  commitChangedFiles,
+  commitRunChanges,
+  createClaudeCodeExecutor,
   createCodexExecutor,
   createEchoExecutor,
+  createExecutorRunResult,
   createRunBranch,
+  createRunWorktree,
+  deleteRunBranch,
+  formatSecurityAssessment,
   isInternalArtifactPath,
   nodeCommandRunner,
   parseChangedFiles,
   parseStatusEntries,
-  pushBranch
+  pushBranch,
+  removeRunWorktree,
+  renderContextPacketForPrompt,
+  scrubEnvironment,
+  worktreePathForRun
 };
 //# sourceMappingURL=index.js.map