@ai-development-environment/control-agent 0.0.88 → 0.0.89

package/dist/control-agent.js

@@ -8321,9 +8321,64 @@ function buildCoverageReportPayload(input) {
   };
 }
 
+// ../agent-contract/src/cli-health.ts
+var CLI_HEALTH_JOB_KIND = "cli.health";
+var CLI_HEALTH_MAX_CHECKS = 27;
+var CLI_HEALTH_MAX_OUTPUT_BYTES = 32 * 1024;
+var CLI_HEALTH_CHECK_TIMEOUT_MS = 15e3;
+function objectValue12(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+  return value;
+}
+function checkDefinition(value, index) {
+  const name = `cli.health checks[${index}]`;
+  const check = objectValue12(value, name);
+  const allowed = /* @__PURE__ */ new Set(["id", "name", "command", "builtIn"]);
+  const unexpected = Object.keys(check).find((key) => !allowed.has(key));
+  if (unexpected) throw new Error(`Unexpected ${name} field: ${unexpected}`);
+  for (const field of ["id", "name", "command"]) {
+    if (typeof check[field] !== "string" || check[field].length === 0) {
+      throw new Error(`${name}.${field} must be a non-empty string`);
+    }
+  }
+  if (typeof check.builtIn !== "boolean") {
+    throw new Error(`${name}.builtIn must be a boolean`);
+  }
+  if (check.id.length > 100)
+    throw new Error(`${name}.id is too long`);
+  if (check.name.length > 100)
+    throw new Error(`${name}.name is too long`);
+  if (check.command.length > 4096 || check.command.includes("\0")) {
+    throw new Error(`${name}.command is invalid`);
+  }
+  return check;
+}
+function parseCliHealthJobPayload(value) {
+  const payload = objectValue12(value, "cli.health payload");
+  const unexpected = Object.keys(payload).find((key) => key !== "checks");
+  if (unexpected)
+    throw new Error(`Unexpected cli.health payload field: ${unexpected}`);
+  if (!Array.isArray(payload.checks)) {
+    throw new Error("cli.health payload.checks must be an array");
+  }
+  if (payload.checks.length > CLI_HEALTH_MAX_CHECKS) {
+    throw new Error(
+      `cli.health supports at most ${CLI_HEALTH_MAX_CHECKS} checks`
+    );
+  }
+  const checks = payload.checks.map(checkDefinition);
+  if (new Set(checks.map((check) => check.id)).size !== checks.length) {
+    throw new Error("cli.health check identifiers must be unique");
+  }
+  return { checks };
+}
+
 // src/inventory.ts
 var AGENT_VERSION = process.env.CONTROL_AGENT_VERSION ?? "0.1.0";
 var PORTABLE_AGENT_CAPABILITIES = [
+  CLI_HEALTH_JOB_KIND,
   COMMAND_RUN_JOB_KIND,
   CCUSAGE_REPORT_JOB_KIND,
   ...CODEBASE_JOB_KINDS,
@@ -8390,12 +8445,17 @@ function captureCommand(options) {
       timedOut: !options.signal.aborted,
       cancelled: options.signal.aborted,
       stdout: "",
-      stderr: ""
+      stderr: "",
+      outputTruncated: false
     });
   }
   return new Promise((resolve8, reject) => {
-    let stdout = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let retainedBytes = 0;
+    let outputTruncated = false;
     let timedOut = false;
     let cancelled = false;
     let settled = false;
@@ -8415,12 +8475,23 @@ function captureCommand(options) {
       // stop the entire command tree instead of only the immediate Git process.
       detached
     });
-    const append = (current, chunk) => `${current}${String(chunk)}`.slice(0, MAX_OUTPUT_BYTES);
+    const append = (chunks, chunk, streamBytes) => {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const remaining = Math.max(
+        0,
+        options.maxOutputBytes === void 0 ? MAX_OUTPUT_BYTES - streamBytes : options.maxOutputBytes - retainedBytes
+      );
+      const retained = bytes.subarray(0, remaining);
+      if (retained.length) chunks.push(Buffer.from(retained));
+      retainedBytes += retained.length;
+      outputTruncated ||= retained.length < bytes.length;
+      return streamBytes + retained.length;
+    };
     child.stdout?.on("data", (chunk) => {
-      stdout = append(stdout, chunk);
+      stdoutBytes = append(stdoutChunks, chunk, stdoutBytes);
     });
     child.stderr?.on("data", (chunk) => {
-      stderr = append(stderr, chunk);
+      stderrBytes = append(stderrChunks, chunk, stderrBytes);
     });
     const sendSignal = (signal) => {
       if (detached && child.pid) {
@@ -8428,12 +8499,18 @@ function captureCommand(options) {
           process.kill(-child.pid, signal);
           return;
         } catch (error) {
-          if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+          if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH" && error.code !== "EPERM") {
             throw error;
           }
         }
       }
-      child.kill(signal);
+      try {
+        child.kill(signal);
+      } catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH" && error.code !== "EPERM") {
+          throw error;
+        }
+      }
     };
     const terminate = () => {
       if (child.exitCode !== null || child.killed) return;
@@ -8473,8 +8550,9 @@ function captureCommand(options) {
         signal,
         timedOut,
         cancelled,
-        stdout,
-        stderr
+        stdout: Buffer.concat(stdoutChunks, stdoutBytes).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks, stderrBytes).toString("utf8"),
+        outputTruncated
       });
     });
   });
