@integrity-labs/agt-cli 0.27.73 → 0.27.75

package/dist/bin/agt.js

@@ -28,7 +28,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-WBT4UEOY.js";
+} from "../chunk-AWAKTFWY.js";
 import {
   CHANNEL_REGISTRY,
   DEPLOYMENT_TEMPLATES,
@@ -4930,7 +4930,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.27.73" : "dev";
+var cliVersion = true ? "0.27.75" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -5853,7 +5853,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.27.73" : "dev";
+var cliVersion2 = true ? "0.27.75" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-WBT4UEOY.js → chunk-AWAKTFWY.js}

@@ -7488,4 +7488,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-WBT4UEOY.js.map
+//# sourceMappingURL=chunk-AWAKTFWY.js.map

package/dist/{chunk-7YM2F3DG.js → chunk-VTAXNSGS.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-XWVM4KPK.js";
 
 // src/lib/persistent-session.ts
-import { spawn, execSync, execFileSync as execFileSync2 } from "child_process";
+import { spawn, execSync, execFileSync as execFileSync3 } from "child_process";
 import { join as join2, dirname } from "path";
 import { homedir as homedir2, platform, userInfo } from "os";
 import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync2, chmodSync, copyFileSync, rmSync } from "fs";
@@ -279,6 +279,216 @@ function probeClaudeProcessInTmux(tmuxSession) {
   }
 }
 
