@moxxy/cli 0.9.0 → 0.10.0

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { z as z$1, defineProvider, definePlugin, defineTool, MoxxyError, writeFileAtomic, asTurnId, defineMode, asPluginId, defineChannel, defineTunnelProvider, spawnCliTunnel, isCliTunnelAvailable, createMutex, defineWorkflowExecutor, toFriendlyError, estimateTextTokens, classifyHttpStatus, createStuckLoopDetector, runCompactionIfNeeded, runElisionIfNeeded, collectProviderStream, usageEventFields, isContextOverflowError, emitRequestsAndDetectStuck, executeToolUses, buildSystemPromptWithSkills, projectMessages, defineCompactor, defineCacheStrategy, denyByDefaultResolver, createAllowListResolver, moxxyPath, zodToJsonSchema, runSingleShotTurn, bearerTokenMatches, resolveChannelToken, rotateChannelToken, estimateContextTokens as estimateContextTokens$1, readRequestBody, MOXXY_WS_SUBPROTOCOL, defineEmbedder, bearerGuard, tokenFromWsProtocolHeader, skillFrontmatterSchema, asSkillId, getInstallHint, moxxyHome, defineTranscriber, summarizeTokensByModel, migrateModeName, createDeferredPermissionResolver, classifyNetworkError, addModelTotals, ISOLATION_RANK, moxxyPackageSchema, defineCommand, createCallbackResolver, autoAllowResolver, asSessionId, asToolCallId, defineViewRenderer, DEFAULT_VIEW_TAGS, isSafeViewUrl, evaluateToolRule, summarizeSessionTokensFromEvents, computeElisionState, toolResultStubbed, toolResultStub, toolResultBytes, conversationalStubbed, conversationalStub, asEventId } from '@moxxy/sdk';
+import { z as z$1, defineProvider, definePlugin, defineTool, MoxxyError, writeFileAtomic, asTurnId, defineMode, asPluginId, defineChannel, defineTunnelProvider, spawnCliTunnel, isCliTunnelAvailable, createMutex, defineWorkflowExecutor, toFriendlyError, estimateTextTokens, classifyHttpStatus, createStuckLoopDetector, runCompactionIfNeeded, runElisionIfNeeded, collectProviderStream, usageEventFields, isContextOverflowError, emitRequestsAndDetectStuck, executeToolUses, buildSystemPromptWithSkills, projectMessages, defineCompactor, defineCacheStrategy, denyByDefaultResolver, createAllowListResolver, moxxyPath, zodToJsonSchema, runSingleShotTurn, bearerTokenMatches, resolveChannelToken, rotateChannelToken, estimateContextTokens as estimateContextTokens$1, readRequestBody, MOXXY_WS_SUBPROTOCOL, defineEmbedder, migrateModeName, bearerGuard, tokenFromWsProtocolHeader, skillFrontmatterSchema, asSkillId, getInstallHint, moxxyHome, defineTranscriber, summarizeTokensByModel, createDeferredPermissionResolver, classifyNetworkError, addModelTotals, ISOLATION_RANK, moxxyPackageSchema, defineCommand, createCallbackResolver, autoAllowResolver, asSessionId, asToolCallId, defineViewRenderer, DEFAULT_VIEW_TAGS, isSafeViewUrl, evaluateToolRule, summarizeSessionTokensFromEvents, computeElisionState, toolResultStubbed, toolResultStub, toolResultBytes, conversationalStubbed, conversationalStub, asEventId } from '@moxxy/sdk';
 import * as fs27 from 'fs';
 import fs27__default, { existsSync, promises, ReadStream, readFileSync, statSync, readdirSync, mkdirSync, writeFileSync, unlinkSync, renameSync, watch, createReadStream } from 'fs';
 import * as path3 from 'path';