@@ -11760,6 +11838,164 @@ var importCoverageReport = async (payloadValue, timeoutMs, signal, onLog) => {
   };
 };
 
+// src/handlers/cli-health.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { homedir as homedir3 } from "node:os";
+var CONCURRENCY = 4;
+var ANSI_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+var CONTROL_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001A\u001C-\u001F\u007F]/g;
+function clean(value) {
+  return value.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "");
+}
+function lineBufferedOutput(value) {
+  return value.replace(/\r?\n$/, "");
+}
+function appendWithinLimit(current, line, retainedBytes) {
+  const addition = current ? `
+${line}` : line;
+  if (!addition) return { value: current, retainedBytes, truncated: false };
+  const remaining = CLI_HEALTH_MAX_OUTPUT_BYTES - retainedBytes;
+  if (remaining <= 0) return { value: current, retainedBytes, truncated: true };
+  const bytes = Buffer2.from(addition, "utf8");
+  if (bytes.length <= remaining)
+    return {
+      value: current + addition,
+      retainedBytes: retainedBytes + bytes.length,
+      truncated: false
+    };
+  let end = remaining;
+  let retained = "";
+  while (end > 0) {
+    try {
+      retained = new TextDecoder("utf-8", { fatal: true }).decode(
+        bytes.subarray(0, end)
+      );
+      break;
+    } catch {
+      end -= 1;
+    }
+  }
+  return {
+    value: current + retained,
+    retainedBytes: retainedBytes + Buffer2.byteLength(retained, "utf8"),
+    truncated: true
+  };
+}
+async function reportOutput(check, stdout, stderr, createdAt, onLog) {
+  for (const [stream, message] of [
+    ["STDOUT", stdout],
+    ["STDERR", stderr]
+  ]) {
+    if (!message) continue;
+    try {
+      await onLog({
+        sequence: 0,
+        stream,
+        message: `[${check.name}] ${message}`,
+        createdAt
+      });
+    } catch (error) {
+      console.error(
+        `Could not append CLI health log for ${check.id}:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+}
+async function runCliHealthCheck(check, signal, onLog, options = {}) {
+  const started = Date.now();
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const shell = options.shell || process.env.SHELL || "/bin/sh";
+    const timeoutMs = options.timeoutMs ?? CLI_HEALTH_CHECK_TIMEOUT_MS;
+    const result = await captureCommand({
+      command: shell,
+      args: ["-lc", check.command],
+      cwd: options.cwd || homedir3(),
+      timeoutMs,
+      signal,
+      maxOutputBytes: CLI_HEALTH_MAX_OUTPUT_BYTES
+    });
+    const capturedStdout = appendWithinLimit(
+      "",
+      clean(lineBufferedOutput(result.stdout)),
+      0
+    );
+    const systemError = result.timedOut ? `Process exceeded its ${Math.round(timeoutMs / 1e3)} second timeout` : result.cancelled ? "Cancellation requested" : "";
+    const capturedStderr = appendWithinLimit(
+      "",
+      [clean(lineBufferedOutput(result.stderr)), systemError].filter(Boolean).join("\n"),
+      capturedStdout.retainedBytes
+    );
+    const stdout = capturedStdout.value;
+    const stderr = capturedStderr.value;
+    const outputTruncated = result.outputTruncated || capturedStdout.truncated || capturedStderr.truncated;
+    await reportOutput(check, stdout, stderr, checkedAt, onLog);
+    return {
+      ...check,
+      exitCode: result.exitCode,
+      stdout,
+      stderr,
+      durationMs: Date.now() - started,
+      checkedAt,
+      timedOut: result.timedOut,
+      launchError: null,
+      outputTruncated
+    };
+  } catch (error) {
+    const launchError = clean(
+      error instanceof Error ? error.message : String(error)
+    );
+    await reportOutput(check, "", launchError, checkedAt, onLog);
+    return {
+      ...check,
+      exitCode: null,
+      stdout: "",
+      stderr: launchError,
+      durationMs: Date.now() - started,
+      checkedAt,
+      timedOut: false,
+      launchError,
+      outputTruncated: false
+    };
+  }
+}
+async function runCliHealth(payload, _timeoutMs, signal, onLog) {
+  const { checks } = parseCliHealthJobPayload(payload);
+  const results = new Array(checks.length);
+  let next = 0;
+  let logSequence = 0;
+  let logChain = Promise.resolve();
+  const appendSweepLog = (log) => {
+    const sequenced = { ...log, sequence: logSequence++ };
+    const task = logChain.then(() => onLog(sequenced));
+    logChain = task.catch(() => void 0);
+    return task;
+  };
+  const worker = async () => {
+    while (!signal.aborted) {
+      const index = next++;
+      if (index >= checks.length) return;
+      results[index] = await runCliHealthCheck(
+        checks[index],
+        signal,
+        appendSweepLog
+      );
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(CONCURRENCY, checks.length) }, worker)
+  );
+  await logChain;
+  return {
+    exitCode: signal.aborted ? null : 0,
+    signal: null,
+    timedOut: false,
+    cancelled: signal.aborted,
+    checks: results.filter(Boolean)
+  };
+}
+
 // src/handlers/signing.ts
 import { createHash as createHash6, randomUUID as randomUUID2, X509Certificate } from "node:crypto";
 import {
@@ -11771,18 +12007,18 @@ import {
   stat as stat4,
   writeFile as writeFile4
 } from "node:fs/promises";
-import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
+import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
 import { basename as basename3, join as join5, relative as relative5, sep as sep5 } from "node:path";
 var PROFILE_DIRECTORIES = [
   join5(
-    homedir3(),
+    homedir4(),
     "Library",
     "Developer",
     "Xcode",
     "UserData",
     "Provisioning Profiles"
   ),
-  join5(homedir3(), "Library", "MobileDevice", "Provisioning Profiles")
+  join5(homedir4(), "Library", "MobileDevice", "Provisioning Profiles")
 ];
 var PROFILE_EXTENSIONS = [".mobileprovision", ".provisionprofile"];
 function text(value) {
@@ -12320,11 +12556,11 @@ var deleteSigningIdentity = async (payload, timeoutMs, signal) => {
 };
 
 // src/handlers/ccusage.ts
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer as Buffer3 } from "node:buffer";
 
 // src/executable-lookup.ts
 import { accessSync, constants } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { delimiter, dirname as dirname3, join as join6 } from "node:path";
 function isExecutable(path) {
   try {
@@ -12335,7 +12571,7 @@ function isExecutable(path) {
   }
 }
 function toolDirectories(options = {}) {
-  const home = options.home ?? homedir4();
+  const home = options.home ?? homedir5();
   const platform2 = options.platform ?? process.platform;
   return [
     join6(home, ".local", "bin"),
@@ -12524,7 +12760,7 @@ async function runCcusage(payload, timeoutMs, signal, onLog) {
         await onLog(log);
         return;
       }
-      const lineBytes = Buffer2.byteLength(log.message, "utf8") + 1;
+      const lineBytes = Buffer3.byteLength(log.message, "utf8") + 1;
       if (stdoutBytes + lineBytes > MAX_CCUSAGE_STDOUT_BYTES) {
         exceededLimit = true;
         return;
@@ -12560,7 +12796,7 @@ import {
   stat as stat5,
   statfs
 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "node:path";
 var successfulProcess4 = {
   exitCode: 0,
@@ -12578,7 +12814,7 @@ function safeRelativePath3(value) {
 }
 async function configuredRoots(payload) {
   if (payload.mode === "DEFAULT") {
-    return [join7(homedir5(), "Library", "Developer", "Xcode", "DerivedData")];
+    return [join7(homedir6(), "Library", "Developer", "Xcode", "DerivedData")];
   }
   if (payload.mode === "ABSOLUTE") {
     if (!payload.path || !isAbsolute4(payload.path)) {
@@ -12662,7 +12898,7 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
 }
 async function scanDeviceSupport(signal) {
   const configuredRoot = join7(
-    process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir5(),
+    process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir6(),
     ...process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ? [] : ["Library", "Developer", "Xcode", "iOS DeviceSupport"]
   );
   signal.throwIfAborted();
@@ -12956,7 +13192,7 @@ async function collectAgentDiskSpace(configuration, signal) {
 
 // src/handlers/codebases.ts
 import { readdir as readdir4, realpath as realpath5, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { dirname as dirname5, join as join8, resolve as resolve5 } from "node:path";
 var successfulProcess5 = {
   exitCode: 0,
@@ -13213,7 +13449,7 @@ async function inspectCodebase(selectedFolder, timeoutMs, signal, expectedOrigin
 }
 var browseCodebaseDirectories = async (payload) => {
   const input = codebaseBrowsePayload(payload);
-  const homePath = await realpath5(homedir6());
+  const homePath = await realpath5(homedir7());
   const path = await realpath5(input.path ? resolve5(input.path) : homePath);
   if (!(await stat6(path)).isDirectory())
     throw new Error("Path is not a directory");
@@ -13841,7 +14077,7 @@ import {
   stat as stat7,
   writeFile as writeFile5
 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { dirname as dirname6, isAbsolute as isAbsolute5, join as join9, relative as relative6, resolve as resolve6, sep as sep6 } from "node:path";
 import { promisify } from "node:util";
 var executeFile = promisify(execFile);
@@ -13903,7 +14139,7 @@ async function directoryExists(path) {
   }
 }
 async function configuredTools(tools) {
-  const homePath = homedir7();
+  const homePath = homedir8();
   return Promise.all(
     AI_TOOLS.filter((tool) => tools.includes(tool)).map(async (tool) => ({
       tool,
@@ -13913,7 +14149,7 @@ async function configuredTools(tools) {
   );
 }
 function rootPath(location) {
-  const base = location.scope === "GLOBAL" ? homedir7() : location.folder;
+  const base = location.scope === "GLOBAL" ? homedir8() : location.folder;
   const parts = location.scope === "GLOBAL" ? GLOBAL_ROOTS[location.rootKind] : PROJECT_ROOTS[location.rootKind];
   const path = resolve6(base, ...parts);
   const normalizedBase = resolve6(base);
@@ -14232,7 +14468,7 @@ var applySkills = async (payload) => {
 
 // src/handlers/runs.ts
 import { readFile as readFile6, readdir as readdir6, stat as stat8 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { join as join10 } from "node:path";
 var successfulProcess7 = {
   exitCode: 0,
@@ -14291,7 +14527,7 @@ async function locateSessionFile(payload, home) {
 }
 var readRunSession = async (payload) => {
   const input = parseRunSessionReadPayload(payload);
-  const path = await locateSessionFile(input, homedir8());
+  const path = await locateSessionFile(input, homedir9());
   if (!path) {
     throw new Error(
       `No ${input.provider === "CLAUDE" ? "Claude" : "Codex"} session file found for this run on this agent`
@@ -17034,6 +17270,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
 
 // src/handlers/index.ts
 var handlers = {
+  [CLI_HEALTH_JOB_KIND]: runCliHealth,
   [COMMAND_RUN_JOB_KIND]: runCommand,
   [CCUSAGE_REPORT_JOB_KIND]: runCcusage,
   [BUILD_DATA_SCAN_JOB_KIND]: scanBuildData,
@@ -17204,7 +17441,7 @@ var JobExecutor = class {
 
 // src/codebase-monitor.ts
 var INSPECTION_TIMEOUT_MS = 3e4;
-var CONCURRENCY = 4;
+var CONCURRENCY2 = 4;
 var CodebaseMonitor = class {
   constructor(client2, repositoryCoordinator = new RepositoryCoordinator()) {
     this.client = client2;
@@ -17228,8 +17465,8 @@ var CodebaseMonitor = class {
       const codebases = configuration.codebases;
       const reports = [];
       const worktreeReports = [];
-      for (let index = 0; index < codebases.length; index += CONCURRENCY) {
-        const batch = codebases.slice(index, index + CONCURRENCY);
+      for (let index = 0; index < codebases.length; index += CONCURRENCY2) {
+        const batch = codebases.slice(index, index + CONCURRENCY2);
         const results = await Promise.all(
           batch.map(
             (codebase) => this.repositoryCoordinator.run(codebase.id, async () => {

package/package.json

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