+// src/lib/claude-dialogs.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function isLoginPickerVisible(screen) {
+  return screen.includes("Select login method") || screen.includes("Claude account with subscription") && screen.includes("Anthropic Console account");
+}
+function isResumeModeDialogVisible(screen) {
+  return screen.includes("Resume from summary") && screen.includes("Don't ask me again");
+}
+function isSessionFeedbackDialogVisible(screen) {
+  return screen.includes("How is Claude doing this session") && screen.includes("0: Dismiss");
+}
+function sweepDialogs(screen) {
+  if (screen.includes("Choose the text style") || screen.includes("Dark mode") && screen.includes("Light mode")) {
+    return {
+      kind: "theme-picker",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted theme picker"
+    };
+  }
+  if (screen.includes("Yes, I trust this folder")) {
+    return {
+      kind: "folder-trust",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted folder trust"
+    };
+  }
+  if (isResumeModeDialogVisible(screen)) {
+    return {
+      kind: "resume-mode",
+      keys: ["3", "Enter"],
+      interKeyDelayMs: 300,
+      logMessage: "Auto-dismissed resume-mode dialog (picked 'Don't ask me again')"
+    };
+  }
+  if (screen.includes("I am using this for local development")) {
+    return {
+      kind: "dev-channels",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted dev channels"
+    };
+  }
+  if (screen.includes("Enter to confirm") && screen.includes("MCP")) {
+    return {
+      kind: "mcp-servers",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted MCP servers"
+    };
+  }
+  if (screen.includes("Yes, I accept") && screen.includes("Bypass Permissions")) {
+    return {
+      kind: "bypass-permissions",
+      keys: ["2", "Enter"],
+      interKeyDelayMs: 300,
+      logMessage: "Auto-accepted bypass permissions"
+    };
+  }
+  if (isSessionFeedbackDialogVisible(screen)) {
+    return {
+      kind: "session-feedback",
+      keys: ["0"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-dismissed session-feedback dialog"
+    };
+  }
+  return null;
+}
+async function sendDialogKeys(tmuxSession, action) {
+  for (let i = 0; i < action.keys.length; i++) {
+    if (i > 0 && action.interKeyDelayMs > 0) {
+      await new Promise((r) => setTimeout(r, action.interKeyDelayMs));
+    }
+    execFileSync2("tmux", ["send-keys", "-t", tmuxSession, action.keys[i]], {
+      stdio: "ignore"
+    });
+  }
+}
+function simpleTextHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i) | 0;
+  }
+  return h.toString(16);
+}
+
+// src/lib/channel-input-watchdog.ts
+var STUCK_THRESHOLD_MS = 5e3;
+var MAX_ENTER_FIRES = 3;
+var ATTACHED_STUCK_THRESHOLD_MS = 15e3;
+var INPUT_BOX_DIVIDER = /^[─━]{10,}/;
+var PROMPT_PREFIX = "\u276F ";
+function decide(pane, prev, now, config = {}) {
+  const threshold = config.stuckThresholdMs ?? STUCK_THRESHOLD_MS;
+  const maxFires = config.maxEnterFires ?? MAX_ENTER_FIRES;
+  const dialogAction = sweepDialogs(pane);
+  if (dialogAction) {
+    return { fire: false, dialog: dialogAction, next: prev };
+  }
+  const inputText = extractInputBoxText(pane);
+  if (!inputText) {
+    return { fire: false, next: void 0 };
+  }
+  if (isActivelyProcessing(pane)) {
+    return { fire: false, next: prev };
+  }
+  const hash = simpleTextHash(inputText);
+  if (!prev || prev.lastInputHash !== hash) {
+    return {
+      fire: false,
+      next: { lastInputHash: hash, firstSeenAt: now, fires: 0, lastFireAt: 0, gaveUpLogged: false }
+    };
+  }
+  if (prev.fires >= maxFires) {
+    if (!prev.gaveUpLogged) {
+      return { fire: false, gaveUp: true, next: { ...prev, gaveUpLogged: true } };
+    }
+    return { fire: false, next: prev };
+  }
+  const sinceLastAttempt = prev.fires === 0 ? now - prev.firstSeenAt : now - prev.lastFireAt;
+  if (sinceLastAttempt < threshold) return { fire: false, next: prev };
+  return {
+    fire: true,
+    next: { ...prev, fires: prev.fires + 1, lastFireAt: now }
+  };
+}
+function extractInputBoxText(pane) {
+  const lines = pane.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!line.startsWith(PROMPT_PREFIX)) continue;
+    let j = i - 1;
+    while (j >= 0 && (lines[j] ?? "").trim() === "") j--;
+    if (j < 0) continue;
+    if (!INPUT_BOX_DIVIDER.test((lines[j] ?? "").trim())) continue;
+    const text = line.slice(PROMPT_PREFIX.length).trim();
+    return text.length > 0 ? text : null;
+  }
+  return null;
+}
+function isActivelyProcessing(pane) {
+  const lines = pane.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = (lines[i] ?? "").trim();
+    if (!line.startsWith("\u273B")) continue;
+    if (/\bfor\s+\d+s\s*$/.test(line)) return false;
+    if (/\b\w+ing[…\.]{0,3}\s*$/i.test(line)) return true;
+    return false;
+  }
+  return false;
+}
+function checkChannelInputs(codeNames, io, config = {}, states = sharedStates) {
+  const live = new Set(codeNames);
+  for (const codeName of codeNames) {
+    try {
+      checkOne(codeName, io, config, states);
+    } catch (err) {
+      io.log(`[channel-input-watchdog] '${codeName}': ${err.message}`);
+    }
+  }
+  for (const key of [...states.keys()]) {
+    if (!live.has(key)) states.delete(key);
+  }
+}
+function checkOne(codeName, io, config, states) {
+  const pane = io.capturePane(codeName);
+  if (!pane) {
+    states.delete(codeName);
+    return;
+  }
+  const attached = io.isClientAttached(codeName);
+  const effectiveConfig = attached ? {
+    ...config,
+    stuckThresholdMs: config.attachedStuckThresholdMs ?? ATTACHED_STUCK_THRESHOLD_MS
+  } : config;
+  const prev = states.get(codeName);
+  const { fire, dialog, gaveUp, next } = decide(pane, prev, io.now(), effectiveConfig);
+  if (next === void 0) {
+    states.delete(codeName);
+  } else {
+    states.set(codeName, next);
+  }
+  if (dialog) {
+    io.log(
+      `[channel-input-watchdog] '${codeName}': ${dialog.logMessage} (dialog was blocking the input box)`
+    );
+    io.sendKeys(codeName, dialog.keys, dialog.interKeyDelayMs);
+    return;
+  }
+  const text = extractInputBoxText(pane) ?? "";
+  const hash = next?.lastInputHash ?? simpleTextHash(text);
+  if (gaveUp) {
+    const maxFires = effectiveConfig.maxEnterFires ?? MAX_ENTER_FIRES;
+    io.log(
+      `[channel-input-watchdog] '${codeName}': GIVING UP after ${maxFires} Enter attempts \u2014 input remains unsubmitted (input_hash=${hash}, len=${text.length})`
+    );
+    return;
+  }
+  if (fire) {
+    const maxFires = effectiveConfig.maxEnterFires ?? MAX_ENTER_FIRES;
+    io.log(
+      `[channel-input-watchdog] '${codeName}': stuck channel input \u2014 firing Enter (attempt ${next?.fires ?? 1}/${maxFires}, input_hash=${hash}, len=${text.length})`
+    );
+    io.sendEnter(codeName);
+  }
+}
+var sharedStates = /* @__PURE__ */ new Map();
+
 // src/lib/persistent-session.ts
 function syncClaudeCredsToRoot() {
   if (platform() !== "linux") return true;
@@ -405,7 +615,7 @@ function getAcpxBin() {
 }
 function defaultAcpxSessionProbe(acpxBin, projectDir) {
   try {
-    execFileSync2(acpxBin, ["claude", "list-sessions"], {
+    execFileSync3(acpxBin, ["claude", "list-sessions"], {
       cwd: projectDir,
       timeout: 5e3,
       stdio: "ignore"
@@ -655,12 +865,6 @@ function spawnSession(config, session) {
     session.restartCount++;
   }
 }
-function isLoginPickerVisible(screen) {
-  return screen.includes("Select login method") || screen.includes("Claude account with subscription") && screen.includes("Anthropic Console account");
-}
-function isResumeModeDialogVisible(screen) {
-  return screen.includes("Resume from summary") && screen.includes("Don't ask me again");
-}
 function hasMcpChildren(tmuxSession) {
   try {
     const claudePidOut = execSync(
@@ -710,40 +914,10 @@ async function acceptDialogs(tmuxSession, codeName, log, primaryModel = null, se
         continue;
       }
       dialogIterations++;
-      if (screen.includes("Choose the text style") || screen.includes("Dark mode") && screen.includes("Light mode")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted theme picker for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Yes, I trust this folder")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted workspace trust for '${codeName}'`);
-        continue;
-      }
-      if (isResumeModeDialogVisible(screen)) {
-        execFileSync2("tmux", ["send-keys", "-t", tmuxSession, "3"], { stdio: "ignore" });
-        await new Promise((r) => setTimeout(r, 300));
-        execFileSync2("tmux", ["send-keys", "-t", tmuxSession, "Enter"], { stdio: "ignore" });
-        log(
-          `[persistent-session] Auto-dismissed resume-mode dialog for '${codeName}' (picked 'Don't ask me again')`
-        );
-        continue;
-      }
-      if (screen.includes("I am using this for local development")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted dev channels for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Enter to confirm") && screen.includes("MCP")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted MCP servers for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Yes, I accept") && screen.includes("Bypass Permissions")) {
-        execSync(`tmux send-keys -t ${tmuxSession} 2`, { stdio: "ignore" });
-        await new Promise((r) => setTimeout(r, 300));
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted bypass permissions for '${codeName}'`);
+      const dialogAction = sweepDialogs(screen);
+      if (dialogAction) {
+        await sendDialogKeys(tmuxSession, dialogAction);
+        log(`[persistent-session] ${dialogAction.logMessage} for '${codeName}'`);
         continue;
       }
       if (screen.includes("\u276F") && !screen.includes("Enter to confirm")) {
@@ -794,7 +968,7 @@ async function waitForPromptReady(tmuxSession) {
   const deadline = Date.now() + 1e4;
   while (Date.now() < deadline) {
     try {
-      const screen = execFileSync2(
+      const screen = execFileSync3(
         "tmux",
         ["capture-pane", "-t", tmuxSession, "-p"],
         { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
@@ -813,11 +987,11 @@ function sleepBlockingMs(ms) {
 }
 function defaultArmSender(tmuxSession, command) {
   try {
-    execFileSync2("tmux", ["send-keys", "-t", tmuxSession, "-l", command], {
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, "-l", command], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     sleepBlockingMs(SEND_KEYS_ENTER_DELAY_MS);
-    execFileSync2("tmux", ["send-keys", "-t", tmuxSession, "Enter"], {
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, "Enter"], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     return true;
@@ -826,6 +1000,50 @@ function defaultArmSender(tmuxSession, command) {
   }
 }
 var armSender = defaultArmSender;
+function defaultPaneCapture(tmuxSession) {
+  try {
+    return execFileSync3("tmux", ["capture-pane", "-t", tmuxSession, "-p"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+  } catch {
+    return null;
+  }
+}
+var paneCapture = defaultPaneCapture;
+var defaultHygieneKeySender = async (tmuxSession, keys, interKeyDelayMs) => {
+  for (let i = 0; i < keys.length; i++) {
+    if (i > 0 && interKeyDelayMs > 0) {
+      await new Promise((r) => setTimeout(r, interKeyDelayMs));
+    }
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, keys[i]], {
+      stdio: "ignore"
+    });
+  }
+};
+var hygieneKeySender = defaultHygieneKeySender;
+async function preSendPaneHygiene(tmuxSession, codeName, log) {
+  try {
+    let screen = paneCapture(tmuxSession);
+    if (screen === null) return;
+    const action = sweepDialogs(screen);
+    if (action) {
+      await hygieneKeySender(tmuxSession, action.keys, action.interKeyDelayMs);
+      log(`[inject] ${action.logMessage} for '${codeName}' before injection`);
+      await new Promise((r) => setTimeout(r, 300));
+      screen = paneCapture(tmuxSession) ?? "";
+    }
+    const orphan = extractInputBoxText(screen);
+    if (orphan) {
+      log(
+        `[inject] clearing orphaned input for '${codeName}' before injection (input_hash=${simpleTextHash(orphan)}, len=${orphan.length})`
+      );
+      await hygieneKeySender(tmuxSession, ["C-u"], 0);
+    }
+  } catch {
+  }
+}
 function sendToAgent(tmuxSession, command) {
   return armSender(tmuxSession, command);
 }
@@ -848,6 +1066,17 @@ var _internals = {
   __setArmSender(fn) {
     armSender = fn ?? defaultArmSender;
   },
+  // ENG-6017 test seam: swap the pane capture used by the inject-time
+  // hygiene so unit tests can simulate dialog overlays / orphaned input
+  // without a tmux server. null restores the real capture.
+  __setPaneCapture(fn) {
+    paneCapture = fn ?? defaultPaneCapture;
+  },
+  // ENG-6017 test seam: swap the hygiene key sender (dialog dismissal +
+  // C-u clear) so unit tests can assert keystrokes without tmux.
+  __setHygieneKeySender(fn) {
+    hygieneKeySender = fn ?? defaultHygieneKeySender;
+  },
   // ENG-5758 test seam: swap the acpx session probe so unit tests can
   // simulate "session present" / "no session" without spawning acpx.
   __setAcpxSessionProbe(fn) {
@@ -922,6 +1151,7 @@ async function injectMessageWithStatus(codeName, type, content, meta, log) {
     _log(`[inject] acpx binary not found \u2014 falling back to tmux send-keys`);
   }
   const singleLineText = text.replace(/\s*\n+\s*/g, " ").trim();
+  await preSendPaneHygiene(`agt-${codeName}`, codeName, _log);
   const sent = sendToAgent(`agt-${codeName}`, singleLineText);
   if (sent) {
     _log(`[inject] tmux send-keys sent for '${codeName}' \u2014 unverified (delivered=false, fallbackUsed=true)`);
@@ -942,7 +1172,7 @@ function stopPersistentSession(codeName, log) {
   try {
     const acpx = getAcpxBin();
     if (acpx) {
-      execFileSync2(acpx, ["claude", "sessions", "close", `agt-${codeName}`], {
+      execFileSync3(acpx, ["claude", "sessions", "close", `agt-${codeName}`], {
         cwd: getProjectDir(codeName),
         timeout: 5e3,
         stdio: "ignore"
@@ -1019,7 +1249,7 @@ function isSessionHealthy(codeName) {
     if (!claudeAlive) {
       const paneTail = readPaneLogTail(codeName);
       try {
-        execFileSync2("tmux", ["kill-session", "-t", tmuxSession], { stdio: "ignore" });
+        execFileSync3("tmux", ["kill-session", "-t", tmuxSession], { stdio: "ignore" });
       } catch {
       }
       session.status = "crashed";
@@ -1059,13 +1289,13 @@ function collectDiagnostics(codeNames) {
     let launchArgs = null;
     let channelStatus = null;
     try {
-      execFileSync2("tmux", ["has-session", "-t", tmuxSession], { stdio: "ignore" });
+      execFileSync3("tmux", ["has-session", "-t", tmuxSession], { stdio: "ignore" });
       tmuxAlive = true;
     } catch {
     }
     if (tmuxAlive) {
       try {
-        screenCapture = execFileSync2("tmux", ["capture-pane", "-t", tmuxSession, "-p", "-S", "-30"], {
+        screenCapture = execFileSync3("tmux", ["capture-pane", "-t", tmuxSession, "-p", "-S", "-30"], {
           encoding: "utf-8",
           timeout: 3e3
         }).trim();
@@ -1073,7 +1303,7 @@ function collectDiagnostics(codeNames) {
       }
     }
     try {
-      const psOutput = execFileSync2("ps", ["aux"], { encoding: "utf-8", timeout: 3e3 });
+      const psOutput = execFileSync3("ps", ["aux"], { encoding: "utf-8", timeout: 3e3 });
       const line = psOutput.split("\n").find((l) => l.includes(`agt-${codeName}`) && !l.includes("grep"));
       if (line) {
         const match = line.match(/claude\s+.*/);
@@ -1187,6 +1417,7 @@ export {
   isAgentIdle,
   isStaleForToday,
   peekCurrentSession,
+  checkChannelInputs,
   resolveClaudeBinary,
   writePersistentClaudeWrapper,
   paneLogPath,
@@ -1210,4 +1441,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-7YM2F3DG.js.map
+//# sourceMappingURL=chunk-VTAXNSGS.js.map