@followbin/dsh-selection 0.0.0-stage → 0.2.0

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+- insert:
+    - id: dsh-selection
+      name: '@followbin/dsh-selection'
+      config: {}

package/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36" fill="none"><path d="M7.5 12.5V10C7.5 8.62 8.62 7.5 10 7.5H12.5M23.5 7.5H26C27.38 7.5 28.5 8.62 28.5 10V12.5M28.5 23.5V26C28.5 27.38 27.38 28.5 26 28.5H23.5M12.5 28.5H10C8.62 28.5 7.5 27.38 7.5 26V23.5" stroke="url(#dsh-selection-frame)" stroke-width="2.4" stroke-linecap="round"/><path d="M18 10.8C18.655 14.77 21.23 17.345 25.2 18C21.23 18.655 18.655 21.23 18 25.2C17.345 21.23 14.77 18.655 10.8 18C14.77 17.345 17.345 14.77 18 10.8Z" fill="url(#dsh-selection-spark)" stroke="none"/><defs><linearGradient id="dsh-selection-frame" x1="7.5" y1="7.5" x2="28.5" y2="28.5" gradientUnits="userSpaceOnUse"><stop stop-color="#6AECB6"/><stop offset="1" stop-color="#37A6B1"/></linearGradient><linearGradient id="dsh-selection-spark" x1="10.8" y1="10.8" x2="25.2" y2="25.2" gradientUnits="userSpaceOnUse"><stop stop-color="#7CB7FF"/><stop offset="1" stop-color="#145AF3"/></linearGradient></defs></svg>

package/index.js

@@ -0,0 +1,41 @@
+// DSH plugin entry (Host side). Starts the selection service and mounts its HTTP API.
+// The settings page lives in client.js; the toolbar runs in a worker process (src/worker).
+import { join } from 'node:path'
+import { createHttpHandler, ROUTE } from './src/host/http.mjs'
+import { createLogger } from './src/host/log.mjs'
+import { createSelectionService } from './src/host/service.mjs'
+import { dataDirectory } from './src/shared/paths.mjs'
+
+export const name = 'dsh-selection'
+export const inject = ['webServer', 'connection']
+
+/**
+ * @param {any} ctx Cordis Host context.
+ * @param {{ promptForPermission?: boolean, force?: boolean }} [config] Row config from cordis.patch.yml.
+ *   `force` starts the toolbar outside DSH Desktop (only for a web Host on the user's own machine).
+ */
+export function apply(ctx, config = {}) {
+  const dataDir = dataDirectory()
+  const log = createLogger(join(dataDir, 'host.log'))
+  // The toolbar must appear on the user's screen, so it only runs where the Host shares their desktop.
+  const desktop = Boolean(process.versions.electron) || config.force === true
+  const service = createSelectionService({
+    // Looked up per request: the llm service may load after this plugin, or be swapped at runtime.
+    getLlm: () => ctx.get('llm'),
+    log,
+    dataDir,
+    desktop,
+    promptForPermission: config.promptForPermission !== false,
+  })
+  log('info', 'plugin started', { platform: process.platform, desktop })
+  ctx.effect(() => () => service.dispose(), 'dsh-selection: service')
+  ctx.on('llm/adapters-updated', () => service.invalidateModels())
+  ctx.effect(
+    () => ctx.webServer.register({
+      kind: 'prefix',
+      path: ROUTE,
+      handler: createHttpHandler(service, { log, connection: ctx.connection }),
+    }),
+    'dsh-selection: http routes',
+  )
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Selection assistant",
+    "description": "Select text in any app and let DSH translate, summarize, explain, answer or read it aloud."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "划词助手",
+    "description": "在任意应用里选中文字，用 DSH 翻译、总结、解释、追问或朗读。"
+  }
+}

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "@followbin/dsh-selection",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Select text in any app and let DSH translate, summarize, explain, answer or read it aloud.",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "selection",
+    "translate",
+    "popclip"
+  ],
+  "license": "MIT",
+  "author": "followbin",
+  "homepage": "https://github.com/followbin/dsh-selection#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/followbin/dsh-selection.git"
+  },
+  "bugs": {
+    "url": "https://github.com/followbin/dsh-selection/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "icon": "./icon.svg",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "icon.svg",
+    "locale/*.json",
+    "src",
+    "ui",
+    "vendor",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "selftest": "ELECTRON_RUN_AS_NODE=1 \"/Applications/DeepSeek Harness.app/Contents/MacOS/DeepSeek Harness\" scripts/selftest.mjs",
+    "dev": "ELECTRON_RUN_AS_NODE=1 \"/Applications/DeepSeek Harness.app/Contents/MacOS/DeepSeek Harness\" scripts/dev-host.mjs",
+    "vendor:selection-hook": "node scripts/vendor-selection-hook.mjs",
+    "screenshots": "ELECTRON_RUN_AS_NODE=1 \"/Applications/DeepSeek Harness.app/Contents/MacOS/DeepSeek Harness\" scripts/screenshots.mjs"
+  },
+  "dependencies": {
+    "@webviewjs/webview": "0.6.0"
+  },
+  "optionalDependencies": {
+    "@koromix/koffi-darwin-arm64": "3.3.6",
+    "@koromix/koffi-darwin-x64": "3.3.6",
+    "@koromix/koffi-win32-arm64": "3.3.6",
+    "@koromix/koffi-win32-x64": "3.3.6"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml",
+      "platforms": [
+        "darwin",
+        "win32"
+      ]
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-locale"
+      ]
+    }
+  },
+  "devDependencies": {
+    "jsdom": "26.1.0",
+    "react": "19.1.10",
+    "react-dom": "19.1.10"
+  }
+}

