@ai-development-environment/control-agent 0.0.80 → 0.0.82

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;
@@ -5031,6 +5031,26 @@ var AgentGraphQLClient = class {
       })
     };
   }
+  async ready() {
+    const response = await fetch(`${this.server}/api/auth/config`, {
+      headers: { ...this.headers },
+      signal: AbortSignal.timeout(this.requestTimeoutMs)
+    });
+    const raw = await response.text();
+    let body;
+    try {
+      body = raw ? JSON.parse(raw) : void 0;
+    } catch {
+      body = void 0;
+    }
+    if (!response.ok || typeof body?.mode !== "string") {
+      const detail = `HTTP ${response.status} ${response.statusText}`.trim();
+      throw new Error(
+        !body && raw ? `${detail}: ${raw.slice(0, 500)}` : detail
+      );
+    }
+    return { mode: body.mode };
+  }
   async request(query, variables) {
     const response = await fetch(`${this.server}/api/graphql`, {
       method: "POST",
@@ -14286,12 +14306,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,
@@ -14308,24 +14332,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, [
@@ -14342,7 +14453,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
   };
 }
@@ -14401,9 +14512,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;
@@ -14451,17 +14574,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
   };
 }
 
@@ -14576,7 +14697,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,
@@ -15576,7 +15697,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"] }
@@ -43515,7 +43636,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";
@@ -43604,7 +43725,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
     });
@@ -51304,7 +51425,7 @@ async function waitForServer(client2, timeoutMs, signal, dependencies) {
   let lastError;
   while (!signal.aborted && Date.now() < deadline) {
     try {
-      await client2.health();
+      await client2.ready();
       return;
     } catch (error) {
       lastError = error;
@@ -51346,10 +51467,15 @@ async function prepareDevelopmentAgent(options, signal, dependencies = defaultDe
     }
   } catch {
   }
-  const enrollment2 = await anonymousClient.createEnrollmentToken();
+  const enrollmentToken = options.enrollmentToken?.trim();
+  if (!enrollmentToken) {
+    throw new Error(
+      "The development agent needs a one-time enrollment token. Create one on the Agents page and set CONTROL_AGENT_DEV_ENROLLMENT_TOKEN."
+    );
+  }
   const response = await anonymousClient.enroll({
     ...inventory,
-    enrollmentToken: enrollment2.createAgentEnrollmentToken.token,
+    enrollmentToken,
     name
   });
   const config = {
@@ -51583,10 +51709,10 @@ async function doctor() {
           null,
           1e4,
           config?.headers
-        ).health();
+        ).ready();
         return {
-          ok: health.health === "ok",
-          detail: `${endpoint.kind} ${endpoint.server}: ${health.health}`
+          ok: true,
+          detail: `${endpoint.kind} ${endpoint.server}: ready (${health.mode})`
         };
       } catch (error) {
         return {
@@ -51633,7 +51759,8 @@ async function main() {
           {
             server,
             websocketServer: options["websocket-server"] ?? process.env.CONTROL_AGENT_DEV_WEBSOCKET_SERVER ?? process.env.NEXT_PUBLIC_AGENT_WS_URL,
-            name: options.name
+            name: options.name,
+            enrollmentToken: options["enrollment-token"] ?? process.env.CONTROL_AGENT_DEV_ENROLLMENT_TOKEN
           },
           controller.signal
         );

package/package.json

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