@adhdev/daemon-standalone 0.9.54 → 0.9.56

package/dist/index.js

@@ -29812,6 +29812,7 @@ var require_dist2 = __commonJS({
         sendDelayMs: typeof provider.sendDelayMs === "number" ? Math.max(0, provider.sendDelayMs) : 0,
         sendKey: typeof provider.sendKey === "string" && provider.sendKey.length > 0 ? provider.sendKey : "\r",
         submitStrategy: provider.submitStrategy === "immediate" ? "immediate" : "wait_for_echo",
+        requirePromptEchoBeforeSubmit: provider.requirePromptEchoBeforeSubmit === true,
         providerResolutionMeta: {
           type: provider.type,
           name: provider.name,
@@ -30077,6 +30078,7 @@ var require_dist2 = __commonJS({
             this.sendDelayMs = resolvedConfig.sendDelayMs;
             this.sendKey = resolvedConfig.sendKey;
             this.submitStrategy = resolvedConfig.submitStrategy;
+            this.requirePromptEchoBeforeSubmit = resolvedConfig.requirePromptEchoBeforeSubmit;
             this.providerResolutionMeta = resolvedConfig.providerResolutionMeta;
             this.cliScripts = provider.scripts || {};
             const scriptNames = listCliScriptNames(this.cliScripts);
@@ -30173,6 +30175,12 @@ var require_dist2 = __commonJS({
           accumulatedRawBuffer = "";
           /** Current visible terminal screen snapshot */
           terminalScreen = new TerminalScreen(24, 80);
+          static MAX_RESPONSE_BUFFER = 8e3;
+          static MAX_RECENT_OUTPUT_BUFFER = 1e3;
+          responseBufferDroppedChars = 0;
+          recentOutputDroppedChars = 0;
+          accumulatedBufferDroppedChars = 0;
+          accumulatedRawBufferDroppedChars = 0;
           /** Max accumulated buffer size. Sized to comfortably hold a single long
            *  Hermes turn (tool calls + reasoning + final bubble) without the
            *  rolling window pushing the turn's ╭─ opening line out of view. */
@@ -30190,6 +30198,23 @@ var require_dist2 = __commonJS({
           providerResolutionMeta;
           static FINISH_RETRY_DELAY_MS = 300;
           static MAX_FINISH_RETRIES = 2;
+          getBufferState() {
+            const build = (droppedChars, maxChars) => droppedChars > 0 ? { truncated: true, droppedChars, maxChars } : void 0;
+            const responseBuffer = build(this.responseBufferDroppedChars, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+            const recentOutputBuffer = build(this.recentOutputDroppedChars, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
+            const accumulatedBuffer = build(this.accumulatedBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+            const accumulatedRawBuffer = build(this.accumulatedRawBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+            if (!responseBuffer && !recentOutputBuffer && !accumulatedBuffer && !accumulatedRawBuffer) return void 0;
+            return {
+              ...responseBuffer ? { responseBuffer } : {},
+              ...recentOutputBuffer ? { recentOutputBuffer } : {},
+              ...accumulatedBuffer ? { accumulatedBuffer } : {},
+              ...accumulatedRawBuffer ? { accumulatedRawBuffer } : {}
+            };
+          }
+          recordBoundedAppendDrop(previousLength, appendedLength, nextLength) {
+            return Math.max(0, previousLength + appendedLength - nextLength);
+          }
           buildCommittedMessagesActivitySignature() {
             const last = this.committedMessages[this.committedMessages.length - 1];
             return [
@@ -30373,6 +30398,7 @@ var require_dist2 = __commonJS({
           sendDelayMs;
           sendKey;
           submitStrategy;
+          requirePromptEchoBeforeSubmit;
           static SCRIPT_STATUS_DEBOUNCE_MS = 3e3;
           /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
           setCliScripts(scripts) {
@@ -30554,7 +30580,9 @@ var require_dist2 = __commonJS({
               this.scheduleStartupSettleCheck();
             }
             if (this.isWaitingForResponse && cleanData) {
-              this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, 8e3);
+              const previousResponseLen = this.responseBuffer.length;
+              this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+              this.responseBufferDroppedChars += this.recordBoundedAppendDrop(previousResponseLen, cleanData.length, this.responseBuffer.length);
             }
             if (cleanData.trim()) {
               if (this.serverConn) {
@@ -30563,14 +30591,19 @@ var require_dist2 = __commonJS({
                 this.logBuffer.push({ message: cleanData.trim(), level: "info" });
               }
             }
+            const prevRecentLen = this.recentOutputBuffer.length;
             const prevAccumulatedLen = this.accumulatedBuffer.length;
             const prevAccumulatedRawLen = this.accumulatedRawBuffer.length;
-            this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, 1e3);
+            this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
             this.accumulatedBuffer = appendBoundedText(this.accumulatedBuffer, cleanData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
             this.accumulatedRawBuffer = appendBoundedText(this.accumulatedRawBuffer, rawData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+            const droppedRecent = this.recordBoundedAppendDrop(prevRecentLen, cleanData.length, this.recentOutputBuffer.length);
+            const droppedClean = this.recordBoundedAppendDrop(prevAccumulatedLen, cleanData.length, this.accumulatedBuffer.length);
+            const droppedRaw = this.recordBoundedAppendDrop(prevAccumulatedRawLen, rawData.length, this.accumulatedRawBuffer.length);
+            this.recentOutputDroppedChars += droppedRecent;
+            this.accumulatedBufferDroppedChars += droppedClean;
+            this.accumulatedRawBufferDroppedChars += droppedRaw;
             if (this.currentTurnScope) {
-              const droppedClean = prevAccumulatedLen + cleanData.length - this.accumulatedBuffer.length;
-              const droppedRaw = prevAccumulatedRawLen + rawData.length - this.accumulatedRawBuffer.length;
               if (droppedClean > 0) {
                 this.currentTurnScope.bufferStart = Math.max(0, this.currentTurnScope.bufferStart - droppedClean);
               }
@@ -31400,13 +31433,15 @@ var require_dist2 = __commonJS({
                 effectiveModal = parsedModal;
               }
             }
+            const bufferState = this.getBufferState();
             return {
               status: effectiveStatus,
               messages: [...this.committedMessages],
               workingDir: this.workingDir,
               activeModal: effectiveModal,
               errorMessage: this.parseErrorMessage || void 0,
-              errorReason: this.parseErrorMessage ? "parse_error" : void 0
+              errorReason: this.parseErrorMessage ? "parse_error" : void 0,
+              ...bufferState ? { bufferState } : {}
             };
           }
           seedCommittedMessages(messages) {
@@ -31588,10 +31623,12 @@ var require_dist2 = __commonJS({
                 messages: hydratedMessages,
                 activeModal: parsed.activeModal ?? this.activeModal,
                 providerSessionId: typeof parsed.providerSessionId === "string" ? parsed.providerSessionId : void 0,
+                ...this.getBufferState() ? { bufferState: this.getBufferState() } : {},
                 ...this.providerOwnsTranscript() ? { transcriptAuthority: "provider", coverage: this.shouldUseFullProviderTranscriptContext() ? "full" : "tail" } : {}
               };
             } else {
               const messages = [...this.committedMessages];
+              const bufferState = this.getBufferState();
               result = {
                 id: "cli_session",
                 status: this.currentStatus,
@@ -31602,7 +31639,8 @@ var require_dist2 = __commonJS({
                   index: typeof message.index === "number" ? message.index : index,
                   receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
                 })),
-                activeModal: this.activeModal
+                activeModal: this.activeModal,
+                ...bufferState ? { bufferState } : {}
               };
             }
             const hasVisibleAssistantMessage = Array.isArray(result?.messages) && result.messages.some((message) => message?.role === "assistant" && typeof message?.content === "string" && message.content.trim());
@@ -31893,6 +31931,22 @@ var require_dist2 = __commonJS({
               }
             }
             if (elapsed >= state.maxEchoWaitMs) {
+              const diagnostic = {
+                elapsed,
+                maxEchoWaitMs: state.maxEchoWaitMs,
+                submitDelayMs: state.submitDelayMs,
+                promptSnippet: state.normalizedPromptSnippet,
+                requirePromptEchoBeforeSubmit: this.requirePromptEchoBeforeSubmit,
+                screenText: summarizeCliTraceText(screenText, 1e3)
+              };
+              this.recordTrace("submit_echo_missing", diagnostic);
+              if (this.requirePromptEchoBeforeSubmit) {
+                const message = `${this.cliName} prompt echo was not observed on the PTY screen before submit`;
+                LOG2.warn("CLI", `[${this.cliType}] ${message} elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
+                completion.rejectOnce(new Error(message));
+                return;
+              }
+              LOG2.warn("CLI", `[${this.cliType}] prompt echo was not observed before submit; sending submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs}`);
               this.submitSendKey(state, completion);
               return;
             }
@@ -32357,6 +32411,7 @@ var require_dist2 = __commonJS({
               sendDelayMs: this.sendDelayMs,
               sendKey: this.sendKey,
               submitStrategy: this.submitStrategy,
+              requirePromptEchoBeforeSubmit: this.requirePromptEchoBeforeSubmit,
               submitPendingUntil: this.submitPendingUntil,
               responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
               resizeSuppressUntil: this.resizeSuppressUntil,
@@ -32442,6 +32497,7 @@ var require_dist2 = __commonJS({
       ProviderLoader: () => ProviderLoader,
       STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS2,
       SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory2,
+      TurnSnapshotTracker: () => TurnSnapshotTracker,
       VersionArchive: () => VersionArchive,
       appendRecentActivity: () => appendRecentActivity,
       buildAssistantChatMessage: () => buildAssistantChatMessage,
@@ -33439,13 +33495,8 @@ var require_dist2 = __commonJS({
       "git_checkpoint",
       "git_stash_push",
       "git_stash_pop",
-      "git_checkout_files"
-    ]);
-    var MUTATING_COMMAND_NAMES = /* @__PURE__ */ new Set([
-      "git_checkpoint",
-      "git_stash_push",
-      "git_stash_pop",
-      "git_checkout_files"
+      "git_checkout_files",
+      "git_remote_url"
     ]);
     var SNAPSHOT_REASONS = /* @__PURE__ */ new Set([
       "session_baseline",
@@ -33486,7 +33537,12 @@ var require_dist2 = __commonJS({
           turnId
         }),
         compareSnapshots: ({ beforeSnapshotId, afterSnapshotId }) => defaultSnapshotStore.compare(beforeSnapshotId, afterSnapshotId),
-        getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until })
+        getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until }),
+        checkpoint: async ({ workspace, message, includeUntracked = false }) => gitCheckpoint(workspace, message, includeUntracked),
+        stashPush: async ({ workspace, message, includeUntracked = false }) => gitStashPush(workspace, message, includeUntracked),
+        stashPop: async ({ workspace, stashRef }) => gitStashPop(workspace, stashRef),
+        checkoutFiles: async ({ workspace, paths }) => gitCheckoutFiles(workspace, paths),
+        getRemoteUrl: async ({ workspace, remote = "origin" }) => gitGetRemoteUrl(workspace, remote)
       };
     }
     var defaultGitCommandServices = createDefaultGitCommandServices();
@@ -33550,9 +33606,6 @@ var require_dist2 = __commonJS({
       if (!isGitCommandName(command)) {
         return failure("invalid_args", `Unknown Git command: ${command}`);
       }
-      if (MUTATING_COMMAND_NAMES.has(command)) {
-        return failure("invalid_args", `${command} is not implemented in daemon-core read-only Git routing`);
-      }
       const workspaceResult = validateWorkspace2(args);
       if ("success" in workspaceResult) return workspaceResult;
       const { workspace } = workspaceResult;
@@ -33612,10 +33665,153 @@ var require_dist2 = __commonJS({
           }));
           return "success" in log ? log : { success: true, log };
         }
+        case "git_checkpoint": {
+          if (!services.checkpoint) return serviceNotImplemented(command);
+          const msg = validateMutatingMessage(args?.message);
+          if (typeof msg !== "string") return msg;
+          const includeUntracked = Boolean(args?.includeUntracked);
+          const checkpoint = await runService(() => services.checkpoint({ workspace, message: msg, includeUntracked }));
+          return "success" in checkpoint ? checkpoint : { success: true, checkpoint };
+        }
+        case "git_stash_push": {
+          if (!services.stashPush) return serviceNotImplemented(command);
+          const msg = validateMutatingMessage(args?.message);
+          if (typeof msg !== "string") return msg;
+          const includeUntracked = Boolean(args?.includeUntracked);
+          const stash = await runService(() => services.stashPush({ workspace, message: msg, includeUntracked }));
+          return "success" in stash ? stash : { success: true, stash };
+        }
+        case "git_stash_pop": {
+          if (!services.stashPop) return serviceNotImplemented(command);
+          const stashRef = optionalString(args?.stashRef);
+          if (stashRef !== void 0 && !/^stash@\{\d+\}$/.test(stashRef)) {
+            return failure("invalid_args", "stashRef must match stash@{N} format");
+          }
+          const popResult = await runService(() => services.stashPop({ workspace, stashRef }));
+          if (popResult !== void 0 && "success" in popResult) return popResult;
+          return { success: true, stashPopped: true };
+        }
+        case "git_checkout_files": {
+          if (!services.checkoutFiles) return serviceNotImplemented(command);
+          const paths = args?.paths;
+          if (!Array.isArray(paths) || paths.length === 0) {
+            return failure("invalid_args", "paths must be a non-empty array");
+          }
+          if (paths.length > 50) {
+            return failure("invalid_args", "paths array exceeds maximum of 50 entries");
+          }
+          const checkoutResult = await runService(() => services.checkoutFiles({ workspace, paths }));
+          return "success" in checkoutResult ? checkoutResult : { success: true, checkedOut: checkoutResult.checkedOut };
+        }
+        case "git_remote_url": {
+          if (!services.getRemoteUrl) return serviceNotImplemented(command);
+          const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
+          const remoteResult = await runService(() => services.getRemoteUrl({ workspace, remote }));
+          if ("success" in remoteResult) return remoteResult;
+          return { success: true, remoteUrl: remoteResult.remoteUrl, remote: remoteResult.remote };
+        }
         default:
           return failure("invalid_args", `Unknown Git command: ${command}`);
       }
     }
+    function validateMutatingMessage(value) {
+      if (typeof value !== "string" || !value.trim()) {
+        return failure("invalid_args", "message must be a non-empty string");
+      }
+      const msg = value.trim();
+      if (msg.length > 200) {
+        return failure("invalid_args", "message must be 200 characters or fewer");
+      }
+      return msg;
+    }
+    async function gitCheckpoint(workspace, message, includeUntracked) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const statusResult = await getGitRepoStatus(workspace);
+      if (statusResult.hasConflicts) {
+        throw new GitCommandError("conflict", "Repository has conflicts \u2014 resolve before checkpointing");
+      }
+      const addArgs = includeUntracked ? ["-A"] : ["-u"];
+      await runGit(repo, ["add", ...addArgs], { cwd: repoRoot });
+      const fullMsg = `adhdev: checkpoint ${message}`;
+      let commitSha;
+      try {
+        await runGit(repo, ["commit", "-m", fullMsg], { cwd: repoRoot });
+        const revResult = await runGit(repo, ["rev-parse", "HEAD"], { cwd: repoRoot });
+        commitSha = revResult.stdout.trim();
+      } catch (err) {
+        const output = (err?.stdout || "") + (err?.stderr || "");
+        if (/nothing to commit/i.test(output)) {
+          throw new GitCommandError("git_command_failed", "Nothing to commit");
+        }
+        throw err;
+      }
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        commit: commitSha,
+        message: fullMsg,
+        lastCheckedAt: Date.now()
+      };
+    }
+    async function gitStashPush(workspace, message, includeUntracked) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const stashArgs = ["stash", "push", "-m", message];
+      if (includeUntracked) stashArgs.push("--include-untracked");
+      const result = await runGit(repo, stashArgs, { cwd: repoRoot });
+      if (/No local changes to save/i.test(result.stdout + result.stderr)) {
+        throw new GitCommandError("git_command_failed", "Nothing to stash");
+      }
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        stashRef: "stash@{0}",
+        message,
+        lastCheckedAt: Date.now()
+      };
+    }
+    async function gitStashPop(workspace, stashRef) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const popArgs = stashRef ? ["stash", "pop", stashRef] : ["stash", "pop"];
+      await runGit(repo, popArgs, { cwd: repoRoot });
+    }
+    async function gitCheckoutFiles(workspace, paths) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const normalizedPaths = [];
+      for (const p of paths) {
+        if (typeof p !== "string" || !p.trim() || p.includes("\0")) {
+          throw new GitCommandError("invalid_args", `Invalid path: ${String(p)}`);
+        }
+        if (path32.isAbsolute(p)) {
+          throw new GitCommandError("invalid_args", `Path must be repository-relative, not absolute: ${p}`);
+        }
+        const normalized = path32.normalize(p.trim()).split(path32.sep).join("/");
+        if (normalized.startsWith("../") || normalized === "..") {
+          throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+        }
+        const absolutePath = path32.resolve(repoRoot, normalized);
+        if (!isPathInside(repoRoot, absolutePath)) {
+          throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+        }
+        normalizedPaths.push(normalized);
+      }
+      await runGit(repo, ["checkout", "--", ...normalizedPaths], { cwd: repoRoot });
+      return { checkedOut: normalizedPaths };
+    }
+    async function gitGetRemoteUrl(workspace, remote) {
+      const repo = await resolveGitRepository(workspace);
+      const result = await runGit(repo, ["remote", "get-url", remote], { cwd: repo.repoRoot });
+      const remoteUrl = result.stdout.trim();
+      if (!remoteUrl) {
+        throw new GitCommandError("git_command_failed", `Remote '${remote}' has no URL`);
+      }
+      return { remoteUrl, remote };
+    }
     function formatOptionalGitLogRangeArg(flag, value) {
       return value ? [`${flag}=${value}`] : [];
     }
@@ -33673,6 +33869,25 @@ var require_dist2 = __commonJS({
       }
       return normalized;
     }
+    var BUSY_STATUSES = /* @__PURE__ */ new Set(["streaming", "waiting_approval"]);
+    var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["idle", "error"]);
+    var TurnSnapshotTracker = class {
+      lastStatus = /* @__PURE__ */ new Map();
+      onTurnCompleted;
+      constructor(onTurnCompleted) {
+        this.onTurnCompleted = onTurnCompleted;
+      }
+      record(sessionId, status, workspace) {
+        const prev = this.lastStatus.get(sessionId);
+        this.lastStatus.set(sessionId, status);
+        if (workspace && prev && BUSY_STATUSES.has(prev) && TERMINAL_STATUSES.has(status)) {
+          this.onTurnCompleted({ sessionId, workspace });
+        }
+      }
+      forget(sessionId) {
+        this.lastStatus.delete(sessionId);
+      }
+    };
     init_config();
     var fs5 = __toESM2(require("fs"));
     var os6 = __toESM2(require("os"));
@@ -42463,6 +42678,16 @@ ${effect.notification.body || ""}`.trim();
             return result;
           }
         }
+        if (cmd === "send_chat" && this._ctx.onBeforeSendChat) {
+          const sessionId = this._currentRoute.session?.sessionId;
+          const workspace = sessionId ? this._ctx.instanceManager?.getInstance(sessionId)?.getState?.()?.workspace : void 0;
+          if (workspace && sessionId) {
+            try {
+              this._ctx.onBeforeSendChat({ workspace, sessionId });
+            } catch {
+            }
+          }
+        }
         try {
           result = await this.dispatch(cmd, args);
           this.logCommandEnd(cmd, result, startedAt);
@@ -45676,6 +45901,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "sendDelayMs",
       "sendKey",
       "submitStrategy",
+      "requirePromptEchoBeforeSubmit",
       "timeouts",
       "disableUpstream"
     ]);
@@ -57123,6 +57349,7 @@ data: ${JSON.stringify(msg.data)}
         providerLoader,
         instanceManager,
         sessionRegistry,
+        gitCommandServices: createDefaultGitCommandServices(),
         onProviderSettingChanged: async (providerType) => {
           await refreshProviderAvailability(providerType);
           config2.onStatusChange?.();
@@ -57130,7 +57357,8 @@ data: ${JSON.stringify(msg.data)}
         onProviderSourceConfigChanged: async () => {
           await refreshProviderAvailability();
           config2.onStatusChange?.();
-        }
+        },
+        onBeforeSendChat: config2.onBeforeSendChat
       });
       agentStreamManager = new DaemonAgentStreamManager(
         LOG2.forComponent("AgentStream").asLogFn(),
@@ -59266,7 +59494,8 @@ var StandaloneServer = class {
       })),
       instanceId: `standalone_${machineId}`,
       version: pkgVersion,
-      profile
+      profile,
+      getGitSummaryForWorkspace: (workspace) => this.gitWorkspaceMonitor.getCompactSummary(workspace)
     });
   }
   async pushWsRuntimeSnapshots(ws2) {