@ai-development-environment/control-agent 0.0.79 → 0.0.81

package/dist/control-agent.js

@@ -4184,7 +4184,7 @@ var require_cross_spawn = __commonJS({
     var cp3 = __require("child_process");
     var parse2 = require_parse();
     var enoent = require_enoent();
-    function spawn8(command3, args, options) {
+    function spawn9(command3, args, options) {
       const parsed = parse2(command3, args, options);
       const spawned = cp3.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -4196,8 +4196,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module.exports = spawn8;
-    module.exports.spawn = spawn8;
+    module.exports = spawn9;
+    module.exports.spawn = spawn9;
     module.exports.sync = spawnSync2;
     module.exports._parse = parse2;
     module.exports._enoent = enoent;
@@ -6106,6 +6106,7 @@ function codebaseGitOperationPayload(value) {
 // ../agent-contract/src/worktrees.ts
 var WORKTREE_INSPECT_JOB_KIND = "worktree.inspect";
 var WORKTREE_OPERATION_JOB_KIND = "worktree.operation";
+var WORKTREE_COMMIT_JOB_KIND = "worktree.commit";
 var WORKTREE_AUTO_SYNC_JOB_KIND = "worktree.auto-sync";
 var WORKTREE_GIT_INSPECT_JOB_KIND = "worktree.git.inspect";
 var WORKTREE_GIT_OPERATION_JOB_KIND = "worktree.git.operation";
@@ -6119,6 +6120,7 @@ var WORKTREE_DIFF_ASSET_JOB_KIND = "worktree.diff.asset";
 var WORKTREE_JOB_KINDS = [
   WORKTREE_INSPECT_JOB_KIND,
   WORKTREE_OPERATION_JOB_KIND,
+  WORKTREE_COMMIT_JOB_KIND,
   WORKTREE_AUTO_SYNC_JOB_KIND,
   WORKTREE_GIT_INSPECT_JOB_KIND,
   WORKTREE_GIT_OPERATION_JOB_KIND,
@@ -6145,6 +6147,7 @@ var WORKTREE_OPERATIONS = [
   "SYNC",
   "REBASE",
   "CANCEL_REBASE",
+  "PULL",
   "PUSH",
   "RESET",
   "STASH_ALL",
@@ -6463,6 +6466,71 @@ function worktreeDeleteJobPayload(value) {
     expectedHeadSha
   };
 }
+function worktreeCommitJobPayload(value) {
+  const payload = objectValue4(value, "worktree commit payload");
+  const allowed = /* @__PURE__ */ new Set([
+    "codebaseId",
+    "folder",
+    "gitDirectory",
+    "expectedOrigin",
+    "baseBranch",
+    "message",
+    "signed",
+    "stageAll",
+    "paths"
+  ]);
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected) {
+    throw new Error(`Unexpected worktree commit payload field: ${unexpected}`);
+  }
+  const message = stringValue4(
+    payload.message,
+    "worktree commit payload.message"
+  );
+  if (!message.trim()) throw new Error("Commit message must not be blank");
+  if (message.length > 5e4) throw new Error("Commit message is too long");
+  if (payload.signed !== null && typeof payload.signed !== "boolean") {
+    throw new Error("worktree commit payload.signed must be a boolean or null");
+  }
+  if (typeof payload.stageAll !== "boolean") {
+    throw new Error("worktree commit payload.stageAll must be a boolean");
+  }
+  if (!Array.isArray(payload.paths) || payload.paths.length > 500) {
+    throw new Error("worktree commit payload.paths is invalid");
+  }
+  const paths = payload.paths.map(
+    (path, index) => safeRelativePath(path, `worktree commit payload.paths[${index}]`)
+  );
+  if (new Set(paths).size !== paths.length) {
+    throw new Error("worktree commit payload.paths must be unique");
+  }
+  if (!payload.stageAll && paths.length === 0) {
+    throw new Error("A partial commit requires at least one path");
+  }
+  return {
+    codebaseId: stringValue4(
+      payload.codebaseId,
+      "worktree commit payload.codebaseId"
+    ),
+    folder: stringValue4(payload.folder, "worktree commit payload.folder"),
+    gitDirectory: stringValue4(
+      payload.gitDirectory,
+      "worktree commit payload.gitDirectory"
+    ),
+    expectedOrigin: stringValue4(
+      payload.expectedOrigin,
+      "worktree commit payload.expectedOrigin"
+    ),
+    baseBranch: nullableString3(
+      payload.baseBranch,
+      "worktree commit payload.baseBranch"
+    ),
+    message,
+    signed: payload.signed,
+    stageAll: payload.stageAll,
+    paths
+  };
+}
 function worktreeJobPayload(value) {
   const payload = objectValue4(value, "worktree payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -14218,12 +14286,16 @@ import { tmpdir as tmpdir5 } from "node:os";
 import { join as join12 } from "node:path";
 
 // src/runs/git-checkpoint.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile2, spawn as spawn6 } from "node:child_process";
 import { copyFile, mkdtemp as mkdtemp4, rm as rm7 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join11 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync = promisify2(execFile2);
+var PATCH_LIMIT = 2e6;
+var SUMMARY_LIMIT = 24e4;
+var MANIFEST_LIMIT = 2e6;
+var TRUNCATION_RESERVE = 200;
 async function git2(cwd, args, env) {
   const result = await execFileAsync("git", args, {
     cwd,
@@ -14240,24 +14312,111 @@ async function optionalGit(cwd, args) {
     return null;
   }
 }
+function cappedGit(cwd, args, limit) {
+  const budget = limit - TRUNCATION_RESERVE;
+  return new Promise((resolve8, reject) => {
+    const child = spawn6("git", args, {
+      cwd,
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_OPTIONAL_LOCKS: "0"
+      },
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const chunks = [];
+    const errorChunks = [];
+    let collected = 0;
+    let errorCollected = 0;
+    let truncated = false;
+    let settled = false;
+    child.stdout.on("data", (chunk) => {
+      if (truncated) return;
+      const remaining = budget - collected;
+      if (chunk.length >= remaining) {
+        chunks.push(chunk.subarray(0, remaining));
+        collected = budget;
+        truncated = true;
+        child.stdout.destroy();
+        if (child.exitCode === null && !child.killed) child.kill("SIGTERM");
+        return;
+      }
+      chunks.push(chunk);
+      collected += chunk.length;
+    });
+    child.stderr.on("data", (chunk) => {
+      if (errorCollected >= 8192) return;
+      errorChunks.push(chunk);
+      errorCollected += chunk.length;
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    });
+    child.once("close", (exitCode) => {
+      if (settled) return;
+      settled = true;
+      if (!truncated && exitCode !== 0) {
+        const message = Buffer.concat(errorChunks).toString("utf8").trim() || `git ${args[0]} exited with code ${exitCode}`;
+        reject(new Error(message));
+        return;
+      }
+      const output = Buffer.concat(chunks).toString("utf8");
+      resolve8(
+        truncated ? `${output.trimEnd()}
+
+[Truncated after ${budget} bytes]` : output.trim()
+      );
+    });
+  });
+}
+async function optionalCappedGit(cwd, args, limit) {
+  try {
+    return await cappedGit(cwd, args, limit) || null;
+  } catch {
+    return null;
+  }
+}
+function manifestPayload(manifest) {
+  let value = manifest;
+  let json = JSON.stringify({ porcelainV2: value });
+  while (json.length > MANIFEST_LIMIT && value.length > 0) {
+    value = value.slice(
+      0,
+      Math.floor(value.length * MANIFEST_LIMIT / json.length) - 1
+    );
+    json = JSON.stringify({ porcelainV2: value });
+  }
+  return json;
+}
 async function compareGitCheckpoint(cwd, target2, current) {
   if (!target2.worktreeTree || !current.worktreeTree) {
     throw new Error("The worktree checkpoint is incomplete");
   }
-  const worktreePatch = await git2(cwd, [
-    "diff",
-    "--binary",
-    "--find-renames",
-    target2.worktreeTree,
-    current.worktreeTree
-  ]);
-  const indexPatch = target2.indexTree && current.indexTree ? await git2(cwd, [
-    "diff",
-    "--binary",
-    "--find-renames",
-    target2.indexTree,
-    current.indexTree
-  ]) : "";
+  const worktreePatch = await cappedGit(
+    cwd,
+    [
+      "diff",
+      "--binary",
+      "--find-renames",
+      target2.worktreeTree,
+      current.worktreeTree
+    ],
+    PATCH_LIMIT
+  );
+  const indexPatch = target2.indexTree && current.indexTree ? await cappedGit(
+    cwd,
+    [
+      "diff",
+      "--binary",
+      "--find-renames",
+      target2.indexTree,
+      current.indexTree
+    ],
+    PATCH_LIMIT
+  ) : "";
   const upstream = await optionalGit(cwd, ["rev-parse", "@{upstream}"]);
   const pushedCount = target2.headSha && upstream ? Number(
     await optionalGit(cwd, [
@@ -14274,7 +14433,7 @@ ${worktreePatch}`,
       indexPatch && `Index changes that will be undone:
 
 ${indexPatch}`
-    ].filter(Boolean).join("\n\n").slice(0, 2e6),
+    ].filter(Boolean).join("\n\n").slice(0, PATCH_LIMIT),
     pushedCommitWarning: pushedCount > 0 ? `${pushedCount} commit${pushedCount === 1 ? "" : "s"} after this question appear on the upstream branch. Remote refs will not be changed.` : null
   };
 }
@@ -14333,9 +14492,21 @@ async function captureGitCheckpoint(cwd, runId, kind) {
   ]);
   const upstreamSha = await optionalGit(cwd, ["rev-parse", "@{upstream}"]);
   const indexTree = await optionalGit(cwd, ["write-tree"]);
-  const manifest = await optionalGit(cwd, ["status", "--porcelain=v2", "-z"]);
-  const staged = await optionalGit(cwd, ["diff", "--cached", "--stat", "HEAD"]);
-  const unstaged = await optionalGit(cwd, ["diff", "--stat", "HEAD"]);
+  const manifest = await optionalCappedGit(
+    cwd,
+    ["status", "--porcelain=v2", "-z"],
+    MANIFEST_LIMIT
+  );
+  const staged = await optionalCappedGit(
+    cwd,
+    ["diff", "--cached", "--stat", "HEAD"],
+    SUMMARY_LIMIT
+  );
+  const unstaged = await optionalCappedGit(
+    cwd,
+    ["diff", "--stat", "HEAD"],
+    SUMMARY_LIMIT
+  );
   const directory = await mkdtemp4(join11(tmpdir4(), "aide-run-index-"));
   let worktreeTree = null;
   let refName = null;
@@ -14383,17 +14554,15 @@ async function captureGitCheckpoint(cwd, runId, kind) {
     indexTree,
     worktreeTree,
     refName,
-    manifestJson: JSON.stringify({ porcelainV2: manifest ?? "" }),
+    manifestJson: manifestPayload(manifest ?? ""),
     diffSummary: [staged && `Staged:
 ${staged}`, unstaged && `Working tree:
 ${unstaged}`].filter(Boolean).join("\n\n") || null,
-    diffPatch: headSha && worktreeTree ? (await git2(cwd, [
-      "diff",
-      "--binary",
-      "--find-renames",
-      headSha,
-      worktreeTree
-    ])).slice(0, 2e6) || null : null
+    diffPatch: headSha && worktreeTree ? await cappedGit(
+      cwd,
+      ["diff", "--binary", "--find-renames", headSha, worktreeTree],
+      PATCH_LIMIT
+    ) || null : null
   };
 }
 
@@ -14508,7 +14677,7 @@ import { createWriteStream as createWriteStream2, watch } from "node:fs";
 import { mkdtemp as mkdtemp6, open as open2, readFile as readFile8, realpath as realpath8, rm as rm9, stat as stat10 } from "node:fs/promises";
 import { tmpdir as tmpdir6 } from "node:os";
 import { basename as basename5, dirname as dirname7, isAbsolute as isAbsolute6, join as join13, relative as relative7 } from "node:path";
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 var successfulProcess8 = {
   exitCode: 0,
   signal: null,
@@ -15164,10 +15333,16 @@ async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
   return { commits: commits.slice(0, 100), truncated: commits.length > 100 };
 }
 async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
-  const [commitResult, changeResult, branchResult] = await Promise.all([
+  const [commitResult, changeResult, branchResult, signingResult] = await Promise.all([
     inspectCommits(folder, baseBranch, timeoutMs, signal),
     inspectChanges(folder, timeoutMs, signal),
-    inspectBranchChanges(folder, baseBranch, timeoutMs, signal)
+    inspectBranchChanges(folder, baseBranch, timeoutMs, signal),
+    git3(
+      folder,
+      ["config", "--bool", "--get", "commit.gpgsign"],
+      timeoutMs,
+      signal
+    )
   ]);
   return {
     commits: commitResult.commits,
@@ -15175,7 +15350,8 @@ async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
     branchChanges: branchResult.changes,
     commitsTruncated: commitResult.truncated,
     changesTruncated: changeResult.truncated,
-    branchChangesTruncated: branchResult.truncated
+    branchChangesTruncated: branchResult.truncated,
+    commitSigningEnabled: signingResult.exitCode === 0 && signingResult.stdout.trim() === "true"
   };
 }
 async function baseMergeCommit(folder, baseBranch, timeoutMs, signal) {
@@ -15501,7 +15677,7 @@ function imageContentType(path) {
 }
 async function writeGitObject(folder, specification, destination, timeoutMs, signal) {
   await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn6(
+    const child = spawn7(
       "git",
       ["-C", folder, "cat-file", "blob", specification],
       { stdio: ["ignore", "pipe", "pipe"] }
@@ -15701,6 +15877,97 @@ var inspectWorktreeGit = async (payload, timeoutMs, signal) => {
     )
   };
 };
+var commitWorktree = async (payload, timeoutMs, signal) => {
+  const input = worktreeCommitJobPayload(payload);
+  const folder = await validateWorktree2(input, timeoutMs, signal);
+  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
+  if (input.stageAll) {
+    await runGit(["add", "--all"], "Could not stage worktree changes");
+  } else {
+    const current = await inspectChanges(folder, timeoutMs, signal);
+    const byPath = new Map(
+      current.changes.map((change) => [change.path, change])
+    );
+    const selected = input.paths.map((path) => {
+      const change = byPath.get(path);
+      if (!change) throw new Error(`Worktree change no longer exists: ${path}`);
+      return change;
+    });
+    const head = await git3(
+      folder,
+      ["rev-parse", "--verify", "HEAD"],
+      timeoutMs,
+      signal
+    );
+    if (head.exitCode === 0) {
+      await runGit(
+        ["reset", "--mixed", "HEAD", "--"],
+        "Could not reset the Git index"
+      );
+    } else {
+      await runGit(
+        ["rm", "--cached", "-r", "--ignore-unmatch", "."],
+        "Could not reset the Git index"
+      );
+    }
+    const selectedPaths = [
+      ...new Set(
+        selected.flatMap(
+          (change) => change.previousPath ? [change.previousPath, change.path] : [change.path]
+        )
+      )
+    ];
+    await runGit(
+      ["--literal-pathspecs", "add", "--all", "--", ...selectedPaths],
+      "Could not stage selected worktree changes"
+    );
+  }
+  const staged = await git3(
+    folder,
+    ["diff", "--cached", "--quiet", "--exit-code"],
+    timeoutMs,
+    signal
+  );
+  if (staged.exitCode === 0) throw new Error("No staged changes to commit");
+  if (staged.exitCode !== 1)
+    requireSuccess3(staged, "Could not inspect staged changes");
+  let signed = input.signed;
+  if (signed === null) {
+    const configured = await git3(
+      folder,
+      ["config", "--bool", "--get", "commit.gpgsign"],
+      timeoutMs,
+      signal
+    );
+    signed = configured.exitCode === 0 && configured.stdout.trim() === "true";
+  }
+  await runGit(
+    ["commit", signed ? "--gpg-sign" : "--no-gpg-sign", "-m", input.message],
+    "Commit failed"
+  );
+  const sha = runGit(["rev-parse", "HEAD"], "Could not read the new commit");
+  const subject = runGit(
+    ["log", "-1", "--format=%s"],
+    "Could not read the new commit subject"
+  );
+  const [shaResult, subjectResult] = await Promise.all([sha, subject]);
+  return {
+    ...successfulProcess8,
+    commit: {
+      sha: shaResult.stdout.trim(),
+      subject: subjectResult.stdout.trim(),
+      signed
+    },
+    worktree: await inspectWorktreeItem(
+      folder,
+      folder,
+      input.baseBranch,
+      false,
+      Math.min(timeoutMs, 3e4),
+      signal
+    )
+  };
+};
 var operateWorktreeGit = async (payload, timeoutMs, signal) => {
   const input = worktreeGitOperationPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
@@ -16456,6 +16723,14 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       await runGit(["rebase", "--abort"], "Could not cancel rebase");
       break;
     }
+    case "PULL": {
+      if (!branch || !upstream)
+        throw new Error("Pull requires a branch with an upstream");
+      const remote = upstream.split("/")[0] || "origin";
+      await runGit(["fetch", remote], `Could not fetch ${remote}`);
+      await runGit(["merge", "--ff-only", "@{upstream}"], "Pull failed");
+      break;
+    }
     case "PUSH":
       if (!branch) throw new Error("Push requires a branch");
       await runGit(
@@ -16735,6 +17010,7 @@ var handlers = {
   [WORKTREE_INSPECT_JOB_KIND]: inspectWorktree,
   [WORKTREE_AUTO_SYNC_JOB_KIND]: autoSyncWorktree,
   [WORKTREE_BRANCH_JOB_KIND]: branchWorktree,
+  [WORKTREE_COMMIT_JOB_KIND]: commitWorktree,
   [WORKTREE_MOVE_PUSH_JOB_KIND]: pushMovedWorktree,
   [WORKTREE_MOVE_CHECKOUT_JOB_KIND]: checkoutMovedWorktree,
   [WORKTREE_DELETE_JOB_KIND]: deleteWorktree,
@@ -43340,7 +43616,7 @@ var ClaudeAdapter = class {
 // src/runs/codex-adapter.ts
 import {
   execFile as execFile3,
-  spawn as spawn7
+  spawn as spawn8
 } from "node:child_process";
 import { mkdtemp as mkdtemp7, rm as rm12, writeFile as writeFile8 } from "node:fs/promises";
 import { tmpdir as tmpdir7 } from "node:os";
@@ -43429,7 +43705,7 @@ var CodexAppServer = class {
     const executable = this.executable();
     const modelCatalogPath = await this.createBundledModelCatalog(executable);
     const modelCatalogDirectory = this.modelCatalogDirectory;
-    const child = spawn7(executable, codexAppServerArgs(modelCatalogPath), {
+    const child = spawn8(executable, codexAppServerArgs(modelCatalogPath), {
       stdio: ["pipe", "pipe", "pipe"],
       env: process.env
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-development-environment/control-agent",
-  "version": "0.0.79",
+  "version": "0.0.81",
   "description": "Control agent for the AI Development Environment",
   "license": "MIT",
   "repository": {