package/src/host/files.mjs

@@ -0,0 +1,29 @@
+// Writes a file so that readers see either the old or the new content, never half of it.
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export function writeFileAtomic(file, text) {
+  mkdirSync(dirname(file), { recursive: true })
+  const temporary = `${file}.${process.pid}.tmp`
+  writeFileSync(temporary, text, { mode: 0o600 })
+  try {
+    replaceFile(temporary, file)
+  } catch (error) {
+    try { unlinkSync(temporary) } catch { /* already gone */ }
+    throw error
+  }
+}
+
+// Windows refuses to replace a file another process has open (antivirus, indexer, sync clients),
+// usually for a few milliseconds.
+function replaceFile(source, target) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      renameSync(source, target)
+      return
+    } catch (error) {
+      if (process.platform !== 'win32' || attempt === 5 || !['EPERM', 'EBUSY', 'EACCES'].includes(error?.code)) throw error
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25 * attempt)
+    }
+  }
+}

package/src/host/http.mjs

@@ -0,0 +1,153 @@
+// HTTP API for the settings page, mounted on DSH's web server under /dsh-selection.
+// DSH's `connection` service is the gate: it fences Host/Origin (cross-site calls, DNS rebinding) and
+// requires the signed-in browser session, the same check DSH's own routes run. Writes must be JSON,
+// which keeps simple cross-site form posts out even before that check.
+import { BadRequest } from './service.mjs'
+
+export const ROUTE = '/dsh-selection'
+const MAX_BODY_BYTES = 256 * 1024
+const KEEPALIVE_MS = 25_000
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]'])
+
+/**
+ * @param {ReturnType<import('./service.mjs').createSelectionService>} service
+ * @param {{
+ *   log: (level: string, message: string, fields?: object) => void,
+ *   connection?: { requestRejection: (req: import('node:http').IncomingMessage) => number | undefined },
+ * }} options Without `connection` (tests, the dev runner) only loopback same-origin requests pass.
+ */
+export function createHttpHandler(service, { log, connection }) {
+  return async function handle(req, res) {
+    const url = new URL(req.url ?? '/', 'http://localhost')
+    const path = url.pathname.slice(ROUTE.length) || '/'
+    const status = connection ? connection.requestRejection(req) : localRejection(req)
+    if (status !== undefined) return sendJson(res, status, { error: status === 401 ? 'unauthorized' : 'forbidden' })
+    if (browserRejection(req)) return sendJson(res, 403, { error: 'forbidden' })
+    const writes = req.method === 'POST' || req.method === 'PUT'
+    if (writes && !isJson(req)) return sendJson(res, 415, { error: 'expected application/json' })
+    try {
+      switch (`${req.method} ${path}`) {
+        case 'GET /api/state':
+          return sendJson(res, 200, service.getState())
+        case 'GET /api/models':
+          return sendJson(res, 200, await service.listModels())
+        case 'GET /api/events':
+          return openEventStream(req, res, service)
+        case 'PUT /api/settings':
+          return sendJson(res, 200, { settings: service.saveSettings(await readJson(req)) })
+        case 'POST /api/settings/reset':
+          return sendJson(res, 200, { settings: service.resetSettings() })
+        case 'POST /api/models/test':
+          return sendJson(res, 200, await service.testModel())
+        case 'POST /api/skills/test':
+          return sendJson(res, 200, await service.testSkill(await readJson(req)))
+        case 'GET /api/usage':
+          return sendJson(res, 200, service.getUsage())
+        case 'POST /api/usage/reset':
+          return sendJson(res, 200, service.resetUsage())
+        case 'POST /api/worker/restart':
+          service.restartWorker()
+          return sendJson(res, 200, { ok: true })
+        case 'POST /api/permission/open':
+          service.openPermissionSettings()
+          return sendJson(res, 200, { ok: true })
+        default:
+          return sendJson(res, 404, { error: 'not found' })
+      }
+    } catch (error) {
+      if (error instanceof BadRequest) return sendJson(res, 400, { error: error.message })
+      log('error', 'request failed', { method: req.method, path, error: String(error?.message ?? error) })
+      return sendJson(res, 500, { error: 'internal error' })
+    }
+  }
+}
+
+/** Fetch metadata and Origin say the request comes from another site. Cheap, and true for any Host. */
+export function browserRejection(req) {
+  const site = req.headers['sec-fetch-site']
+  if (typeof site === 'string' && site !== 'same-origin' && site !== 'none') return true
+  const origin = req.headers.origin
+  if (typeof origin !== 'string' || origin === 'null') return false
+  try {
+    return new URL(origin).host !== req.headers.host
+  } catch {
+    return true
+  }
+}
+
+/** Fallback gate when DSH's connection service is absent: loopback only. */
+export function localRejection(req) {
+  const host = typeof req.headers.host === 'string' ? req.headers.host : ''
+  const hostname = host.startsWith('[') ? host.slice(0, host.indexOf(']') + 1) : host.split(':')[0].toLowerCase()
+  return LOOPBACK_HOSTS.has(hostname) ? undefined : 403
+}
+
+function isJson(req) {
+  return String(req.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let size = 0
+    req.on('data', (chunk) => {
+      size += chunk.length
+      if (size > MAX_BODY_BYTES) {
+        reject(new BadRequest('request body too large'))
+        req.destroy()
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8') || 'null'))
+      } catch {
+        reject(new BadRequest('invalid JSON'))
+      }
+    })
+    req.on('error', reject)
+  })
+}
+
+function sendJson(res, status, value) {
+  const body = JSON.stringify(value)
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'content-length': Buffer.byteLength(body),
+  })
+  res.end(body)
+}
+
+/**
+ * Server-sent events: `status`, `settings` and `navigate` (open the settings page). Every connection
+ * starts with the current status and settings, so a page that reconnects never edits stale values.
+ */
+function openEventStream(req, res, service) {
+  res.writeHead(200, {
+    'content-type': 'text/event-stream; charset=utf-8',
+    'cache-control': 'no-store',
+    connection: 'keep-alive',
+  })
+  let unsubscribe = () => {}
+  const keepalive = setInterval(() => res.write(': keepalive\n\n'), KEEPALIVE_MS)
+  const close = () => {
+    clearInterval(keepalive)
+    unsubscribe()
+  }
+  const write = (event, data) => {
+    if (event === 'closing') {
+      close()
+      res.end()
+      return
+    }
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
+  }
+  const { status, settings } = service.getState()
+  write('status', status)
+  write('settings', settings)
+  unsubscribe = service.subscribe(write)
+  req.on('close', close)
+  res.on('error', close)
+}

