@moguiyu/dsh-tavily 0.2.7 → 0.3.0

package/src/client.js

@@ -7,7 +7,6 @@ export const id = '@moguiyu/dsh-tavily'
 
 export function factory(require) {
   const react = require('react')
-  const _primitives = require('@deepseek-ai/dsh-client-ui-primitives')
 
   const inject = ['slots']
 
@@ -57,18 +56,6 @@ export function factory(require) {
     }, react.createElement(SvgIcon, { name: icon, size: 13 }))
   }
 
-  function Switch({ checked, disabled, label, onChange }) {
-    return react.createElement('button', {
-      type: 'button',
-      role: 'switch',
-      'aria-checked': checked === true,
-      'aria-label': label,
-      disabled: disabled || checked === null,
-      onClick: onChange,
-      style: { width: 36, height: 20, borderRadius: 10, border: '1px solid var(--dsw-alias-border-l2)', background: checked === true ? 'var(--dsw-alias-state-success-primary)' : 'var(--dsw-alias-bg-layer-1)', cursor: 'pointer', padding: 0, position: 'relative', flex: 'none', opacity: disabled ? 0.5 : 1 }
-    }, react.createElement('span', { style: { position: 'absolute', top: 2, left: checked === true ? 18 : 2, width: 14, height: 14, borderRadius: 7, background: '#fff', transition: 'left .12s ease' } }))
-  }
-
   function UsageCircle({ percent, size, label, onClick }) {
     const radius = 15
     const circumference = 2 * Math.PI * radius
@@ -83,9 +70,7 @@ export function factory(require) {
     )
   }
 
