@ordewell/web 0.11.1 → 0.11.3

package/AUTHORS.md

@@ -27,6 +27,10 @@ record of who built what, rather than `git log`.
 - [@haltingstate](https://github.com/haltingstate) — made the terminal UI's
   stepper say what a saved step does next, instead of encoding it in a
   sentinel index (#123).
+- [@Logic769](https://github.com/Logic769) — made `/resume` an alias of
+  `/sessions` in the planner chat (#139).
+- Hanbin Tan ([@hskl18](https://github.com/hskl18)) — documented how
+  planners and runners get their models and credentials (#140).
 
 Thank you. Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
 

package/dist/server/main.js

@@ -407,6 +407,8 @@ var OrchestratorPool = class {
   sequence = /* @__PURE__ */ new Map();
   registry = new core.RunnerRegistry();
   modelResolver;
+  /** A host that supplied its own resolver answers for every workspace, as a supplied probe does. */
+  suppliedModelResolver;
   runnerInstallation;
   /**
    * A host that supplied its own probe (a test, or a surface that owns one).
@@ -419,11 +421,19 @@ var OrchestratorPool = class {
   settingsService = new core.SettingsService();
   plannerModelMemory = new core.PlannerModelMemory(this.settingsService);
   /**
-   * The model a settings write picked in this daemon. The environment's model
-   * is otherwise inherited, and an agent planning only because detection
-   * found it does not plan with an inherited model it cannot be shown to run.
+   * The model a settings write picked in this daemon, and the workspace it was
+   * picked in. The environment's model is otherwise inherited, and an agent
+   * planning only because detection found it does not plan with an inherited
+   * model it cannot be shown to run. The pick is that workspace's: another
+   * may name another account, whose catalog judges the model afresh.
    */
   pickedModel;
+  /**
+   * The last planner write a route made, so each lands after the ones made
+   * before it: a switch still waiting for its catalog must not write over a
+   * pick made while it waited (ADR-0040).
+   */
+  plannerWrites = Promise.resolve();
   runner;
   /** One probe per daemon, asked again whenever the runner list is refreshed (ADR-0033). */
   codexSandbox;
@@ -438,7 +448,10 @@ var OrchestratorPool = class {
       env: () => core.workspaceEnvOf(process.cwd()),
       workspace: () => process.cwd()
     });
-    this.modelResolver = deps.modelResolver ?? new core.ModelResolver(this.registry, new WebConfig());
+    this.suppliedModelResolver = deps.modelResolver !== void 0;
+    this.modelResolver = deps.modelResolver ?? new core.ModelResolver(this.registry, new WebConfig(), {
+      env: async () => ({ ...process.env, ...await core.workspaceEnvOf(process.cwd()) })
+    });
     this.codexSandbox = deps.codexSandbox ?? new core.CodexSandboxAvailability(this.registry, { spawn: child_process.spawn, fetch: globalThis.fetch }, { cwd: process.cwd(), env: process.env });
     this.leaseHost = deps.leaseHost;
     this.isolationPreview = deps.isolationPreview ?? core.createIsolationPreview({ config: new WebConfig() });
@@ -618,7 +631,7 @@ var OrchestratorPool = class {
       core.ensureStateDirIgnored(workspace);
       core.assertWorkspaceIsProject(workspace);
     }
-    const config = this.plannerConfig(modelOverride);
+    const config = this.plannerConfig(modelOverride, workspace);
     const fsAdapter = new PoolFileSystem(workspace);
     const broadcast = (msg) => this.broadcast(sessionId, msg);
     const runner = new PoolAwareRunner(sessionId, broadcast, this.runner);
@@ -637,7 +650,7 @@ var OrchestratorPool = class {
       broadcast,
       // The notification channel above is silent here; this is how a client hears how the run isolates.
       onNotice: (notice) => this.broadcast(sessionId, notice),
-      modelResolver: this.modelResolver,
+      modelResolver: this.resolverFor(workspace),
       settings: () => this.runtimeSettings(),
       sessionId,
       ...this.leaseHost ? { leaseHost: this.leaseHost } : {}
@@ -650,13 +663,13 @@ var OrchestratorPool = class {
    * lists are handed over as a reader, not a snapshot, so a credential change
    * reaches a session that is already open.
    */
-  plannerConfig(modelOverride) {
+  plannerConfig(modelOverride, workspace, catalog = (provider) => this.plannerCatalogFor(provider, workspace)) {
     return new WebConfig({
       enabledRunners: this.enabledRunnerOverride(),
       modelOverride,
       providerModelLists: () => this.cachedProviderLists,
-      pickedModel: () => this.pickedModel,
-      agentCatalog: (provider) => this.plannerCatalogFor(provider).map((model) => model.id)
+      pickedModel: () => this.pickedModel?.workspace === workspaceKey(workspace) ? this.pickedModel : void 0,
+      agentCatalog: (provider) => catalog(provider).map((model) => model.id)
     });
   }
   /**
@@ -679,8 +692,13 @@ var OrchestratorPool = class {
       return enabled ? current.includes(id) ? current : [...current, id] : current.filter((r) => r !== id);
     });
   }
-  getSettings(sessionId) {
-    const config = this.plannerConfig();
+  /**
+   * What `sessionId`, or a client in `workspace`, plans with: the planner's
+   * model is judged against that workspace's runner catalog (see
+   * {@link settingsWorkspace}).
+   */
+  getSettings(sessionId, workspace) {
+    const config = this.plannerConfig(void 0, this.settingsWorkspace(sessionId, workspace));
     const userSettings = this.settingsService.getAll();
     const live = sessionId ? this.sessions.get(sessionId) : void 0;
     return {
@@ -709,45 +727,106 @@ var OrchestratorPool = class {
    * they were opened with. Throws a {@link RunSettingsError}, saving nothing,
    * for a value out of range.
    */
-  updateRunSettings(changes, sessionId) {
+  updateRunSettings(changes, sessionId, workspace) {
     this.settingsService.updateRunSettings(changes);
     if (sessionId) this.sessions.get(sessionId)?.applyRunSettings(changes);
-    return this.getSettings(sessionId);
+    return this.getSettings(sessionId, workspace);
+  }
+  /**
+   * The workspace whose runner catalog a settings read or write is judged
+   * against: an open session's own, else the one the client says it is in.
+   * Without either the daemon's cwd stands in. One daemon serves several
+   * workspaces, and each may name another Claude account in its environment.
+   */
+  settingsWorkspace(sessionId, workspace) {
+    return (sessionId ? this.sessions.get(sessionId)?.workspaceRoot : void 0) ?? workspace;
   }
   /**
    * The catalog `selectPlanner` should judge `provider`'s
    * remembered model against — a harness planner's own runner catalog, or the
    * cross-provider picker list for a vendor (ADR-0009), same split as
    * `plannerModelItems` in the TUI reducer. Read from whatever the resolver
-   * has already cached so this stays synchronous; a cold cache degrades to an
-   * empty catalog rather than kicking off discovery mid-settings-write.
+   * has already cached so this stays synchronous; the routes discover it
+   * first where it decides the answer ({@link discoverPlannerCatalogs},
+   * {@link writeSettings}), and a catalog still cold degrades to an empty one
+   * rather than kicking off discovery mid-settings-write.
    */
-  plannerCatalogFor(provider) {
-    const runner = core.runnerForProvider(provider);
-    if (runner) {
-      return this.modelResolver.getCachedRunnerModels(runner).map((m) => ({ id: m.modelId, variants: m.variants }));
-    }
-    return this.modelResolver.getCachedPickerOptions().map((o) => ({ id: o.id }));
+  plannerCatalogFor(provider, workspace) {
+    return this.resolverFor(workspace).cachedPlannerCatalog(provider);
+  }
+  /**
+   * Discover the runner catalog a settings read for `workspace` is judged
+   * against, when the read consults one not yet held. Most reads consult
+   * none — a vendor planner, a model picked in that workspace, an agent's
+   * alias or remembered pick — and answer at once, however slow the runner
+   * is to list its models (ADR-0040). Only a configured model whose owner
+   * only the catalog can tell waits: a cold one would report the wrong model.
+   * Never throws: a catalog that cannot be discovered stays empty.
+   */
+  async discoverPlannerCatalogs(sessionId, requestWorkspace) {
+    const workspace = this.settingsWorkspace(sessionId, requestWorkspace);
+    const consulted = [];
+    void this.plannerConfig(void 0, workspace, (provider) => {
+      consulted.push(provider);
+      return this.plannerCatalogFor(provider, workspace);
+    }).planner;
+    await this.discoverUnheld(workspace, consulted);
+  }
+  /**
+   * {@link updateSettings} as a route makes it. A write that changes who plans
+   * lands after the planner writes made before it and, where its judgement
+   * reads a catalog not yet held, waits for that one; every other write — a
+   * key, an allowlist, a limit — lands at once (ADR-0040).
+   */
+  async writeSettings(changes, sessionId, requestWorkspace) {
+    const change = plannerChangeOf(changes, admittedEnv(changes)?.accepted);
+    if (!changesPlanner(change)) return this.updateSettings(changes, sessionId, requestWorkspace);
+    const turn = this.plannerWrites.then(async () => {
+      const workspace = this.settingsWorkspace(sessionId, requestWorkspace);
+      const judging = this.catalogJudging(change, workspace);
+      await this.discoverUnheld(workspace, judging ? [judging] : []);
+      return this.updateSettings(changes, sessionId, requestWorkspace);
+    });
+    this.plannerWrites = turn.catch(() => void 0);
+    return turn;
+  }
+  /**
+   * The provider whose catalog `selectPlanner` reads to judge `change`: a
+   * switch with no model of its own restores the remembered pick only from
+   * the incoming catalog, and an agent's effort alone survives only where its
+   * model in effect offers it. An explicit model is the user's word whatever
+   * the catalog lists, and a cold catalog refuses no effort, so it reads none.
+   */
+  catalogJudging(change, workspace) {
+    const current = this.plannerProviderInEffect(workspace);
+    const provider = change.provider ?? current;
+    const model = change.model?.trim();
+    if (provider !== current) return model ? void 0 : provider;
+    return model === void 0 && change.effort !== void 0 && core.runnerForProvider(provider) ? provider : void 0;
+  }
+  /**
+   * Discover the catalogs of `providers` that `workspace`'s resolver does not
+   * hold yet; a held one, or a degraded one discovery still remembers,
+   * answers at once. Never throws.
+   */
+  async discoverUnheld(workspace, providers) {
+    const resolver = this.resolverFor(workspace);
+    await Promise.all([...new Set(providers)].map((provider) => resolver.plannerCatalog(provider)));
   }
   /**
    * The provider planning right now. A vendor planner is resolved from its
    * model id, so this is read again after a write rather than carried over.
    */
-  plannerProviderInEffect() {
-    return this.plannerConfig().aiProvider;
+  plannerProviderInEffect(workspace) {
+    return this.plannerConfig(void 0, workspace).aiProvider;
   }
-  updateSettings(changes, sessionId) {
-    const current = this.plannerConfig().planner;
-    const rawEnv = changes.env && typeof changes.env === "object" && !Array.isArray(changes.env) ? changes.env : void 0;
-    const admission = rawEnv ? core.admitSettingsEnv(rawEnv) : void 0;
+  updateSettings(changes, sessionId, requestWorkspace) {
+    const workspace = this.settingsWorkspace(sessionId, requestWorkspace);
+    const current = this.plannerConfig(void 0, workspace).planner;
+    const admission = admittedEnv(changes);
     const envChanges = admission ? admission.accepted : void 0;
-    const plannerChange = changes.inherited === true ? {} : {
-      provider: envChanges?.AI_PROVIDER,
-      model: envChanges?.ORCHESTRATOR_MODEL ?? stringField(changes.orchestratorModel),
-      effort: envChanges?.ORDEWELL_PLANNER_EFFORT ?? stringField(changes.plannerThinkingEffort)
-    };
-    const touchesPlanner = Object.values(plannerChange).some((v) => v !== void 0);
-    const selection = touchesPlanner ? core.selectPlanner(current, plannerChange, this.plannerModelMemory, this.plannerCatalogFor(plannerChange.provider ?? current.provider)) : void 0;
+    const plannerChange = plannerChangeOf(changes, envChanges);
+    const selection = changesPlanner(plannerChange) ? core.selectPlanner(current, plannerChange, this.plannerModelMemory, this.plannerCatalogFor(plannerChange.provider ?? current.provider, workspace)) : void 0;
     if (envChanges) {
       let touched = false;
       for (const [key, value] of Object.entries(envChanges)) {
@@ -763,14 +842,15 @@ var OrchestratorPool = class {
       }
       if (touched) {
         this.modelResolver.invalidate();
-        this.modelResolver.refreshRunnerModels();
         this.dropUnkeyedProviderLists();
       }
     }
     if (selection) {
       if (plannerChange.provider !== void 0 || plannerChange.model !== void 0) process.env.ORCHESTRATOR_MODEL = selection.next.model;
       process.env.ORDEWELL_PLANNER_EFFORT = selection.next.effort;
-      if (plannerChange.model !== void 0) this.pickedModel = { model: selection.next.model, provider: this.plannerProviderInEffect() };
+      if (plannerChange.model !== void 0) {
+        this.pickedModel = { model: selection.next.model, provider: this.plannerProviderInEffect(workspace), workspace: workspaceKey(workspace) };
+      }
     }
     if (changes.modelAllowlist && typeof changes.modelAllowlist === "object") {
       const allowlist = changes.modelAllowlist;
@@ -786,10 +866,10 @@ var OrchestratorPool = class {
     if (selection?.remember) {
       const { provider, model, effort } = selection.remember;
       const switched = provider !== current.provider;
-      this.plannerModelMemory.remember(switched ? provider : this.plannerProviderInEffect(), model, effort);
+      this.plannerModelMemory.remember(switched ? provider : this.plannerProviderInEffect(workspace), model, effort);
     }
     const rejectedEnvKeys = admission?.rejected ?? [];
-    const settings = this.getSettings(sessionId);
+    const settings = this.getSettings(sessionId, workspace);
     if (rejectedEnvKeys.length > 0) settings.rejectedEnvKeys = rejectedEnvKeys;
     if (selection?.recall) settings.switchRecall = selection.recall;
     return settings;
@@ -812,16 +892,22 @@ var OrchestratorPool = class {
     process.env.ORCHESTRATOR_MODEL = model;
     return model;
   }
-  async getProviderModels() {
+  /**
+   * The catalog as `workspace`'s runners see it: Claude Code's picker lineup
+   * follows the `CLAUDE_CONFIG_DIR` that workspace's environment sets.
+   * Without a workspace the daemon's cwd stands in.
+   */
+  async getProviderModels(workspace) {
     const config = new WebConfig();
+    const resolver = this.resolverFor(workspace);
     const runnerIds = this.registry.list().map((p) => p.manifest.name);
     const [runnerModels, providerLists] = await Promise.all([
-      this.modelResolver.modelsForRunners(runnerIds),
-      this.modelResolver.refresh(),
+      resolver.modelsForRunners(runnerIds),
+      resolver.refresh(),
       this.codexSandbox.ensure()
     ]);
-    const orchestratorModels = await this.modelResolver.pickerOptions();
-    const providerErrors = this.modelResolver.getDiscoveryErrors();
+    const orchestratorModels = await resolver.pickerOptions();
+    const providerErrors = resolver.getDiscoveryErrors();
     this.cachedProviderLists = providerLists;
     const allModels = [];
     const seen = /* @__PURE__ */ new Set();
@@ -840,16 +926,28 @@ var OrchestratorPool = class {
       models: allModels,
       modelsByRunner,
       modesByRunner: core.runnerModesFrom(this.registry, runnerIds),
-      orchestratorModel: this.plannerConfig().orchestratorModel,
+      orchestratorModel: this.plannerConfig(void 0, workspace).orchestratorModel,
       providers,
       orchestratorModels,
       providerErrors
     };
   }
-  getRunnerState() {
-    const config = this.plannerConfig();
+  getRunnerState(workspace) {
+    const config = this.plannerConfig(void 0, workspace);
     return { enabledRunners: config.enabledRunners, orchestratorModel: config.orchestratorModel };
   }
+  /**
+   * The resolver whose runner catalogs are discovered under `workspace`'s
+   * environment, the one its tasks are launched with. Kept per workspace,
+   * since one daemon serves several and a catalog is cached until refreshed;
+   * the vendor catalogs are shared by all of them.
+   */
+  resolverFor(workspace) {
+    if (this.suppliedModelResolver || !workspace) return this.modelResolver;
+    const key = workspaceKey(workspace);
+    if (key === workspaceKey(void 0)) return this.modelResolver;
+    return this.modelResolver.withRunnerEnv(key, async () => ({ ...process.env, ...await core.workspaceEnvOf(key) }));
+  }
   /**
    * The probe that judges a login for `workspace`, cached so its install and
    * auth verdicts survive between runner-list refreshes. Without a workspace
@@ -1079,9 +1177,26 @@ function getSessionList(workspace) {
 function removeSession(sessionId, workspace) {
   return core.deleteSession(sessionId, workspace);
 }
+function admittedEnv(changes) {
+  const raw = changes.env;
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? core.admitSettingsEnv(raw) : void 0;
+}
+function plannerChangeOf(changes, envChanges) {
+  return changes.inherited === true ? {} : {
+    provider: envChanges?.AI_PROVIDER,
+    model: envChanges?.ORCHESTRATOR_MODEL ?? stringField(changes.orchestratorModel),
+    effort: envChanges?.ORDEWELL_PLANNER_EFFORT ?? stringField(changes.plannerThinkingEffort)
+  };
+}
+function changesPlanner(change) {
+  return Object.values(change).some((v) => v !== void 0);
+}
 function stringField(value) {
   return typeof value === "string" ? value : void 0;
 }
+function workspaceKey(workspace) {
+  return path.resolve(workspace ?? process.cwd());
+}
 var InvalidBodyError = class extends Error {
   constructor(message) {
     super(message);
@@ -1224,7 +1339,7 @@ function plansRoute(pool2) {
       const queryRunners = c.req.query("runners");
       const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : queryRunners ? queryRunners.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
       const plan = await pool2.generatePlan(c.req.param("sessionId"), goal, runnerList, ws, model, { allowInit });
-      const { models, modelsByRunner } = await pool2.getProviderModels();
+      const { models, modelsByRunner } = await pool2.getProviderModels(ws);
       const notes = (pool2.session(c.req.param("sessionId")).planState?.conversationHistory ?? []).filter((e) => e.kind === "system").map((e) => e.content);
       return c.json({ plan: core.surfacePlanState(plan), models, modelsByRunner, ...notes.length > 0 ? { notes } : {} });
     } catch (err) {
@@ -1483,8 +1598,10 @@ function plansRoute(pool2) {
 function runnersRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", async (c) => {
-    const runners = await pool2.getInstalledRunners(c.req.query("workspace"));
-    const state = pool2.getRunnerState();
+    const workspace = c.req.query("workspace");
+    const runners = await pool2.getInstalledRunners(workspace);
+    await pool2.discoverPlannerCatalogs(void 0, workspace);
+    const state = pool2.getRunnerState(workspace);
     return c.json({
       runners,
       orchestratorModel: state.orchestratorModel
@@ -1507,7 +1624,7 @@ function runnersRoute(pool2) {
 function modelsRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", async (c) => {
-    const result = await pool2.getProviderModels();
+    const result = await pool2.getProviderModels(c.req.query("workspace"));
     return c.json(result);
   });
   return router;
@@ -1572,29 +1689,34 @@ function settingsRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", async (c) => {
     await core.installedPlannerDetected();
-    const settings = pool2.getSettings(c.req.query("sessionId") || void 0);
+    const sessionId = c.req.query("sessionId") || void 0;
+    const workspace = c.req.query("workspace") || void 0;
+    await pool2.discoverPlannerCatalogs(sessionId, workspace);
+    const settings = pool2.getSettings(sessionId, workspace);
     return c.json(settings);
   });
   router.patch("/", async (c) => {
     try {
       await core.installedPlannerDetected();
       const body = await jsonObject(c);
-      if (Object.keys(body).length === 0) {
+      if (Object.keys(body).every((key) => key === "workspace")) {
         return refuse(c, 400, "At least one setting field is required");
       }
-      const { run: run2, sessionId: namedSession, ...rest } = body;
+      const { run: run2, sessionId: namedSession, workspace: namedWorkspace, ...rest } = body;
       if (namedSession !== void 0 && typeof namedSession !== "string") return refuse(c, 400, "sessionId must be a string");
+      if (namedWorkspace !== void 0 && typeof namedWorkspace !== "string") return refuse(c, 400, "workspace must be a string");
       const sessionId = namedSession || void 0;
+      const workspace = namedWorkspace || void 0;
       if (run2 !== void 0) {
         if (!run2 || typeof run2 !== "object" || Array.isArray(run2)) return refuse(c, 400, "run must be an object of run settings");
         try {
-          pool2.updateRunSettings(run2, sessionId);
+          pool2.updateRunSettings(run2, sessionId, workspace);
         } catch (err) {
           if (err instanceof core.RunSettingsError) return refuse(c, 400, err.message);
           throw err;
         }
       }
-      const result = Object.keys(rest).length > 0 ? sessionId ? pool2.updateSettings(rest, sessionId) : pool2.updateSettings(rest) : pool2.getSettings(sessionId);
+      const result = Object.keys(rest).length > 0 ? await pool2.writeSettings(rest, sessionId, workspace) : pool2.getSettings(sessionId, workspace);
       return c.json(result);
     } catch (err) {
       return failure(c, err, "settings update", { fallback: 400 });