@adhdev/daemon-standalone 0.9.54 → 0.9.55

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);
@@ -30373,6 +30375,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) {
@@ -31893,6 +31896,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 +32376,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 +32462,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 +33460,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 +33502,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 +33571,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 +33630,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 +33834,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 +42643,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 +45866,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "sendDelayMs",
       "sendKey",
       "submitStrategy",
+      "requirePromptEchoBeforeSubmit",
       "timeouts",
       "disableUpstream"
     ]);
@@ -57123,6 +57314,7 @@ data: ${JSON.stringify(msg.data)}
         providerLoader,
         instanceManager,
         sessionRegistry,
+        gitCommandServices: createDefaultGitCommandServices(),
         onProviderSettingChanged: async (providerType) => {
           await refreshProviderAvailability(providerType);
           config2.onStatusChange?.();
@@ -57130,7 +57322,8 @@ data: ${JSON.stringify(msg.data)}
         onProviderSourceConfigChanged: async () => {
           await refreshProviderAvailability();
           config2.onStatusChange?.();
-        }
+        },
+        onBeforeSendChat: config2.onBeforeSendChat
       });
       agentStreamManager = new DaemonAgentStreamManager(
         LOG2.forComponent("AgentStream").asLogFn(),
@@ -59266,7 +59459,8 @@ var StandaloneServer = class {
       })),
       instanceId: `standalone_${machineId}`,
       version: pkgVersion,
-      profile
+      profile,
+      getGitSummaryForWorkspace: (workspace) => this.gitWorkspaceMonitor.getCompactSummary(workspace)
     });
   }
   async pushWsRuntimeSnapshots(ws2) {