package/src/host/llm.mjs

@@ -0,0 +1,194 @@
+// Calls models through DSH's own `llm` service, so requests use whatever account or API key the user
+// already configured in DSH. Each skill click is one request with no tools and thinking off; Ask DSH
+// carries the earlier turns of its panel in that request.
+
+const PREFERRED_ROUTES = [
+  ['deepseek-account', 'deepseek-flash'],
+  ['deepseek-official', 'deepseek-flash'],
+]
+const MAX_OUTPUT_TOKENS = 4096
+// Silence limits rather than a total limit: a long, healthy answer keeps streaming as long as it needs.
+const FIRST_TOKEN_TIMEOUT_MS = 60_000
+const IDLE_TIMEOUT_MS = 45_000
+const ROUTE_CACHE_MS = 5 * 60_000
+
+/** @typedef {{ provider: string, providerName: string, model: string, modelName: string }} Route */
+
+export class ModelError extends Error {
+  /**
+   * @param {'NO_LLM' | 'NO_MODEL' | 'MODEL_FAILED' | 'EMPTY' | 'TIMEOUT'} code Stable code the UI translates.
+   * @param {string} [detail] Provider message, shown as a secondary line.
+   */
+  constructor(code, detail = '') {
+    super(detail || code)
+    this.code = code
+    this.detail = detail
+  }
+}
+
+/**
+ * @param {{ getLlm: () => any, log?: (level: string, message: string, fields?: object) => void }} options
+ */
+export function createModelClient({ getLlm, log }) {
+  let cache = null
+  let listing = null
+  // Bumped by invalidate(), so a listing already under way when DSH's providers change is not cached.
+  let generation = 0
+  // Routes that reject an "off" reasoning level; without this every click would prepare the call twice.
+  const withoutOff = new Set()
+
+  function llmService() {
+    const llm = getLlm()
+    if (!llm) throw new ModelError('NO_LLM')
+    return llm
+  }
+
+  /** Every provider/model pair DSH can currently call. Concurrent callers share one listing. */
+  function listRoutes({ fresh = false } = {}) {
+    if (!fresh && cache && Date.now() - cache.at < ROUTE_CACHE_MS) return Promise.resolve(cache.routes)
+    if (!fresh && listing) return listing
+    const current = readRoutes(generation).finally(() => {
+      if (listing === current) listing = null
+    })
+    listing = current
+    return current
+  }
+
+  async function readRoutes(started) {
+    const llm = llmService()
+    const providers = llm.listProviders()
+    // Each provider looks up its credentials and may fetch its model list, so ask them all at once.
+    const results = await Promise.allSettled(providers.map((provider) => llm.listModels(provider.id)))
+    const routes = []
+    let complete = true
+    results.forEach((result, index) => {
+      const provider = providers[index]
+      if (result.status === 'rejected') {
+        complete = false
+        log?.('warn', 'listing models failed', { provider: provider.id, error: String(result.reason?.message ?? result.reason) })
+        return
+      }
+      for (const model of result.value ?? []) {
+        routes.push({
+          provider: provider.id,
+          providerName: provider.displayName ?? provider.name ?? provider.label ?? provider.id,
+          model: model.id,
+          modelName: model.displayName ?? model.name ?? model.id,
+        })
+      }
+    })
+    // An empty or partial list is often minutes from being fixed (a sign-in, a provider hiccup);
+    // caching it would keep answering NO_MODEL, or a fallback route, after that.
+    if (started === generation) cache = complete && routes.length ? { at: Date.now(), routes } : null
+    return routes
+  }
+
+  /** The configured route if it still exists, otherwise DeepSeek Flash, otherwise the first route. */
+  async function resolveRoute(settings) {
+    const routes = await listRoutes()
+    if (routes.length === 0) throw new ModelError('NO_MODEL')
+    const { provider, model } = settings.model
+    const pick = (p, m) => routes.find((route) => route.provider === p && route.model === m)
+    if (provider && model && pick(provider, model)) return pick(provider, model)
+    for (const [p, m] of PREFERRED_ROUTES) if (pick(p, m)) return pick(p, m)
+    return routes[0]
+  }
+
+  /**
+   * Streams the reply text.
+   * @param {{
+   *   settings: import('./settings.mjs').Settings,
+   *   prompt: (route: Route) => { system: string, user: string },
+   *   signal: AbortSignal,
+   *   onUsage?: (usage: object) => void,
+   * }} request `prompt` runs once the route is known, so the request can name the model answering it.
+   *   `onUsage` receives DSH's token counts for the request, also when it fails or is cancelled.
+   * @returns {AsyncGenerator<string>}
+   */
+  async function* stream({ settings, prompt, signal, onUsage }) {
+    const llm = llmService()
+    const silence = new AbortController()
+    let timer = setTimeout(() => silence.abort(), FIRST_TOKEN_TIMEOUT_MS)
+    const combined = AbortSignal.any([signal, silence.signal])
+    const failed = (error) => {
+      if (signal.aborted) return signal.reason ?? new DOMException('Aborted', 'AbortError')
+      if (silence.signal.aborted) return new ModelError('TIMEOUT')
+      return error instanceof ModelError ? error : new ModelError('MODEL_FAILED', String(error?.message ?? error))
+    }
+    let usage = null
+    try {
+      const route = await abortable(resolveRoute(settings), combined)
+      const { system, user } = prompt(route)
+      const prepare = (effort) => llm.prepareCall({
+        provider: route.provider,
+        model: route.model,
+        maxTokens: MAX_OUTPUT_TOKENS,
+        ...effort ? { reasoningEffort: effort } : {},
+      }, combined)
+      const key = `${route.provider}\u0000${route.model}`
+      let prepared
+      if (withoutOff.has(key)) prepared = await prepare(null)
+      else {
+        try {
+          prepared = await prepare('off')
+        } catch (error) {
+          if (combined.aborted) throw error
+          // Routes without an "off" reasoning level reject it; their own default is the next best choice.
+          prepared = await prepare(null)
+          if (error?.code === 'UNSUPPORTED_REASONING_EFFORT') withoutOff.add(key)
+          log?.('info', 'reasoning effort off unavailable, using route default', { provider: route.provider, model: route.model, error: String(error?.message ?? error) })
+        }
+      }
+      const messages = [{ role: 'user', content: [{ type: 'text', text: user }] }]
+      let produced = false
+      for await (const chunk of prepared.stream({ ...prepared.config, system, messages, signal: combined })) {
+        clearTimeout(timer)
+        timer = setTimeout(() => silence.abort(), IDLE_TIMEOUT_MS)
+        if (chunk.type === 'text-delta' && chunk.text) {
+          produced = true
+          yield chunk.text
+        } else if (chunk.type === 'usage') {
+          usage = chunk.usage
+        } else if (chunk.type === 'finish') {
+          if (chunk.reason?.kind === 'error') throw new ModelError('MODEL_FAILED', chunk.reason.failure?.message ?? '')
+          if (chunk.reason?.kind === 'aborted') throw new DOMException('Aborted', 'AbortError')
+        }
+      }
+      if (!produced) throw new ModelError('EMPTY')
+    } catch (error) {
+      throw failed(error)
+    } finally {
+      clearTimeout(timer)
+      if (usage) {
+        try {
+          onUsage?.(usage)
+        } catch (error) {
+          log?.('warn', 'recording usage failed', { error: String(error?.message ?? error) })
+        }
+      }
+    }
+  }
+
+  /** Forgets what was learned about the routes, after DSH's providers or the chosen model change. */
+  function invalidate() {
+    generation += 1
+    cache = null
+    listing = null
+    withoutOff.clear()
+  }
+
+  return { listRoutes, resolveRoute, stream, invalidate }
+}
+
+/** Rejects as soon as the signal aborts, even if the work itself cannot be cancelled. */
+function abortable(promise, signal) {
+  if (signal.aborted) return Promise.reject(signal.reason)
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason)
+    signal.addEventListener('abort', onAbort, { once: true })
+    promise.then(
+      (value) => { signal.removeEventListener('abort', onAbort); resolve(value) },
+      (error) => { signal.removeEventListener('abort', onAbort); reject(error) },
+    )
+  })
+}

