nolo-cli 0.1.30 → 0.1.31

package/server/handlers/desktopAgentRuntimeTurnHandler.ts

@@ -1,4 +1,5 @@
 import type { AgentRuntimeMessageContent } from "../../agent-runtime";
+import { normalizeAgentRunDialogLineage } from "../../ai/agent/agentRunDialogLineage";
 import { parseToken } from "../../auth/token";
 import { WEB_AUTH_TOKEN_COOKIE } from "../../auth/tokenCookie";
 import {
@@ -7,7 +8,7 @@ import {
   type DesktopTextOnlyAgentRuntimeTurnInput,
 } from "./desktopAgentRuntimeTurnService";
 import type { DesktopAgentRuntimeRecordStore } from "./desktopAgentRuntimeAdapter";
-import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostFacts";
+import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostCapabilities";
 
 type DesktopAgentRuntimeTurnBody = {
   agentRef: string;
@@ -87,11 +88,14 @@ function parseDesktopAgentRuntimeTurnBody(body: unknown): DesktopAgentRuntimeTur
   const record = body as Record<string, unknown>;
   if (typeof record.agentRef !== "string" || !record.agentRef.trim()) return null;
   if (!isAgentRuntimeMessageContent(record.input)) return null;
+  const dialogLineage = normalizeAgentRunDialogLineage({
+    continueDialogId: record.continueDialogId,
+  });
   return {
     agentRef: record.agentRef.trim(),
     input: record.input,
-    ...(typeof record.continueDialogId === "string" && record.continueDialogId.trim()
-      ? { continueDialogId: record.continueDialogId.trim() }
+    ...(dialogLineage.continueDialogId
+      ? { continueDialogId: dialogLineage.continueDialogId }
       : {}),
     ...(typeof record.maxToolRounds === "number" && Number.isFinite(record.maxToolRounds)
       ? { maxToolRounds: Math.max(0, Math.floor(record.maxToolRounds)) }

package/server/handlers/desktopAgentRuntimeTurnService.ts

@@ -1,5 +1,6 @@
 import type {
   AgentRuntimeAgentConfig,
+  HostRuntimeConfig,
   AgentRuntimeMessageContent,
   AgentRuntimeProvider,
   AgentRuntimeToolCallInput,
@@ -13,11 +14,14 @@ import {
   createWorkspaceSession,
   executeLocalToolWithPolicy,
   prepareGitTaskWorkspace,
+  resolveHostRuntimeConfigFromEnv,
+  resolveRequestedRuntimeToolNames,
   runLocalAgentTurn,
 } from "../../agent-runtime";
 import {
   buildLocalWorkspaceOpenAiTools,
   buildLocalWorkspacePolicyToolNames,
+  resolveLocalWorkspaceShellToolExposure,
   buildLocalWorkspaceToolset,
   createLocalWorkspaceToolExecutors,
 } from "../../agent-runtime/localWorkspaceTools";
@@ -28,10 +32,11 @@ import {
   type DesktopAgentRuntimeActions,
   type DesktopAgentRuntimeRecordStore,
 } from "./desktopAgentRuntimeAdapter";
-import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostFacts";
+import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostCapabilities";
 
 type DesktopAgentRuntimeBaseTurnInput = {
   env: DesktopAgentRuntimeEnv;
+  hostRuntimeConfig?: HostRuntimeConfig;
   store: DesktopAgentRuntimeRecordStore;
   agentRef: string;
   input: AgentRuntimeMessageContent;
@@ -75,8 +80,8 @@ export function createDesktopAgentRuntimeDialogId() {
 }
 
 function buildDesktopOpenAiTools(args: {
-  toolNames?: string[];
-  env: DesktopAgentRuntimeEnv;
+  requestedToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
 }) {
   const toolset = buildDesktopLocalWorkspaceToolset(args);
   return buildLocalWorkspaceOpenAiTools({
@@ -86,29 +91,31 @@ function buildDesktopOpenAiTools(args: {
 }
 
 function buildDesktopLocalWorkspaceToolset(args: {
-  toolNames?: string[];
-  env: DesktopAgentRuntimeEnv;
+  requestedToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
 }) {
-  const shellModeEnabled = ["worktree", "dangerous", "1", "true"].includes(
-    args.env.NOLO_LOCAL_SHELL_MODE || ""
-  );
+  const requestedToolNames = args.requestedToolNames ?? [];
+  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
+    declaredToolNames: requestedToolNames,
+    hostRuntimeConfig: args.hostRuntimeConfig,
+  });
   const toolset = buildLocalWorkspaceToolset({
-    declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled,
+    declaredToolNames: requestedToolNames,
+    exposeShellTools,
   });
   return toolset;
 }
 
 function buildDesktopLocalPolicyToolNames(args: {
-  toolNames?: string[];
-  env: DesktopAgentRuntimeEnv;
+  requestedToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
 }) {
-  const shellModeEnabled = ["worktree", "dangerous", "1", "true"].includes(
-    args.env.NOLO_LOCAL_SHELL_MODE || ""
-  );
   return buildLocalWorkspacePolicyToolNames({
-    declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled,
+    declaredToolNames: args.requestedToolNames,
+    exposeShellTools: resolveLocalWorkspaceShellToolExposure({
+      declaredToolNames: args.requestedToolNames,
+      hostRuntimeConfig: args.hostRuntimeConfig,
+    }),
   });
 }
 
@@ -120,23 +127,6 @@ function buildDesktopLocalToolExecutors(args: {
   };
 }
 
-function resolveDesktopRuntimePolicyEnv(args: {
-  env: DesktopAgentRuntimeEnv;
-  agentConfig: AgentRuntimeAgentConfig;
-}): DesktopAgentRuntimeEnv {
-  const policy = args.agentConfig.runtimeToolPolicy;
-  const shellPolicy = policy?.shell;
-  const enablesWorktreeShell =
-    shellPolicy?.enabled === true && shellPolicy.mode === "worktree";
-  if (!enablesWorktreeShell || args.env.NOLO_LOCAL_SHELL_MODE) {
-    return args.env;
-  }
-  return {
-    ...args.env,
-    NOLO_LOCAL_SHELL_MODE: "worktree",
-  };
-}
-
 function resolveDesktopRuntimeWorkspaceMode(args: {
   agentConfig: AgentRuntimeAgentConfig;
   hasExplicitCwd: boolean;
@@ -236,6 +226,7 @@ export function createDesktopTextOnlyAgentRuntimeActions(args: {
 
 export function createDesktopAgentRuntimeActions(args: {
   env: DesktopAgentRuntimeEnv;
+  hostRuntimeConfig?: HostRuntimeConfig;
   store: DesktopAgentRuntimeRecordStore;
   now: () => number;
   createId: () => string;
@@ -244,7 +235,11 @@ export function createDesktopAgentRuntimeActions(args: {
   prepareTaskWorkspace?: PrepareTaskWorkspace;
 }): DesktopAgentRuntimeActions {
   let activeAgentToolNames: string[] = [];
-  let activeEnv = args.env;
+  const hostRuntimeConfig = args.hostRuntimeConfig ?? resolveHostRuntimeConfigFromEnv({
+    env: args.env,
+    surface: "desktop",
+    workspaceBinding: args.cwd ? "explicit-cwd" : "default-cwd",
+  });
   let workspaceSession = createWorkspaceSession({ cwd: args.cwd });
   let executors = buildDesktopLocalToolExecutors({ workspaceRoot: workspaceSession.workspaceRoot });
   return createDesktopAgentRuntimeRecordStoreActions({
@@ -254,13 +249,10 @@ export function createDesktopAgentRuntimeActions(args: {
     createId: args.createId,
     getWorkspaceRoot: () => workspaceSession.workspaceRoot,
     resolveProvider: async (agentConfig) => {
-      activeEnv = resolveDesktopRuntimePolicyEnv({
-        env: args.env,
-        agentConfig,
-      });
+      const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
       activeAgentToolNames = buildDesktopLocalPolicyToolNames({
-        toolNames: agentConfig.toolNames,
-        env: activeEnv,
+        requestedToolNames,
+        hostRuntimeConfig,
       });
       const workspaceMode = resolveDesktopRuntimeWorkspaceMode({
         agentConfig,
@@ -272,7 +264,7 @@ export function createDesktopAgentRuntimeActions(args: {
       workspaceSession = await activateWorkspaceSession(activationSession, {
         agentKey: agentConfig.key,
         mode: workspaceMode,
-        env: activeEnv,
+        env: args.env,
         prepareTaskWorkspace: args.prepareTaskWorkspace ?? ((prepareArgs) => prepareGitTaskWorkspace({
           ...prepareArgs,
           cwd: args.cwd,
@@ -286,13 +278,14 @@ export function createDesktopAgentRuntimeActions(args: {
         agentConfig,
         fetchImpl: args.fetchImpl,
         tools: buildDesktopOpenAiTools({
-          toolNames: agentConfig.toolNames,
-          env: activeEnv,
+          requestedToolNames,
+          hostRuntimeConfig,
         }),
       });
     },
     executeTool: (call) => executeLocalToolWithPolicy({
-      env: activeEnv,
+      env: args.env,
+      hostRuntimeConfig,
       agentToolNames: activeAgentToolNames,
       call,
       executors,
@@ -329,6 +322,7 @@ export async function runDesktopAgentRuntimeTurn(
 ): Promise<LocalAgentTurnResult> {
   const actions = createDesktopAgentRuntimeActions({
     env: input.env,
+    hostRuntimeConfig: input.hostRuntimeConfig,
     store: input.store,
     now: input.now ?? Date.now,
     createId: input.createId ?? createDesktopAgentRuntimeDialogId,

package/server/handlers/desktopLlamaRuntimeHandler.ts

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join, posix, win32 } from "node:path";
 
 import { isPidRunning } from "../../../scripts/helpers/devProcessGuard";
 import {
@@ -22,10 +23,12 @@ const JSON_HEADERS = {
   "content-type": "application/json; charset=utf-8",
 };
 
-type DesktopLlamaRuntimeResponse = Omit<DesktopLlamaRuntimeSnapshot, "state"> & {
-  state: DesktopLlamaRuntimeSnapshot["state"] | "starting";
-  accepted?: boolean;
-};
+type DesktopLlamaRuntimeResponse = Omit<DesktopLlamaRuntimeSnapshot, "state"> & {
+  state: DesktopLlamaRuntimeSnapshot["state"] | "starting";
+  accepted?: boolean;
+};
+
+export type DesktopProviderRuntimeSnapshot = DesktopLlamaRuntimeResponse;
 
 type DesktopLlamaRuntimeHandlerController = {
   status: () => Promise<DesktopLlamaRuntimeSnapshot>;
@@ -36,12 +39,13 @@ type DesktopLlamaRuntimeHandlerController = {
   }>;
 };
 
-type DesktopLlamaRuntimeHandlerDeps = {
-  isDesktopMode?: () => boolean;
-  controller?: DesktopLlamaRuntimeHandlerController;
-  logger?: Pick<Console, "error">;
-  repoRoot?: string;
-};
+type DesktopLlamaRuntimeHandlerDeps = {
+  isDesktopMode?: () => boolean;
+  controller?: DesktopLlamaRuntimeHandlerController;
+  logger?: Pick<Console, "error">;
+  repoRoot?: string;
+  env?: NodeJS.ProcessEnv;
+};
 
 const json = (data: unknown, status = 200) =>
   new Response(JSON.stringify(data), {
@@ -49,7 +53,7 @@ const json = (data: unknown, status = 200) =>
     headers: JSON_HEADERS,
   });
 
-const defaultIsDesktopMode = () => process.env.NOLO_DESKTOP === "1";
+const defaultIsDesktopMode = () => process.env.NOLO_DESKTOP === "1";
 
 const notDesktopResponse = () =>
   json({ error: "Desktop llama runtime is only available inside Nolo Desktop." }, 404);
@@ -66,11 +70,21 @@ export function configureDesktopLocalProviderEnv(config: Pick<LlamaLaunchConfig,
 function formatError(error: unknown, fallback: string): string {
   return error instanceof Error ? error.message : fallback;
 }
-
-function createDesktopLlamaRuntimeController(
-  repoRoot = process.cwd(),
-): DesktopLlamaRuntimeHandlerController {
-  const paths = resolveLlamaSupervisorPaths(repoRoot);
+
+export function resolveDesktopLlamaSupervisorLogDir(env: NodeJS.ProcessEnv): string | null {
+  const dbPath = env.NOLO_SERVER_DB_PATH?.trim();
+  if (!dbPath) return null;
+  const pathApi = dbPath.includes("\\") ? win32 : posix;
+  const channelDir = pathApi.dirname(pathApi.dirname(dbPath));
+  return pathApi.join(channelDir, "logs", "llama-supervisor");
+}
+
+function createDesktopLlamaRuntimeController(
+  repoRoot = process.cwd(),
+  env: NodeJS.ProcessEnv = process.env,
+): DesktopLlamaRuntimeHandlerController {
+  const desktopLogDir = resolveDesktopLlamaSupervisorLogDir(env);
+  const paths = resolveLlamaSupervisorPaths(desktopLogDir ? { logDir: desktopLogDir } : repoRoot);
 
   const ensureLogDir = async () => {
     await mkdir(paths.logDir, { recursive: true });
@@ -168,9 +182,24 @@ function createDesktopLlamaRuntimeController(
     return config;
   };
 
-  const probeHealth = (
-    config: Pick<LlamaLaunchConfig, "host" | "port" | "healthPath" | "modelsPath">,
-  ) => probeLlamaHealth(config);
+  const probeHealth = (
+    config: Pick<LlamaLaunchConfig, "host" | "port" | "healthPath" | "modelsPath">,
+  ) => probeLlamaHealth(config);
+
+  const resolveConfiguredLaunchConfig = async (): Promise<LlamaLaunchConfig | null> => {
+    const storedState = await readStoredState();
+    const localConfig = await readLocalConfigFile();
+    const config = resolveLlamaLaunchConfig({
+      storedConfig: {
+        ...(storedState?.launchConfig ?? {}),
+        ...(localConfig ?? {}),
+      },
+    });
+    if (config) {
+      configureDesktopLocalProviderEnv(config);
+    }
+    return config;
+  };
 
   const stopManagedServer = () =>
     stopManagedLlamaServer({
@@ -189,9 +218,9 @@ function createDesktopLlamaRuntimeController(
       logFilePath: paths.logFile,
     });
 
-  const runtimeController = createLlamaRuntimeController({
-    readStoredState,
-    readLocalConfigFile,
+  const runtimeController = createLlamaRuntimeController({
+    readStoredState,
+    readLocalConfigFile,
     readManagedPid,
     readWatchPid,
     isPidRunning,
@@ -200,14 +229,17 @@ function createDesktopLlamaRuntimeController(
     readLogTail: () => readLogTail(40),
   });
 
-  return {
-    status: () => runtimeController.status(),
-    stop: () => runtimeController.stop(),
-    start: () =>
-      startLlamaRuntime({
-        resolveLaunchConfigOrThrow,
-        writeStoredState,
-        probeHealth,
+  return {
+    status: async () => {
+      await resolveConfiguredLaunchConfig();
+      return runtimeController.status();
+    },
+    stop: () => runtimeController.stop(),
+    start: () =>
+      startLlamaRuntime({
+        resolveLaunchConfigOrThrow,
+        writeStoredState,
+        probeHealth,
         readManagedPid,
         isPidRunning,
         stopManagedServer,
@@ -249,13 +281,13 @@ function buildResponseSnapshot(
   return snapshot;
 }
 
-export function createDesktopLlamaRuntimeHandlers(
-  deps: DesktopLlamaRuntimeHandlerDeps = {},
-) {
-  const isDesktopMode = deps.isDesktopMode ?? defaultIsDesktopMode;
-  const runtimeController =
-    deps.controller ?? createDesktopLlamaRuntimeController(deps.repoRoot);
-  const logger = deps.logger ?? console;
+export function createDesktopLlamaRuntimeHandlers(
+  deps: DesktopLlamaRuntimeHandlerDeps = {},
+) {
+  const isDesktopMode = deps.isDesktopMode ?? defaultIsDesktopMode;
+  const runtimeController =
+    deps.controller ?? createDesktopLlamaRuntimeController(deps.repoRoot, deps.env);
+  const logger = deps.logger ?? console;
 
   let activeStartTask: Promise<void> | null = null;
   let activeStartToken = 0;
@@ -267,8 +299,8 @@ export function createDesktopLlamaRuntimeHandlers(
     lastStartError = null;
   };
 
-  const readSnapshot = async () =>
-    buildResponseSnapshot(await runtimeController.status(), activeStartTask, lastStartError);
+  const readSnapshot = async () =>
+    buildResponseSnapshot(await runtimeController.status(), activeStartTask, lastStartError);
 
   const trackStartTask = (task: Promise<void>) => {
     const taskToken = ++activeStartToken;
@@ -348,13 +380,15 @@ export function createDesktopLlamaRuntimeHandlers(
     return json({ error: "Unsupported action" }, 400);
   };
 
-  return {
-    handleGet,
-    handlePost,
-  };
-}
-
-const defaultHandlers = createDesktopLlamaRuntimeHandlers();
-
-export const handleDesktopLlamaRuntimeGet = defaultHandlers.handleGet;
-export const handleDesktopLlamaRuntimePost = defaultHandlers.handlePost;
+  return {
+    readSnapshot,
+    handleGet,
+    handlePost,
+  };
+}
+
+const defaultHandlers = createDesktopLlamaRuntimeHandlers();
+
+export const readDesktopProviderRuntimeSnapshot = defaultHandlers.readSnapshot;
+export const handleDesktopLlamaRuntimeGet = defaultHandlers.handleGet;
+export const handleDesktopLlamaRuntimePost = defaultHandlers.handlePost;

package/server/handlers/desktopUpdaterHandler.ts

@@ -1,9 +1,25 @@
+import {
+  normalizeDesktopReleaseManifest,
+  type DesktopReleasePlatform,
+} from "../../app/constants/desktopReleaseManifest";
+import { createDesktopUpdaterSnapshot } from "../../desktop/desktopUpdaterState";
+import type { DesktopUpdaterReleaseArtifact } from "../../desktop/desktopUpdatePolicy";
+
 const JSON_HEADERS = {
   "content-type": "application/json; charset=utf-8",
 };
 
 let activeOperation: "check" | "download" | "apply" | null = null;
 let activeTask: Promise<void> | null = null;
+const DESKTOP_MANIFEST_CACHE_TTL_MS = 30_000;
+const manifestCache = new Map<
+  string,
+  {
+    fetchedAt: number;
+    artifact: DesktopUpdaterReleaseArtifact | null;
+    error: string | null;
+  }
+>();
 
 const isDesktopMode = () => process.env.NOLO_DESKTOP === "1";
 
@@ -17,12 +33,70 @@ const notDesktopResponse = () =>
   json({ error: "Desktop updater is only available inside Nolo Desktop." }, 404);
 
 const loadDesktopRuntime = async () => import("electrobun/bun");
+type DesktopRuntimeModule = Awaited<ReturnType<typeof loadDesktopRuntime>>;
+type UpdaterInstance = DesktopRuntimeModule["Updater"];
+
+const resolveDesktopReleasePlatform = (): DesktopReleasePlatform =>
+  process.platform === "win32"
+    ? "windows"
+    : process.platform === "darwin"
+      ? "macos"
+      : "linux";
+
+const resolveDesktopManifestUrl = (baseUrl: string) =>
+  `${baseUrl.replace(/\/+$/, "")}/desktop-release-manifest.json`;
 
 const latestStatus = (Updater: Awaited<ReturnType<typeof loadDesktopRuntime>>["Updater"]) => {
   const history = Updater.getStatusHistory();
   return history.length > 0 ? history[history.length - 1] : null;
 };
 
+const readPublishedReleaseArtifact = async (
+  baseUrl: string,
+  platform: DesktopReleasePlatform
+) => {
+  const cacheKey = `${platform}:${baseUrl.replace(/\/+$/, "")}`;
+  const cached = manifestCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < DESKTOP_MANIFEST_CACHE_TTL_MS) {
+    return cached;
+  }
+
+  try {
+    const response = await fetch(resolveDesktopManifestUrl(baseUrl), {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+      },
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    const manifest = normalizeDesktopReleaseManifest(await response.json());
+    if (!manifest) {
+      throw new Error("invalid manifest payload");
+    }
+
+    const artifact = manifest.artifacts[platform];
+    const result = {
+      fetchedAt: Date.now(),
+      artifact: artifact ? { platform, ...artifact } : null,
+      error: artifact ? null : `manifest is missing a ${platform} artifact`,
+    };
+    manifestCache.set(cacheKey, result);
+    return result;
+  } catch (error) {
+    const result = {
+      fetchedAt: Date.now(),
+      artifact: null,
+      error:
+        error instanceof Error ? error.message : "failed to fetch desktop release manifest",
+    };
+    manifestCache.set(cacheKey, result);
+    return result;
+  }
+};
+
 const getUpdaterSnapshot = async () => {
   const { BuildConfig, Updater } = await loadDesktopRuntime();
   const [buildConfig, version, hash, channel, baseUrl] = await Promise.all([
@@ -32,9 +106,16 @@ const getUpdaterSnapshot = async () => {
     Updater.localInfo.channel(),
     Updater.localInfo.baseUrl(),
   ]);
-
-  return {
+  const platform = resolveDesktopReleasePlatform();
+  const updateInfo = Updater.updateInfo?.() ?? null;
+  const shouldLoadReleaseArtifact = Boolean(updateInfo?.updateAvailable || updateInfo?.updateReady);
+  const releaseArtifactState = shouldLoadReleaseArtifact
+    ? await readPublishedReleaseArtifact(baseUrl, platform)
+    : { artifact: null, error: null };
+
+  return createDesktopUpdaterSnapshot({
     desktop: true,
+    platform,
     activeOperation,
     localInfo: {
       version,
@@ -43,10 +124,12 @@ const getUpdaterSnapshot = async () => {
       baseUrl,
     },
     buildConfig,
-    updateInfo: Updater.updateInfo?.() ?? null,
+    updateInfo,
     latestStatus: latestStatus(Updater),
     statusHistory: Updater.getStatusHistory(),
-  };
+    releaseArtifact: releaseArtifactState.artifact,
+    manifestError: releaseArtifactState.error,
+  });
 };
 
 const runOperation = (
@@ -79,6 +162,22 @@ const runOperation = (
   return true;
 };
 
+const OPERATION_EXECUTORS: Record<
+  "check" | "download" | "apply",
+  { resetHistory?: boolean; run: (updater: UpdaterInstance) => Promise<void> }
+> = {
+  check: {
+    resetHistory: true,
+    run: (updater) => updater.checkForUpdate(),
+  },
+  download: {
+    run: (updater) => updater.downloadUpdate(),
+  },
+  apply: {
+    run: (updater) => updater.applyUpdate(),
+  },
+};
+
 export const handleDesktopUpdaterGet = async () => {
   if (!isDesktopMode()) return notDesktopResponse();
 
@@ -104,27 +203,36 @@ export const handleDesktopUpdaterPost = async (req: Request) => {
 
   const action = body.action;
 
-  if (action === "check") {
-    runOperation("check", async () => {
-      const { Updater } = await loadDesktopRuntime();
-      await Updater.checkForUpdate();
-    }, true);
-    return json(await getUpdaterSnapshot(), 202);
-  }
-
-  if (action === "download") {
-    runOperation("download", async () => {
-      const { Updater } = await loadDesktopRuntime();
-      await Updater.downloadUpdate();
-    });
-    return json(await getUpdaterSnapshot(), 202);
-  }
+  if (action === "check" || action === "download" || action === "apply") {
+    const snapshot = await getUpdaterSnapshot();
+    if (action !== "check" && snapshot.summary.primaryAction !== action) {
+      return json(
+        {
+          error:
+            snapshot.summary.statusMessage ??
+            `Desktop updater is not ready to ${action} right now.`,
+        },
+        409
+      );
+    }
 
-  if (action === "apply") {
-    runOperation("apply", async () => {
-      const { Updater } = await loadDesktopRuntime();
-      await Updater.applyUpdate();
-    });
+    const operation = OPERATION_EXECUTORS[action];
+    const started = runOperation(
+      action,
+      async () => {
+        const { Updater } = await loadDesktopRuntime();
+        await operation.run(Updater);
+      },
+      operation.resetHistory ?? false
+    );
+    if (!started) {
+      return json(
+        {
+          error: `Desktop updater is already busy with ${activeOperation ?? "another operation"}.`,
+        },
+        409
+      );
+    }
     return json(await getUpdaterSnapshot(), 202);
   }
 

package/server/handlers/favoriteHandlers.ts

@@ -1,10 +1,11 @@
 // server/api/favoriteHandlers.ts
 
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import {
   createFavoriteKey,
   createFavoriteStatsKey,
 } from "../../database/keys";
+import { writeStoreOps } from "../../database/server/storeBatchCompat";
 import { isTombstoneRecord } from "../../database/tombstones";
 
 import type { ApiContext, ApiError } from "../api/types";
@@ -21,6 +22,8 @@ import {
   ListFavoritesResult,
 } from "../../app/favorite/type";
 
+const getFavoriteStore = () => getServerAuthorityStore();
+
 function toTimeMs(t: unknown) {
   if (typeof t === "number") return t;
   const n = Date.parse(String(t ?? 0));
@@ -109,6 +112,7 @@ function resolveFavoriteKeysByKey(
 
 /** 安全 get：不存在时返回 undefined，而不是抛错 */
 async function safeGet<T>(key: string): Promise<T | undefined> {
+  const serverDb = getFavoriteStore();
   try {
     const record = await serverDb.get(key);
     return isTombstoneRecord(record) ? undefined : record;
@@ -138,6 +142,7 @@ async function setFavoriteState(
   desiredFavoriteState: boolean,
   favoritedAt?: number
 ): Promise<ToggleFavoriteResult> {
+  const serverDb = getFavoriteStore();
   const resolved = resolveFavoriteKeysByKey(targetType, userId, targetKey);
   const {
     relKey,
@@ -213,7 +218,7 @@ async function setFavoriteState(
     }
   }
 
-  await serverDb.batch(ops);
+  await writeStoreOps(serverDb, ops);
 
   return buildFavoriteResult(
     targetType,
@@ -302,6 +307,7 @@ async function listFavoritesForUser(
   targetType: ListableFavoriteTargetType,
   userId: string
 ): Promise<ListFavoritesResult> {
+  const serverDb = getFavoriteStore();
   const normalizedTargetType =
     targetType === "doc" || targetType === "content" ? "page" : targetType;