@@ -1376,6 +1376,13 @@ var init_providers = __esm({
       defs = /* @__PURE__ */ new Map();
       instances = /* @__PURE__ */ new Map();
       active = null;
+      /**
+       * Names the user disabled. Kept name-based (not def-based) so it can be
+       * seeded from preferences BEFORE the plugins register their defs — boot
+       * order doesn't matter. A disabled provider stays registered/listable but
+       * can't be activated.
+       */
+      disabled = /* @__PURE__ */ new Set();
       /**
        * Register a provider def. Throws on duplicate — use `replace()` for
        * explicit overwrite. Matches the semantics of `tools` and `channels`.
@@ -1404,10 +1411,32 @@ var init_providers = __esm({
       list() {
         return [...this.defs.values()];
       }
+      /**
+       * Enable/disable a provider by name. Disabling the ACTIVE provider is
+       * refused — switch first, then disable — so a session never ends up with an
+       * active-but-disabled provider. Unknown names are accepted (the set seeds
+       * from preferences before plugins register), except when disabling via a
+       * live toggle is meaningless because the provider is active.
+       */
+      setEnabled(name, enabled) {
+        if (!enabled && this.active === name) {
+          throw new Error(`Cannot disable the active provider "${name}" \u2014 switch providers first.`);
+        }
+        if (enabled)
+          this.disabled.delete(name);
+        else
+          this.disabled.add(name);
+      }
+      isEnabled(name) {
+        return !this.disabled.has(name);
+      }
       setActive(name, config) {
         const def = this.defs.get(name);
         if (!def)
           throw new Error(`Provider not registered: ${name}`);
+        if (this.disabled.has(name)) {
+          throw new Error(`Provider "${name}" is disabled \u2014 enable it first.`);
+        }
         let instance = this.instances.get(name);
         if (!instance) {
           instance = def.createClient(config ?? {});
@@ -3081,6 +3110,7 @@ var init_session = __esm({
       readyProviders;
       credentialResolver;
       mcpAdmin;
+      providerAdmin;
       workflows;
       pluginsAdmin;
       dispatcher;
@@ -3262,7 +3292,8 @@ var init_session = __esm({
             // are the ones the desktop's "Fetch live" affordance targets;
             // they advertise this via the provider-admin factory by
             // setting `supportsLiveModelDiscovery: true` on their def.
-            supportsLiveModelDiscovery: p3.supportsLiveModelDiscovery === true
+            supportsLiveModelDiscovery: p3.supportsLiveModelDiscovery === true,
+            enabled: this.providers.isEnabled(p3.name)
           })),
           activeMode,
           activeModeBadge,
@@ -127441,6 +127472,15 @@ function noteTemperatureUnsupported() {
     console.debug("[openai-codex] ProviderRequest.temperature is not supported by the Codex Responses backend (gpt-5 reasoning models reject sampling params); ignoring it.");
   }
 }
+var maxTokensNoteShown = false;
+function noteMaxTokensUnsupported() {
+  if (maxTokensNoteShown)
+    return;
+  maxTokensNoteShown = true;
+  if (process.env.MOXXY_DEBUG) {
+    console.debug("[openai-codex] ProviderRequest.maxTokens is not supported by the Codex Responses backend (400 Unsupported parameter: max_output_tokens); ignoring it.");
+  }
+}
 function toResponsesBody(req, opts = {}) {
   const instructions = extractSystemText(req.messages, req.system) || DEFAULT_INSTRUCTIONS;
   const body = {
@@ -127458,7 +127498,7 @@ function toResponsesBody(req, opts = {}) {
   if (opts.sessionHint)
     body.prompt_cache_key = opts.sessionHint;
   if (req.maxTokens !== void 0)
-    body.max_output_tokens = req.maxTokens;
+    noteMaxTokensUnsupported();
   if (req.temperature !== void 0)
     noteTemperatureUnsupported();
   return body;
@@ -134757,7 +134797,7 @@ function isRunnerUp(socketPath = runnerSocketPath()) {
 
 // ../runner/dist/server.js
 init_dist();
-var RUNNER_PROTOCOL_VERSION = 6;
+var RUNNER_PROTOCOL_VERSION = 7;
 var MIN_COMPATIBLE_PROTOCOL_VERSION = 1;
 var RunnerMethod = {
   /** client->server: handshake; returns the initial info snapshot. */
@@ -134782,6 +134822,12 @@ var RunnerMethod = {
   ModeSetActive: "mode.setActive",
   /** client->server: switch the active provider (server resolves credentials). */
   ProviderSetActive: "provider.setActive",
+  /** client->server: enable/disable a provider (v7; persists to preferences). */
+  ProviderSetEnabled: "provider.setEnabled",
+  /** client->server: re-probe every provider's credentials → readyProviders (v7). */
+  ProviderRefreshReady: "provider.refreshReady",
+  /** client->server: patch a stored (runtime-registered) provider's config (v7). */
+  ProviderConfigure: "provider.configure",
   /** client->server: persist an allow-always permission rule. */
   PermissionAddAllow: "permission.addAllow",
   /** client->server: run a registered slash command on the runner. */
@@ -134877,6 +134923,19 @@ var providerSetActiveParamsSchema = z.object({
   name: z.string(),
   config: z.record(z.unknown()).optional()
 });
+var providerSetEnabledParamsSchema = z.object({
+  name: z.string().min(1),
+  enabled: z.boolean()
+});
+var providerConfigureParamsSchema = z.object({
+  name: z.string().min(1),
+  patch: z.object({
+    baseURL: z.string().url().optional(),
+    defaultModel: z.string().min(1).optional(),
+    envVar: z.string().regex(/^[A-Z][A-Z0-9_]*$/).optional(),
+    models: z.array(z.object({ id: z.string().min(1), contextWindow: z.number() }).passthrough()).min(1).optional()
+  })
+});
 var permissionAddAllowParamsSchema = z.object({
   name: z.string(),
   reason: z.string().optional()
@@ -134983,6 +135042,9 @@ var RunnerServer = class {
     peer.handle(RunnerMethod.SetResolver, (raw) => this.handleSetResolver(client, raw));
     peer.handle(RunnerMethod.ModeSetActive, (raw) => this.handleModeSetActive(raw));
     peer.handle(RunnerMethod.ProviderSetActive, (raw) => this.handleProviderSetActive(raw));
+    peer.handle(RunnerMethod.ProviderSetEnabled, (raw) => this.handleProviderSetEnabled(raw));
+    peer.handle(RunnerMethod.ProviderRefreshReady, () => this.handleProviderRefreshReady());
+    peer.handle(RunnerMethod.ProviderConfigure, (raw) => this.handleProviderConfigure(raw));
     peer.handle(RunnerMethod.PermissionAddAllow, (raw) => this.handlePermissionAddAllow(raw));
     peer.handle(RunnerMethod.CommandRun, (raw) => this.handleCommandRun(raw));
     peer.handle(RunnerMethod.Transcribe, (raw) => this.handleTranscribe(raw));
@@ -135058,6 +135120,7 @@ var RunnerServer = class {
           turnId,
           ...error2 ? { error: error2 } : {}
         });
+        this.broadcastInfo();
       }
     });
     return { turnId };
@@ -135122,6 +135185,54 @@ var RunnerServer = class {
     this.broadcastInfo();
     return {};
   }
+  async handleProviderSetEnabled(raw) {
+    const { name, enabled } = providerSetEnabledParamsSchema.parse(raw);
+    if (!this.session.providers.list().some((p3) => p3.name === name)) {
+      throw new Error(`Provider not registered: ${name}`);
+    }
+    this.session.providers.setEnabled(name, enabled);
+    void (async () => {
+      const prefs = await loadPreferences();
+      const current = new Set(prefs.disabledProviders ?? []);
+      if (enabled)
+        current.delete(name);
+      else
+        current.add(name);
+      await savePreferences({ disabledProviders: [...current] });
+    })();
+    this.broadcastInfo();
+    return {};
+  }
+  async handleProviderRefreshReady() {
+    const resolver2 = this.session.credentialResolver;
+    if (resolver2) {
+      const ready = /* @__PURE__ */ new Set();
+      const active = this.session.providers.getActiveName();
+      if (active)
+        ready.add(active);
+      for (const p3 of this.session.providers.list()) {
+        if (ready.has(p3.name))
+          continue;
+        try {
+          await resolver2(p3.name);
+          ready.add(p3.name);
+        } catch {
+        }
+      }
+      this.session.readyProviders = ready;
+    }
+    this.broadcastInfo();
+    return {};
+  }
+  async handleProviderConfigure(raw) {
+    const { name, patch } = providerConfigureParamsSchema.parse(raw);
+    const admin = this.session.providerAdmin;
+    if (!admin)
+      throw new Error("provider admin not supported on this runner");
+    await admin.configure(name, patch);
+    this.broadcastInfo();
+    return {};
+  }
   async handlePermissionAddAllow(raw) {
     const { name, reason } = permissionAddAllowParamsSchema.parse(raw);
     await this.session.permissions.addAllow({ name, ...reason ? { reason } : {} });
@@ -135397,6 +135508,7 @@ var RemoteSession = class {
   requirements;
   permissions;
   mcpAdmin;
+  providerAdmin;
   workflows;
   /**
    * Turns that completed before their `runTurn` stream was registered. A fast
@@ -135410,6 +135522,8 @@ var RemoteSession = class {
   permissionResolver = null;
   approvalResolver = null;
   info = null;
+  /** Subscribers to `info.changed` pushes (see {@link onInfoChanged}). */
+  infoListeners = /* @__PURE__ */ new Set();
   /**
    * The protocol version the SERVER reported at attach. Defaults to our own
    * version until the handshake resolves. Version-specific client methods (the
@@ -135435,6 +135549,12 @@ var RemoteSession = class {
     });
     this.peer.on(RunnerNotification.InfoChanged, (params) => {
       this.info = params.info;
+      for (const fn of this.infoListeners) {
+        try {
+          fn(this.info);
+        } catch {
+        }
+      }
     });
     this.peer.on(RunnerNotification.ReplayStart, (params) => {
       const { fromSeq } = params;
@@ -135472,6 +135592,7 @@ var RemoteSession = class {
     this.requirements = { check: () => ({ ready: false, issues: [] }) };
     this.permissions = this.makePermissionsView();
     this.mcpAdmin = this.makeMcpAdminView();
+    this.providerAdmin = this.makeProviderAdminView();
     this.workflows = this.makeWorkflowsView();
   }
   /**
@@ -135537,6 +135658,16 @@ var RemoteSession = class {
   getInfo() {
     return this.requireInfo();
   }
+  /**
+   * Subscribe to runner `info.changed` pushes (registry snapshot changes —
+   * provider/mode/MCP/workflow mutations, including ones made by tools inside
+   * a turn). Fires after the local `getInfo()` mirror has been updated, so a
+   * listener can re-read it synchronously. Returns an unsubscribe fn.
+   */
+  onInfoChanged(fn) {
+    this.infoListeners.add(fn);
+    return () => this.infoListeners.delete(fn);
+  }
   async *runTurn(prompt, opts = {}) {
     const result = await this.peer.request(RunnerMethod.RunTurn, {
       prompt,
@@ -135740,6 +135871,27 @@ var RemoteSession = class {
       detach: (name) => this.peer.request(RunnerMethod.McpDetach, { name })
     };
   }
+  // Provider management (protocol v7): backs the desktop's interactive
+  // Settings → Providers tab. Gated on the SERVER's reported version so a v7
+  // client attached to an older runner (a desktop whose JS hot-update outran
+  // its bundled CLI) gets a clear "update the CLI" error instead of a raw
+  // method-not-found.
+  makeProviderAdminView() {
+    return {
+      setEnabled: async (name, enabled) => {
+        this.requireServerProtocol(7, "Enabling/disabling a provider");
+        await this.peer.request(RunnerMethod.ProviderSetEnabled, { name, enabled });
+      },
+      refreshReady: async () => {
+        this.requireServerProtocol(7, "Re-probing provider credentials");
+        await this.peer.request(RunnerMethod.ProviderRefreshReady, {});
+      },
+      configure: async (name, patch) => {
+        this.requireServerProtocol(7, "Configuring a provider");
+        await this.peer.request(RunnerMethod.ProviderConfigure, { name, patch });
+      }
+    };
+  }
   makeWorkflowsView() {
     return {
       list: () => this.peer.request(RunnerMethod.WorkflowList),
@@ -138037,6 +138189,51 @@ var testProviderInput = z$1.object({
   baseURL: z$1.string().url().describe("Vendor API base URL to probe, e.g. https://api.deepseek.com."),
   keyName: z$1.string().regex(/^[A-Z][A-Z0-9_]*$/).describe("NAME of the vault secret holding the API key (e.g. DEEPSEEK_API_KEY). The key is resolved from the vault inside the tool \u2014 never ask the user for the plaintext key and never pass one as a tool argument. Have them store it first: /vault set <NAME> <key>.")
 });
+function buildProviderAdminPluginWithApi(opts) {
+  const { providerRegistry, configPath } = opts;
+  const api = {
+    configure: async (name, patch) => {
+      const cfg = await readProvidersConfig(configPath);
+      const entry = cfg.providers.find((p3) => p3.name === name);
+      if (!entry) {
+        throw new MoxxyError({
+          code: "CONFIG_INVALID",
+          message: `provider-admin: no stored provider named "${name}" \u2014 only runtime-registered (providers.json) providers are configurable; built-ins are code.`
+        });
+      }
+      const next = {
+        ...entry,
+        ...patch.baseURL ? { baseURL: patch.baseURL } : {},
+        ...patch.defaultModel ? { defaultModel: patch.defaultModel } : {},
+        ...patch.envVar ? { envVar: patch.envVar } : {},
+        ...patch.models && patch.models.length > 0 ? { models: patch.models } : {}
+      };
+      if (!next.models.some((m3) => m3.id === next.defaultModel)) {
+        throw new MoxxyError({
+          code: "CONFIG_INVALID",
+          message: `provider-admin: defaultModel "${next.defaultModel}" is not in the models list (${next.models.map((m3) => m3.id).join(", ")}).`
+        });
+      }
+      const def = buildProviderDef(next);
+      const hadDef = providerRegistry.list().some((p3) => p3.name === name);
+      if (hadDef)
+        providerRegistry.replace(def);
+      else
+        providerRegistry.register(def);
+      try {
+        await upsertStoredProvider(next, configPath);
+      } catch (err) {
+        const prev = buildProviderDef(entry);
+        if (hadDef)
+          providerRegistry.replace(prev);
+        else
+          providerRegistry.unregister(name);
+        throw err;
+      }
+    }
+  };
+  return { plugin: buildProviderAdminPlugin(opts), api };
+}
 function buildProviderAdminPlugin(opts) {
   const { providerRegistry, configPath } = opts;
   return definePlugin({
@@ -144027,20 +144224,25 @@ function formatCatalog(entries, emptyLabel) {
 }
 async function draftWorkflow(provider, model, intent, signal, opts = {}) {
   let accumulated = "";
+  let truncated = false;
+  const ceiling = provider.models.find((m3) => m3.id === model)?.maxOutputTokens;
+  const budget = Math.min(opts.maxTokens ?? DEFAULT_MAX_TOKENS, ceiling ?? Number.POSITIVE_INFINITY);
   for await (const event of provider.stream({
     model,
     system: buildSystemPrompt(opts),
     messages: [{ role: "user", content: [{ type: "text", text: `Build a workflow for: ${intent}` }] }],
-    maxTokens: opts.maxTokens ?? DEFAULT_MAX_TOKENS,
+    maxTokens: budget,
     signal
   })) {
     if (event.type === "text_delta")
       accumulated += event.delta;
+    if (event.type === "message_end")
+      truncated = event.stopReason === "max_tokens";
     if (event.type === "error")
       throw new Error(`workflow_create: provider error: ${event.message}`);
   }
   const raw = extractYamlBlock(accumulated);
-  return { raw, parse: parseWorkflowYaml(raw) };
+  return { raw, parse: parseWorkflowYaml(raw), truncated };
 }
 function extractYamlBlock(s2) {
   const fence = /```(?:ya?ml)?\n([\s\S]*?)```/.exec(s2);
@@ -144119,7 +144321,7 @@ function createTool(deps) {
       if (!drafted.parse.ok || !drafted.parse.workflow) {
         throw new MoxxyError({
           code: "TOOL_ERROR",
-          message: `workflow_create: the model did not produce a valid workflow (${drafted.parse.errors.join("; ")}). Try a more specific intent.`
+          message: drafted.truncated ? "workflow_create: the draft hit the output-token limit before the YAML was complete. Try a simpler intent, or split the workflow into smaller ones." : `workflow_create: the model did not produce a valid workflow (${drafted.parse.errors.join("; ")}). Try a more specific intent.`
         });
       }
       const created = await deps.store.create(drafted.parse.workflow, scope);
@@ -145292,10 +145494,11 @@ function buildBuiltinsCore(args) {
     // ~/.moxxy/providers.json; the plugin's onInit re-registers them on
     // every boot. Pairs with the `add-provider` skill which walks the
     // model through gathering baseURL + models + key.
-    {
-      name: "@moxxy/plugin-provider-admin",
-      plugin: buildProviderAdminPlugin({ providerRegistry: session.providers })
-    },
+    (() => {
+      const { plugin: plugin4, api } = buildProviderAdminPluginWithApi({ providerRegistry: session.providers });
+      session.providerAdmin = api;
+      return { name: "@moxxy/plugin-provider-admin", plugin: plugin4 };
+    })(),
     // Admin tools (mcp_add_server, mcp_list_servers, mcp_remove_server,
     // mcp_test_server) plus the boot-time lazy attach. Passing the
     // session's live tool registry enables both hot-attach for runtime
@@ -145794,6 +145997,10 @@ async function activateProvider(args) {
   } else {
     for (let i2 = 0; i2 < candidates.length; i2++) {
       const candidate = candidates[i2];
+      if (!session.providers.isEnabled(candidate)) {
+        logger.warn("skipping disabled provider", { provider: candidate });
+        continue;
+      }
       const interactive = i2 === 0 && !skipKeyPrompt && process.stdin.isTTY === true;
       try {
         const resolved = await resolveProviderCredentials(candidate, vault, {
@@ -146002,6 +146209,13 @@ async function setupSessionWithConfig(opts) {
   });
   await selectEmbedder(session, rawConfig.embeddings, logger);
   for (const iso2 of session.isolators.list()) security.registry.register(iso2);
+  try {
+    const bootPrefs = await loadPreferences();
+    for (const name of bootPrefs.disabledProviders ?? []) {
+      session.providers.setEnabled(name, false);
+    }
+  } catch {
+  }
   const { credentialResolver } = await activateProvider({
     session,
     config,