package/src/host/log.mjs

@@ -0,0 +1,40 @@
+// Small JSON-lines log under the plugin's data directory. It never records selected text or model
+// output, only events, counts and errors, so it is safe to attach to bug reports.
+import { appendFileSync, mkdirSync, renameSync, statSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+const MAX_BYTES = 1024 * 1024
+
+/**
+ * @param {string} file
+ * @param {{ echo?: boolean }} [options] Also print to stderr (useful when running outside DSH).
+ * @returns {(level: 'debug' | 'info' | 'warn' | 'error', message: string, fields?: object) => void}
+ */
+export function createLogger(file, { echo = false } = {}) {
+  let ready = false
+  return (level, message, fields = {}) => {
+    const record = { time: new Date().toISOString(), level, message }
+    // A field never replaces the record's own time, level or message.
+    for (const [key, value] of Object.entries(fields)) record[key in record ? `_${key}` : key] = value
+    const line = JSON.stringify(record)
+    if (echo) console.error(`[dsh-selection] ${line}`)
+    try {
+      if (!ready) {
+        mkdirSync(dirname(file), { recursive: true })
+        ready = true
+      }
+      if (statSize(file) > MAX_BYTES) renameSync(file, `${file}.1`)
+      appendFileSync(file, `${line}\n`, { mode: 0o600 })
+    } catch {
+      // Logging must never take the plugin down.
+    }
+  }
+}
+
+function statSize(file) {
+  try {
+    return statSync(file).size
+  } catch {
+    return 0
+  }
+}