-  function TavilyCard() {
-    const [enabled, setEnabled] = react.useState(null)
-    const [expanded, setExpanded] = react.useState(false)
+  function TavilySettingsCard() {
     const [server, setServer] = react.useState(null)
     const [loadError, setLoadError] = react.useState(null)
     const [strategy, setStrategy] = react.useState('rotate')
@@ -101,13 +86,6 @@ export function factory(require) {
     const [usageError, setUsageError] = react.useState(null)
 
     const refresh = react.useCallback(async () => {
-      try {
-        const response = await fetch('/api/tavily-tool', { cache: 'no-store' })
-        const data = await response.json()
-        if (data.ok) { setEnabled(data.enabled); setLoadError(null) } else { setLoadError(data.error || 'Failed to load settings') }
-      } catch (error) {
-        setLoadError(String(error && error.message ? error.message : error))
-      }
       try {
         const response = await fetch('/api/tavily-manager', { cache: 'no-store' })
         const data = await response.json()
@@ -127,27 +105,6 @@ export function factory(require) {
 
     react.useEffect(() => { refresh() }, [refresh])
 
-    const toggleEnabled = async () => {
-      const next = enabled !== true
-      setBusy(true)
-      setNotice(null)
-      try {
-        const response = await fetch('/api/tavily-tool', {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ enabled: next })
-        })
-        const data = await response.json()
-        if (!data.ok) { setNotice({ error: data.error || 'Switch failed' }); return }
-        setEnabled(data.enabled)
-        setNotice({ ok: data.enabled ? 'Advanced tavily_search tool enabled.' : 'Advanced tavily_search tool disabled — built-in web_search is unchanged.' })
-      } catch (error) {
-        setNotice({ error: String(error && error.message ? error.message : error) })
-      } finally {
-        setBusy(false)
-      }
-    }
-
     const saveStrategy = async (next) => {
       setBusy(true)
       setNotice(null)
@@ -288,46 +245,12 @@ export function factory(require) {
     const headStyle = { textAlign: 'left', padding: '6px 8px', borderBottom: '1px solid var(--dsw-alias-border-l2)', fontSize: 12, color: 'var(--dsw-alias-label-tertiary)' }
     const cellStyle = { padding: '8px', verticalAlign: 'top' }
 
-    const isOff = enabled === false
-
-    // Card box mirrors the native plugin-config card (PluginCard.module.css,
-    // ui-settings-plugins): bg-layer-3 fill, .5px border-l4, 16px radius,
-    // hover/open border lift, and the open state's bg-layer-2 upgrade — so
-    // the card sits at the same elevation as native cards in dark mode too.
-    return react.createElement('div', { className: expanded ? 'dts-card dts-card-open' : 'dts-card', style: { minWidth: 0 } },
-      react.createElement('style', null, '.dts-card{border:.5px solid var(--dsw-alias-border-l4);border-radius:16px;background:var(--dsw-alias-bg-layer-3);transition:border-color .16s,background .16s}.dts-card:hover{border-color:var(--dsw-alias-label-dimmed)}.dts-card-open{background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-label-dimmed)}.dts-icon-btn:hover{background:var(--dsw-alias-interactive-bg-hover)}.dts-icon-btn:disabled{opacity:.4;cursor:default}.dts-icon-btn-danger:hover{background:var(--dsw-alias-interactive-bg-hover-danger)}'),
-      react.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: 12, padding: '12px 14px', minHeight: 52, boxSizing: 'border-box' } },
-        react.createElement('button', {
-          type: 'button',
-          'aria-expanded': expanded,
-          onClick: () => setExpanded((current) => !current),
-          style: { flex: 1, minWidth: 0, textAlign: 'left', background: 'none', border: 'none', padding: 0, cursor: 'pointer', display: 'flex', flexDirection: 'column', gap: 2, font: 'inherit', color: 'inherit' }
-        },
-          react.createElement('strong', { style: { fontSize: 14, fontWeight: 600, lineHeight: '20px', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, 'Tavily Search'),
-          react.createElement('span', { style: { fontSize: 12, lineHeight: '16px', color: 'var(--dsw-alias-label-tertiary)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, 'Advanced tavily_search tool · key rotation · usage')
-        ),
-        react.createElement('span', { style: { display: 'inline-flex', alignItems: 'center', gap: 6, flex: 'none' } },
-          react.createElement(Switch, { checked: enabled, disabled: busy, label: 'Advanced tavily_search tool enabled', onChange: toggleEnabled }),
-          react.createElement('button', {
-            type: 'button',
-            className: 'dts-icon-btn',
-            title: expanded ? 'Collapse' : 'Expand',
-            'aria-label': expanded ? 'Collapse' : 'Expand',
-            onClick: () => setExpanded((current) => !current),
-            style: { width: 26, height: 26, borderRadius: 6, border: 'none', background: 'transparent', color: 'var(--dsw-alias-label-tertiary)', cursor: 'pointer', display: 'inline-flex', alignItems: 'center', justifyContent: 'center', padding: 0 }
-          },
-            react.createElement('span', { style: { display: 'inline-flex', transform: expanded ? 'rotate(180deg)' : undefined, transition: 'transform .14s var(--ds-ease-in-out)' } },
-              react.createElement(_primitives.IconChevronDownOutline14, { size: 12, 'aria-hidden': 'true' })
-            )
-          )
-        )
-      ),
-      expanded && react.createElement('div', { style: { borderTop: '1px solid var(--dsw-alias-border-l2)', padding: '12px 14px', display: 'flex', flexDirection: 'column', gap: 16 } },
-        isOff
-          ? react.createElement('p', { style: { margin: 0, fontSize: 13, color: 'var(--dsw-alias-label-tertiary)' } },
-              'The advanced tavily_search tool is off. The built-in web_search keeps its native provider and is never replaced.'
-            )
-          : react.createElement(react.Fragment, null,
+    // The Plugins page draws the title, the icon, and the crumb — the
+    // `plugins.bundle.config` contract puts the form alone in the entry — so
+    // this renders no card chrome, no second heading, and no collapse.
+    return react.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: 16, minWidth: 0 } },
+      react.createElement('style', null, '.dts-icon-btn:hover{background:var(--dsw-alias-interactive-bg-hover)}.dts-icon-btn:disabled{opacity:.4;cursor:default}.dts-icon-btn-danger:hover{background:var(--dsw-alias-interactive-bg-hover-danger)}'),
+      react.createElement(react.Fragment, null,
               react.createElement('p', { style: { margin: 0, fontSize: 13, color: 'var(--dsw-alias-label-tertiary)' } },
                 'All keys are listed below; the green dot marks the first (primary) key. The tavily_search tool uses all keys according to the strategy. Built-in web_search is unaffected.'
               ),
@@ -439,21 +362,33 @@ export function factory(require) {
               usageError !== null && react.createElement('p', { style: { margin: 0, fontSize: 12, color: 'var(--dsw-alias-state-error-primary)' } }, String(usageError)),
               usage !== null && usage.ok === false && react.createElement('p', { style: { margin: 0, fontSize: 12, color: 'var(--dsw-alias-state-error-primary)' } }, String(usage.error))
             )
-      )
     )
   }
 
+  // The entry the Plugins page renders. The contract asks for two views:
+  // `summary` for the one-liner under the title, and `page` for the form with
+  // its own save control. The page supplies the title, icon, and crumb, so the
+  // summary is a plain string and the page view is the form alone — matching
+  // how the shipped cards (WebSearchCard and friends) are written.
+  function TavilyCard(props) {
+    if (props && props.view === 'summary') {
+      return 'Manage Tavily API keys and the key-usage strategy. The built-in web_search is never replaced.'
+    }
+    return react.createElement(TavilySettingsCard, null)
+  }
+
   function apply(ctx) {
-    ctx.slots.inject('settings.plugin.item', () => ctx.slots.register({
-      name: 'settings.plugin.item',
-      // rc.7 plugin management: this card is keyed by the settings namespace
-      // the Host serves (`tavily-search`); the Plugins configuration tab
-      // dispatches it when the namespace is present. The id/order/label props
-      // keep rc.6 list-slot deployments rendering the card as well.
-      key: 'tavily-search',
-      id: 'tavily-search',
-      order: 30,
-      label: 'Tavily Search'
+    // ONE slot. 0.1.6-alpha.2 moved plugin configuration to the sidebar
+    // Plugins page and retired `settings.plugin.item`. This package no longer
+    // registers a settings namespace, so the retired keyed slot has no key it
+    // could claim. On rc.7 through 0.1.6-alpha.1 the tools and routes work but
+    // this card has no host — see `docs/agents/plugin-design.md`.
+    ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({
+      name: 'plugins.bundle.config',
+      // Keyed by the bundle's package name. The Plugins page renders this on
+      // the @moguiyu/dsh-tavily bundle page, between its description and rows.
+      key: '@moguiyu/dsh-tavily',
+      id: '@moguiyu/dsh-tavily'
     }, TavilyCard))
   }
 

package/src/index.js

@@ -1,170 +1,43 @@
 /**
- * `@moguiyu/dsh-tavily` combined package: the advanced `tavily_search` model
- * tool plus the local HTTP backend for usage and key management. The
- * implementations live in the two standalone packages and are composed here,
- * so there is exactly one copy of each:
+ * `@moguiyu/dsh-tavily` — the combined plugin, and now the only package.
  *
- * - tool half — `@moguiyu/dsh-tool-tavily-search` {@link installTavilyTool};
- * - backend half — `@moguiyu/dsh-tavily-backend` {@link installBackend}.
+ * Both halves live here, so there is no cross-package contract left to skew:
  *
- * This package adds the plugin-management seam: the Host installs the
- * `tavily-search` settings section (the key the Plugins configuration tab
- * pairs the card against). The switch value lives both in that namespace and
- * in `~/.dsh/tavily-tool.json`; every write path converges on
- * `settings.update` (or the state file when no settings service exists).
+ * - the model tools (`tools.js`) — `tavily_search`, `tavily_extract`,
+ *   `tavily_map`, `tavily_crawl`, with key rotation and failover on 401/429;
+ * - key and usage management (`backend.js`) — `/api/tavily-usage` and
+ *   `/api/tavily-manager`;
+ * - the browser card (`client.js`) — keys, usage, and strategy.
  *
- * The switch owns the tool half's lifecycle DIRECTLY: it holds the disposer
- * returned by {@link installTavilyTool} and disposes / re-installs it in place.
- * Earlier versions instead restarted the composing row and let `apply()` re-run;
- * that is gone on purpose. A row restart on 0.1.6 re-mounts the fiber into a
- * scope the agent does not see, so the tools ended up registered nowhere and
- * stayed missing for every session until DSH restarted (AGENTS.md §9 gate 5).
- * Do not reintroduce the restart.
+ * Composing the plugin registers the tools. There is NO tool-level on/off:
+ * the Plugins page's own bundle toggle is the only one. Two earlier designs
+ * are gone deliberately, both recorded in `docs/agents/verification.md`:
  *
- * The settings-card switch controls ONLY the opt-in `tavily_search` tool. The
- * built-in `web_search` tool is never replaced: this package registers no web
- * search provider and never rewrites `web.searchProvider` — `web_search`
- * keeps its native provider.
+ * 1. A row restart. On 0.1.6 it re-mounts the fiber into a scope the agent
+ *    does not see, so the tools ended up registered nowhere and stayed
+ *    missing, process-wide, until dsh restarted.
+ * 2. A tool-level switch split across packages. The combined package needed a
+ *    disposer from the tool half, but its dependency range still allowed the
+ *    old tool half, so `installTavilyTool` returned `undefined` and turning
+ *    the switch off threw. One package removes the range as a failure mode.
+ *
+ * The built-in `web_search` tool is never replaced: no web search provider is
+ * registered, `web.searchProvider` / `DSH_WEB_SEARCH_PROVIDER` are never
+ * rewritten, and `ctx.web` is untouched.
  */
-import z from '@deepseek-ai/schemastery'
-import { isToolEnabled, installTavilyTool } from '@moguiyu/dsh-tool-tavily-search'
-import { installBackend, readToolState, restoreToolState, writeToolState } from '@moguiyu/dsh-tavily-backend'
+import { installTavilyTool } from './tools.js'
+import { installBackend } from './backend.js'
 
 export const name = 'dsh-tavily'
 
 export const inject = ['tools', 'webServer', 'credentials', 'systemPrompt']
 
-export const Config = z.object({
-  enabled: z.boolean().default(false),
-})
-
-/**
- * Settings namespace owned by this package. It is the join key between the
- * Host half and the browser card: the Plugins configuration tab serves this
- * namespace and dispatches the card registered under the same key. A plain
- * lowercase-hyphenated string, valid on every supported host line: rc.7/rc.8
- * treat the namespace as a branded string (runtime-identical), and 0.1.2
- * validates and brands it on registration (`settingsNamespace()` was
- * removed upstream).
- */
-export const TAVILY_NS = 'tavily-search'
-
-export function apply(ctx, config) {
-  // The switch value this fiber is acting on. Every write path updates it
-  // before (un)registering, so a watcher re-fired afterwards no-ops.
-  let lastApplied = isToolEnabled(config)
-  // Settings seam state: the attached provider (null on hosts without one)
-  // and the authoritative switch source — the resolved section while the
-  // provider is attached, the composition entry otherwise.
-  let settingsProvider = null
-  let settingsSource = () => config
-  // The live registration of the tool half, or null while it is off.
-  let disposeTools = null
-
-  /**
-   * Add or remove the tool half to match `enabled`. This is the whole switch:
-   * `installTavilyTool` hands back a disposer covering its tools and prompt
-   * sections, so turning the capability off is a disposal rather than a row
-   * restart. See the module header for why the restart is gone.
-   */
-  function setTools(enabled) {
-    if (enabled) {
-      if (disposeTools === null) disposeTools = installTavilyTool(ctx)
-      return
-    }
-    if (disposeTools !== null) {
-      const dispose = disposeTools
-      disposeTools = null
-      dispose()
-    }
-  }
-
-  // Seed from the composition entry / persisted switch, and hand the fiber the
-  // teardown so unloading the row leaves nothing registered.
-  setTools(lastApplied)
-  ctx.effect(() => () => { setTools(false) })
-
-  /** Persist the switch, then (un)register the tool half in place. */
-  async function applySwitchLocal(enabled) {
-    if (enabled === lastApplied) return
-    const previous = readToolState()
-    lastApplied = enabled
-    writeToolState(enabled)
-    try {
-      setTools(enabled)
-    } catch (error) {
-      lastApplied = previous !== null ? previous.enabled : (config.enabled !== false)
-      restoreToolState(previous)
-      setTools(lastApplied)
-      throw error
-    }
-  }
-
-  /** Re-judge the switch from a resolved settings value (either seam's shape). */
-  function applySwitchValue(value) {
-    const nextEnabled = value !== null && typeof value === 'object' && typeof value.enabled === 'boolean'
-      ? value.enabled
-      : false
-    applySwitchLocal(nextEnabled).catch((error) => {
-      ctx.logger.warn('tavily-search: applying settings switch failed: %s', error instanceof Error ? error.message : String(error))
-    })
-  }
-
-  // First-class settings integration: install the `tavily-search` section so
-  // the Plugins configuration surface serves it and pairs this package's
-  // card. Runtime-optional on purpose: the row boots (state-file path) even
-  // on hosts that never provide a settings service. Two host seams are
-  // supported by feature detection, so ONE package version covers both host
-  // lines:
-  //
-  // - 0.1.2 (`installSection`) — the row config is the composition entry
-  //   (base layer while a provider is attached, fallback value when one
-  //   detaches); `onChange` re-judges the switch on attach, on detach, and
-  //   on every committed change.
-  // - rc.7/rc.8 (`register`) — the row config is the composition base layer
-  //   and the scope watcher re-judges the switch on every committed change
-  //   (`applies: 'restart'`, the 0.2.0 behavior).
-  ctx.inject(['settings'], (settingsCtx) => {
-    const provider = settingsCtx.settings
-    try {
-      if (typeof provider.installSection === 'function') {
-        provider.installSection(ctx, TAVILY_NS, Config, config, {
-          setSource: (current) => { settingsSource = current },
-          onChange: () => { applySwitchValue(settingsSource()) },
-        })
-        settingsProvider = provider
-        return
-      }
-      if (typeof provider.register === 'function') {
-        const scope = provider.register(TAVILY_NS, Config, {
-          base: { enabled: config.enabled },
-          applies: 'restart',
-        })
-        if (scope !== undefined && scope !== null && typeof scope.watch === 'function') {
-          scope.watch((next) => { applySwitchValue(next) })
-          settingsProvider = provider
-        } else {
-          ctx.logger.warn('tavily-search: settings scope exposes no watcher; using the state-file path')
-        }
-        return
-      }
-      ctx.logger.warn('tavily-search: settings service exposes neither installSection nor register; using the state-file path')
-    } catch (error) {
-      ctx.logger.warn('tavily-search: settings section installation failed: %s', error instanceof Error ? error.message : String(error))
-    }
-  })
+export function apply(ctx) {
+  const disposeTools = installTavilyTool(ctx)
+  installBackend(ctx)
 
-  installBackend(ctx, {
-    enabled: () => isToolEnabled(config),
-    async applySwitch(enabled) {
-      // Every write converges on one pipeline: the settings namespace when a
-      // settings service is attached (its watcher persists and re-applies the
-      // switch in place), or the plain state-file path otherwise.
-      if (settingsProvider !== null) {
-        await settingsProvider.update(TAVILY_NS, { enabled })
-      } else {
-        await applySwitchLocal(enabled)
-      }
-    },
-  })
+  // The fiber owns the teardown: unloading the row — including the Plugins
+  // page's runtime unload on 0.1.6-alpha.2 — unregisters every tool and
+  // prompt section this row added.
+  ctx.effect(() => () => { disposeTools() })
 }

package/src/lib.js

@@ -0,0 +1,65 @@
+/**
+ * Pure helpers for the Tavily backend (exported for tests).
+ */
+import { readFileSync } from 'node:fs'
+
+export const STRATEGIES = ['rotate', 'low-usage-first', 'high-usage-first']
+
+export function isValidStrategy(value) {
+  return STRATEGIES.includes(value)
+}
+
+/**
+ * Mask a key for display: `first12…last4`; comma-separated lists are masked
+ * per part. Never reveals more than a fingerprint.
+ */
+export function maskValue(value) {
+  if (typeof value !== 'string' || value.length === 0) return ''
+  return value.split(',').map((part) => {
+    const p = part.trim()
+    if (p.length <= 12) return '••••'
+    return p.slice(0, 12) + '…' + p.slice(-4)
+  }).join(', ')
+}
+
+/** Split a comma-separated credential value into trimmed, deduped keys. */
+export function parseKeyList(value) {
+  if (typeof value !== 'string') return []
+  const seen = new Set()
+  const out = []
+  for (const part of value.split(',')) {
+    const key = part.trim()
+    if (key.length > 0 && !seen.has(key)) {
+      seen.add(key)
+      out.push(key)
+    }
+  }
+  return out
+}
+
+/**
+ * Order keys according to a strategy. `usageOf(key)` returns a number or null
+ * (unknown usage is treated as 0). `rotate` keeps the given order.
+ */
+export function orderKeys(values, strategy, usageOf) {
+  if (strategy === 'rotate') return [...values]
+  const usageOfKey = (value) => {
+    const usage = usageOf(value)
+    return usage !== null && typeof usage === 'number' ? usage : 0
+  }
+  const sorted = [...values]
+  sorted.sort((a, b) => strategy === 'low-usage-first'
+    ? usageOfKey(a) - usageOfKey(b)
+    : usageOfKey(b) - usageOfKey(a))
+  return sorted
+}
+
+/** Read a JSON object file; `fallback` on missing or unparsable content. */
+export function readJsonFile(path, fallback) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'))
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : fallback
+  } catch {
+    return fallback
+  }
+}