@otto-code/server 0.7.2 → 0.7.3

package/dist/server/server/websocket-server.js

@@ -24,6 +24,7 @@ import { CLIENT_CAPS } from "@otto-code/protocol/client-capabilities";
 import { BrowserAutomationHostCapabilitySchema, } from "@otto-code/protocol/browser-automation/capabilities";
 import { LspService } from "./lsp/service.js";
 import { SolutionService } from "./solution-model/service.js";
+import { killAllSharedDotnetProcesses } from "./dotnet-process-registry.js";
 const WS_CLOSE_DAEMON_AUTH_FAILED = 4401;
 function resolveTerminalAttentionReason(input) {
     if (input.attentionReason === "finished")
@@ -72,6 +73,7 @@ function createFallbackWorkspaceGitService() {
         onSnapshotUpdated: () => ({
             unsubscribe: () => { },
         }),
+        setActiveWorkspace: () => { },
         peekSnapshot: () => null,
         getCheckout: async (cwd) => ({
             cwd,
@@ -665,6 +667,10 @@ export class VoiceAssistantWebSocketServer {
         await this.solutionService.stopAll().catch((err) => {
             this.logger.warn({ err }, "Failed to stop solution sidecars during shutdown");
         });
+        // Backstop after both pools have had their turn: anything .NET still tracked is a
+        // process whose owner lost its handle, and it would otherwise outlive the daemon.
+        // Kills by tree, so MSBuild workers go with their parent.
+        killAllSharedDotnetProcesses();
         this.providerSnapshotManager.destroy();
         this.checkoutDiffManager.dispose();
         this.workspaceGitService.dispose();
@@ -1052,6 +1058,10 @@ export class VoiceAssistantWebSocketServer {
                 codeIndex: true,
                 // COMPAT(lsp): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
                 lsp: true,
+                // COMPAT(lspHostServers): added in v0.7.3, drop the gate when daemon floor >= v0.7.3.
+                // `lsp.servers.list` answers host-wide with no `cwd`, so the settings screen can
+                // list what this machine can run without a workspace open.
+                lspHostServers: true,
                 // COMPAT(solutionView): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
                 // Serving the RPCs, not the feature being on: the switch lives in the daemon
                 // config and the client reads it there. A flag that folded in the setting would

package/dist/server/server/workspace-git-service.d.ts

@@ -102,6 +102,12 @@ export interface WorkspaceGitService {
     }>;
     scheduleRefreshForCwd(cwd: string): void;
     onWorkspaceStateMayHaveChanged(cwd: string): void;
+    /**
+     * The workspace the client is currently in. Periodic refresh and background fetch run
+     * only for this one; everything else stays observed through its filesystem watchers but
+     * costs nothing while idle.
+     */
+    setActiveWorkspace(cwd: string | null): void;
     dispose(): void;
 }
 /**
@@ -185,6 +191,8 @@ export declare class WorkspaceGitServiceImpl implements WorkspaceGitService {
     private readonly snapshotUpdatedListeners;
     private readonly workspaceTargets;
     private readonly repoTargets;
+    /** Resolved cwd of the workspace the client is in; see `setActiveWorkspace`. */
+    private activeWorkspaceCwd;
     private readonly workingTreeWatchTargets;
     private readonly workingTreeWatchSetups;
     private readonly linuxIgnoredDirsCache;
@@ -243,7 +251,35 @@ export declare class WorkspaceGitServiceImpl implements WorkspaceGitService {
     private resolveWorkspaceGitRefsRoot;
     private startWorkspaceWatchers;
     private ensureRepoTarget;
+    private startRepoFetchTimer;
+    private stopRepoFetchTimer;
     private scheduleWorkspaceRefresh;
+    /**
+     * Which workspace the client is actually in, or null when that is not known.
+     *
+     * This is the whole answer to "why does Otto get slower the more projects I have". Every
+     * workspace the client has ever listed gets an observer, and each observer used to run a
+     * 60s self-heal refresh and a 180s `git fetch` of its own. One snapshot is around nine
+     * `git` invocations, measured at roughly half a second of process time on Windows, so the
+     * steady-state cost was half a second per workspace per minute *of catalogue*, whether or
+     * not any of it was on screen. Twenty workspaces meant ten seconds of git per minute,
+     * forever, for a user looking at one of them.
+     *
+     * Periodic work now follows the active workspace and nothing else. What deliberately does
+     * *not* follow it are the `.git` filesystem watchers: those are event-driven, cost nothing
+     * while nothing happens, and are how a background workspace with an agent committing in it
+     * still refreshes its card. Dropping the poll is only safe because that watcher is
+     * reliable, which it became when it stopped watching the `HEAD` file's inode.
+     */
+    setActiveWorkspace(cwd: string | null): void;
+    private isActiveWorkspaceTarget;
+    /**
+     * Start periodic work on whatever is now active and stop it everywhere else. The newly
+     * active workspace also gets one refresh, because it may have gone stale while dormant
+     * and the user is looking at it right now.
+     */
+    private applyActiveWorkspacePolicy;
+    private stopWorkspacePeriodicWork;
     private startWorkspaceSubscriptionTimers;
     private updateGitHubPollForTarget;
     private resolveGitHubPollTarget;

package/dist/server/server/workspace-git-service.js

@@ -60,6 +60,8 @@ export class WorkspaceGitServiceImpl {
         this.snapshotUpdatedListeners = new Set();
         this.workspaceTargets = new Map();
         this.repoTargets = new Map();
+        /** Resolved cwd of the workspace the client is in; see `setActiveWorkspace`. */
+        this.activeWorkspaceCwd = null;
         this.workingTreeWatchTargets = new Map();
         this.workingTreeWatchSetups = new Map();
         this.linuxIgnoredDirsCache = new Map();
@@ -602,10 +604,28 @@ export class WorkspaceGitServiceImpl {
         return gitDir;
     }
     startWorkspaceWatchers(target, gitDir, repoGitRoot) {
-        for (const watchPath of new Set([join(gitDir, "HEAD"), join(repoGitRoot, "refs", "heads")])) {
+        // Watch the *directories*, never `HEAD` itself.
+        //
+        // Git does not edit HEAD in place: `git checkout` writes `HEAD.lock` and renames it
+        // over HEAD. A watch on the file path binds to the inode, so after the first
+        // checkout the watcher was holding an unlinked file and went permanently deaf —
+        // which is why switching branches in a terminal never reached the Changes sidebar.
+        // A directory watch sees the rename, because the rename is an event *in* the
+        // directory. `filename` is filtered so the rest of `.git`'s churn (index.lock,
+        // COMMIT_EDITMSG, ORIG_HEAD) does not schedule a refresh; a null filename is rare
+        // and refreshes anyway, since a missed branch switch costs more than a debounced
+        // extra snapshot.
+        const watchTargets = [
+            { path: gitDir, matches: (filename) => filename === null || filename === "HEAD" },
+            { path: join(repoGitRoot, "refs", "heads"), matches: () => true },
+        ];
+        for (const { path: watchPath, matches } of watchTargets) {
             let watcher = null;
             try {
-                watcher = this.deps.watch(watchPath, { recursive: false }, () => {
+                watcher = this.deps.watch(watchPath, { recursive: false }, (_event, filename) => {
+                    if (!matches(typeof filename === "string" ? filename : null)) {
+                        return;
+                    }
                     this.scheduleWorkspaceRefresh(target);
                 });
             }
@@ -650,13 +670,32 @@ export class WorkspaceGitServiceImpl {
             repoGitRoot,
             cwd: workspaceTarget.cwd,
             workspaceKeys: new Set([workspaceTarget.cwd]),
-            intervalId: setInterval(() => {
-                void this.runRepoFetch(repoTarget);
-            }, BACKGROUND_GIT_FETCH_INTERVAL_MS),
+            intervalId: null,
             fetchInFlight: false,
         };
         this.repoTargets.set(repoGitRoot, repoTarget);
-        void this.runRepoFetch(repoTarget);
+        // A background `git fetch` is the most expensive periodic thing here — it is network
+        // I/O, not just process spawning — so it is the last thing that should run for a repo
+        // the user is not in. Both the timer and the immediate first fetch are gated.
+        if (this.isActiveWorkspaceTarget(workspaceTarget)) {
+            this.startRepoFetchTimer(repoTarget);
+            void this.runRepoFetch(repoTarget);
+        }
+    }
+    startRepoFetchTimer(target) {
+        if (target.intervalId) {
+            return;
+        }
+        target.intervalId = setInterval(() => {
+            void this.runRepoFetch(target);
+        }, BACKGROUND_GIT_FETCH_INTERVAL_MS);
+    }
+    stopRepoFetchTimer(target) {
+        if (!target.intervalId) {
+            return;
+        }
+        clearInterval(target.intervalId);
+        target.intervalId = null;
     }
     scheduleWorkspaceRefresh(targetOrCwd, options) {
         const target = typeof targetOrCwd === "string"
@@ -682,7 +721,72 @@ export class WorkspaceGitServiceImpl {
             }
         }, WORKSPACE_GIT_WATCH_DEBOUNCE_MS);
     }
+    /**
+     * Which workspace the client is actually in, or null when that is not known.
+     *
+     * This is the whole answer to "why does Otto get slower the more projects I have". Every
+     * workspace the client has ever listed gets an observer, and each observer used to run a
+     * 60s self-heal refresh and a 180s `git fetch` of its own. One snapshot is around nine
+     * `git` invocations, measured at roughly half a second of process time on Windows, so the
+     * steady-state cost was half a second per workspace per minute *of catalogue*, whether or
+     * not any of it was on screen. Twenty workspaces meant ten seconds of git per minute,
+     * forever, for a user looking at one of them.
+     *
+     * Periodic work now follows the active workspace and nothing else. What deliberately does
+     * *not* follow it are the `.git` filesystem watchers: those are event-driven, cost nothing
+     * while nothing happens, and are how a background workspace with an agent committing in it
+     * still refreshes its card. Dropping the poll is only safe because that watcher is
+     * reliable, which it became when it stopped watching the `HEAD` file's inode.
+     */
+    setActiveWorkspace(cwd) {
+        const next = cwd === null ? null : resolve(cwd);
+        if (next === this.activeWorkspaceCwd) {
+            return;
+        }
+        this.activeWorkspaceCwd = next;
+        this.applyActiveWorkspacePolicy();
+    }
+    isActiveWorkspaceTarget(target) {
+        return this.activeWorkspaceCwd !== null && target.cwd === this.activeWorkspaceCwd;
+    }
+    /**
+     * Start periodic work on whatever is now active and stop it everywhere else. The newly
+     * active workspace also gets one refresh, because it may have gone stale while dormant
+     * and the user is looking at it right now.
+     */
+    applyActiveWorkspacePolicy() {
+        for (const target of this.workspaceTargets.values()) {
+            if (this.isActiveWorkspaceTarget(target)) {
+                this.startWorkspaceSubscriptionTimers(target);
+                this.scheduleWorkspaceRefresh(target, { reason: "became-active" });
+            }
+            else {
+                this.stopWorkspacePeriodicWork(target);
+            }
+        }
+        for (const repoTarget of this.repoTargets.values()) {
+            const holdsActive = [...repoTarget.workspaceKeys].some((key) => key === this.activeWorkspaceCwd);
+            if (holdsActive) {
+                this.startRepoFetchTimer(repoTarget);
+            }
+            else {
+                this.stopRepoFetchTimer(repoTarget);
+            }
+        }
+    }
+    stopWorkspacePeriodicWork(target) {
+        if (target.selfHealTimer) {
+            clearInterval(target.selfHealTimer);
+            target.selfHealTimer = null;
+        }
+        this.stopGitHubPollForTarget(target);
+    }
     startWorkspaceSubscriptionTimers(target) {
+        // A workspace nobody is looking at does not poll. `applyActiveWorkspacePolicy` starts
+        // this the moment it becomes active, so nothing is lost, only deferred.
+        if (!this.isActiveWorkspaceTarget(target)) {
+            return;
+        }
         if (!target.selfHealTimer) {
             target.selfHealTimer = setInterval(() => {
                 this.scheduleWorkspaceObservationSetup(target);

package/dist/server/terminal/shell-integration/zsh/.zshenv

@@ -1,17 +1,17 @@
-typeset -g OTTO_SHELL_INTEGRATION_DIR="${${(%):-%N}:A:h}"
-
-if [[ -n "${OTTO_ZSH_ZDOTDIR-}" ]]; then
-  export ZDOTDIR="${OTTO_ZSH_ZDOTDIR}"
-else
-  unset ZDOTDIR
-fi
-
-if [[ -n "${ZDOTDIR-}" ]]; then
-  if [[ -f "${ZDOTDIR}/.zshenv" ]]; then
-    source "${ZDOTDIR}/.zshenv"
-  fi
-elif [[ -f "${HOME}/.zshenv" ]]; then
-  source "${HOME}/.zshenv"
-fi
-
-source "${OTTO_SHELL_INTEGRATION_DIR}/otto-integration.zsh"
+typeset -g OTTO_SHELL_INTEGRATION_DIR="${${(%):-%N}:A:h}"
+
+if [[ -n "${OTTO_ZSH_ZDOTDIR-}" ]]; then
+  export ZDOTDIR="${OTTO_ZSH_ZDOTDIR}"
+else
+  unset ZDOTDIR
+fi
+
+if [[ -n "${ZDOTDIR-}" ]]; then
+  if [[ -f "${ZDOTDIR}/.zshenv" ]]; then
+    source "${ZDOTDIR}/.zshenv"
+  fi
+elif [[ -f "${HOME}/.zshenv" ]]; then
+  source "${HOME}/.zshenv"
+fi
+
+source "${OTTO_SHELL_INTEGRATION_DIR}/otto-integration.zsh"

package/dist/server/terminal/shell-integration/zsh/otto-integration.zsh

@@ -1,32 +1,32 @@
-if [[ -n "${_OTTO_ZSH_INTEGRATION_LOADED-}" ]]; then
-  return
-fi
-typeset -g _OTTO_ZSH_INTEGRATION_LOADED=1
-
-autoload -Uz add-zsh-hook
-
-typeset -g _OTTO_ZSH_COMMAND_ACTIVE=0
-
-function _otto_osc633() {
-  printf '\e]633;%s\a' "$1"
-}
-
-function _otto_precmd() {
-  local command_status=$?
-  if [[ "$_OTTO_ZSH_COMMAND_ACTIVE" == "1" ]]; then
-    _otto_osc633 "D;${command_status}"
-    _OTTO_ZSH_COMMAND_ACTIVE=0
-  fi
-  printf '\e]2;%s\a' "${PWD/#$HOME/~}"
-  _otto_osc633 "A"
-}
-
-function _otto_preexec() {
-  _OTTO_ZSH_COMMAND_ACTIVE=1
-  _otto_osc633 "B"
-  _otto_osc633 "C"
-  printf '\e]2;%s\a' "$1"
-}
-
-add-zsh-hook precmd _otto_precmd
-add-zsh-hook preexec _otto_preexec
+if [[ -n "${_OTTO_ZSH_INTEGRATION_LOADED-}" ]]; then
+  return
+fi
+typeset -g _OTTO_ZSH_INTEGRATION_LOADED=1
+
+autoload -Uz add-zsh-hook
+
+typeset -g _OTTO_ZSH_COMMAND_ACTIVE=0
+
+function _otto_osc633() {
+  printf '\e]633;%s\a' "$1"
+}
+
+function _otto_precmd() {
+  local command_status=$?
+  if [[ "$_OTTO_ZSH_COMMAND_ACTIVE" == "1" ]]; then
+    _otto_osc633 "D;${command_status}"
+    _OTTO_ZSH_COMMAND_ACTIVE=0
+  fi
+  printf '\e]2;%s\a' "${PWD/#$HOME/~}"
+  _otto_osc633 "A"
+}
+
+function _otto_preexec() {
+  _OTTO_ZSH_COMMAND_ACTIVE=1
+  _otto_osc633 "B"
+  _otto_osc633 "C"
+  printf '\e]2;%s\a' "$1"
+}
+
+add-zsh-hook precmd _otto_precmd
+add-zsh-hook preexec _otto_preexec

package/dist/server/terminal/terminal.js

@@ -228,13 +228,23 @@ function resolveZshShellIntegrationRuntimeDir() {
     }
     return join(tmpdir(), `${username}-otto-zsh`);
 }
+/**
+ * zsh refuses to parse scripts with CRLF endings: the trailing `\r` becomes part of
+ * the token, so a blank line runs `^M` as a command and `fi\r` never closes its `if`.
+ * The shipped sources can pick up CRLF anywhere along the way (a Windows checkout with
+ * `core.autocrlf=true` publishes them straight into the tarball), so normalize at the
+ * point of use rather than trusting whatever bytes reached disk.
+ */
+function readZshShellIntegrationScript(filePath) {
+    return readFileSync(filePath, "utf8").replace(/\r\n/g, "\n");
+}
 function prepareZshShellIntegrationRuntimeDir(sourceDir = resolveZshShellIntegrationDir()) {
     const readableSourceDir = resolveExternalProcessPath(sourceDir);
     const runtimeDir = resolveZshShellIntegrationRuntimeDir();
     mkdirSync(runtimeDir, { recursive: true, mode: 0o700 });
     chmodSync(runtimeDir, 0o700);
-    writePrivateFileAtomicSync(join(runtimeDir, ".zshenv"), readFileSync(join(readableSourceDir, ".zshenv")));
-    writePrivateFileAtomicSync(join(runtimeDir, "otto-integration.zsh"), readFileSync(join(readableSourceDir, "otto-integration.zsh")));
+    writePrivateFileAtomicSync(join(runtimeDir, ".zshenv"), readZshShellIntegrationScript(join(readableSourceDir, ".zshenv")));
+    writePrivateFileAtomicSync(join(runtimeDir, "otto-integration.zsh"), readZshShellIntegrationScript(join(readableSourceDir, "otto-integration.zsh")));
     return runtimeDir;
 }
 export function buildTerminalEnvironment(input) {