dsh-plugin-scys-mcp 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,123 @@
-# Temporary Holding Version
+# dsh-plugin-scys-mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+生财有术（scys.com）MCP 的 DeepSeek Harness 插件。装好后**打开浏览器授权一次**，就把 160 个站内工具接进 Harness：
+
+```
+mcp__scys-mcp__searchTopic      搜帖子
+mcp__scys-mcp__getDailyReport   生财日报
+mcp__scys-mcp__getMyInsight     我的画像
+mcp__scys-mcp__getUserInsight   用户画像
+...
+```
+
+不需要本地代理、不需要手工改配置、不需要额外进程；macOS / Windows / Linux 行为一致。
+连接中断时插件会自动重建传输并重试一次当前调用，已注册的工具不会消失。
+
+## 为什么需要插件
+
+DSH 自带的 `dsh-mcp-client` 只支持静态 `headers`，而 scys MCP 要求 OAuth 2.1（PKCE + 动态客户端注册）。本插件在 Harness 进程内完成授权并把令牌注入每个请求，因此不需要旁路进程。
+
+## 安装
+
+```bash
+# 从 npm（发布后）
+dsh plugin --profile desktop add dsh-plugin-scys-mcp
+
+# 或从本地目录 / tarball
+dsh plugin --profile desktop add file:/path/to/dsh-plugin-scys-mcp
+```
+
+也可以在 Web 侧边栏 **Plugins** 页搜索安装。安装后插件自带一行配置：
+
+```yaml
+- insert:
+    - id: mcp-scys-oauth
+      name: 'dsh-plugin-scys-mcp'
+      config:
+        serverName: scys-mcp
+```
+
+> 如果你之前手工加过 `mcp-scys` / `mcp-scys-oauth` 行，先删掉，避免同 `serverName` 冲突。
+
+## 首次授权
+
+插件启动时若没有有效令牌，会自动打开浏览器：
+
+1. 浏览器跳到 `https://mcp.scys.com/mcp-oauth/authorize?...`
+2. 用你的生财有术账号登录并同意授权
+3. 页面显示“授权成功”，回到 Harness —— 工具会在几秒内出现
+
+授权窗口最长等待 15 分钟。如果错过了，跟模型说一句“重新授权生财 MCP”，或直接调用 `mcp__scys-mcp__auth`，会重新打开授权页。
+
+## 令牌
+
+| 项 | 说明 |
+| --- | --- |
+| access token | 1 小时，到期前 60 秒自动刷新 |
+| refresh token | 每次刷新都会轮换，14 天窗口随之顺延 |
+| 存储位置 | `~/.dsh/mcp/scys-mcp/tokens.json`（Windows: `%USERPROFILE%\.dsh\mcp\scys-mcp\`） |
+| 客户端注册 | `client.json`（动态注册的 public client，绑定 `http://127.0.0.1:<port>/callback`） |
+
+令牌只在本地，插件直接访问 `mcp.scys.com`，不经过任何第三方。
+
+## 配置项
+
+| 字段 | 默认值 | 说明 |
+| --- | --- | --- |
+| `serverName` | `scys-mcp` | 工具前缀，`[A-Za-z0-9_-]{1,32}` |
+| `url` | `https://mcp.scys.com/shengcai-web/mcp` | MCP 端点 |
+| `port` | `18787` | 授权回调端口，占用时自动换空闲端口 |
+| `openBrowser` | `true` | 授权时是否自动打开浏览器 |
+| `toolCallTimeoutMs` | `120000` | 单次工具调用超时 |
+| `authorizeTimeoutMs` | `900000` | 授权等待上限 |
+
+## 故障排查
+
+看 `~/.dsh/mcp/scys-mcp/plugin.log`：
+
+- `registered N/M tools` —— 正常，N 应接近 160。
+- `register <tool> failed` —— 某个工具的 schema 超出 Harness 支持的子集，会被跳过，不影响其他工具。
+- `授权已失效` —— 重新授权：调用 `mcp__scys-mcp__auth`。
+- 端口被占 —— 自动改用空闲端口，无需处理。
+
+## 卸载
+
+```bash
+dsh plugin --profile desktop remove dsh-plugin-scys-mcp
+rm -rf ~/.dsh/mcp/scys-mcp      # 同时清除本地令牌
+```
+
+## 平台说明
+
+- **macOS**：`open` 打开默认浏览器；无需任何系统权限。
+- **Windows**：`rundll32 url.dll,FileProtocolHandler` 打开默认浏览器（不经 `cmd.exe`，URL 里的 `&` 不会被当成命令分隔符）；回调只监听 `127.0.0.1`，不会触发防火墙弹窗。
+- **Linux**：`xdg-open`。
+
+## 开发
+
+```bash
+node scripts/selftest.mjs   # 用已存令牌跑 initialize / tools/list / tools/call
+node scripts/plugin-test.mjs # 全链路离线测试：模拟 AS + MCP，验证授权、注册、断线重连
+```
+
+源码结构：
+
+| 文件 | 作用 |
+| --- | --- |
+| `lib/index.js` | 插件入口：连接、工具注册、`auth` 工具 |
+| `lib/oauth.js` | OAuth 2.1：发现、DCR、PKCE、刷新、回环回调 |
+| `lib/mcp.js` | Streamable HTTP 上的 JSON-RPC 客户端（JSON + SSE） |
+| `lib/store.js` | 本地令牌与客户端注册存储 |
+| `scripts/plugin-test.mjs` | 零网络的端到端测试（mock OAuth + mock MCP） |
+
+零运行时依赖，只用 Node 内置模块与全局 `fetch`。
+
+## 发布到 npm 前检查
+
+1. **包名**：如果 `dsh-plugin-scys-mcp` 已被占用，改用 scope，例如 `@yourname/dsh-plugin-scys-mcp`。
+2. **同步 patch 里的 name**：`cordis.patch.yml` 的 `name:` 必须和 package.json 的 `name` 完全一致，否则安装后加载不到插件。
+3. `npm pack` 检查内容（应为 `lib/*.js` + `cordis.patch.yml` + `README.md` + `package.json`）。
+4. `npm publish`（scoped 包加 `--access public`，仓库里已声明 `publishConfig.access`）。
+
+装好后的启用路径是 **Plugins 页面 / `plugin_manager.installBundle`**（它会写 `dsh.profile.bundles`）；
+只跑 `dsh plugin --profile desktop add` 只是 pnpm 安装，不会自动启用该 bundle。

package/cordis.patch.yml

@@ -0,0 +1,9 @@
+# 生财有术 MCP：OAuth 2.1 + 原生工具注册。
+# 安装后首次启动会打开浏览器完成授权，随后自动注册 mcp__scys-mcp__* 工具。
+- insert:
+    - id: mcp-scys-oauth
+      name: 'dsh-plugin-scys-mcp'
+      config:
+        serverName: scys-mcp
+        url: https://mcp.scys.com/shengcai-web/mcp
+        openBrowser: true

package/icon.svg

@@ -0,0 +1,12 @@
+<svg width="36" height="36" viewBox="0 0 36 36" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="36" y2="36" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#0EA5E9"/>
+      <stop offset="1" stop-color="#4F46E5"/>
+    </linearGradient>
+  </defs>
+  <rect width="36" height="36" rx="9" fill="url(#bg)"/>
+  <rect x="9" y="20" width="4" height="7" rx="2" fill="#FFFFFF" fill-opacity="0.82"/>
+  <rect x="16" y="16" width="4" height="11" rx="2" fill="#FFFFFF" fill-opacity="0.92"/>
+  <rect x="23" y="11" width="4" height="16" rx="2" fill="#FCD34D"/>
+</svg>

package/lib/index.js

@@ -0,0 +1,372 @@
+/**
+ * dsh-plugin-scys-mcp — 生财有术 MCP for DeepSeek Harness.
+ *
+ * Connects to https://mcp.scys.com/shengcai-web/mcp with OAuth 2.1 (browser
+ * authorization + PKCE + rotating refresh token), then publishes every MCP
+ * tool to the harness tool registry as `mcp__scys-mcp__<name>`.
+ *
+ * The plugin owns the whole connection: no sidecar process, no profile edits
+ * beyond this row, identical behaviour on macOS, Windows and Linux.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { accessToken, authorize, openBrowser, watchAuthUrl, DEFAULT_RESOURCE } from './oauth.js';
+import { McpHttp, McpError } from './mcp.js';
+import { tokenStatus, stateDir } from './store.js';
+
+export const name = 'scys-mcp';
+export const inject = ['tools'];
+
+/** Append to <state>/plugin.log so installs can be diagnosed without host logs. */
+function fileLog(level, message) {
+  try {
+    fs.mkdirSync(stateDir(), { recursive: true, mode: 0o700 });
+    fs.appendFileSync(path.join(stateDir(), 'plugin.log'), `${new Date().toISOString()} ${level} ${message}\n`);
+  } catch { /* logging must never break the plugin */ }
+}
+
+const SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
+const MAX_PUBLIC_NAME_LENGTH = 64;
+const INVALID_NAME_CHARS = /[^A-Za-z0-9_-]/g;
+const HASH_LENGTH = 12;
+const RETRY_BASE_MS = 30_000;
+const RETRY_MAX_MS = 10 * 60_000;
+
+/** Same identity contract as dsh-mcp-client: `mcp__<server>__<tool>`. */
+function publicToolName(serverName, rawName) {
+  const joined = `mcp__${serverName}__${rawName}`;
+  const normalized = joined.replace(INVALID_NAME_CHARS, '_');
+  if (normalized === joined && normalized.length <= MAX_PUBLIC_NAME_LENGTH) return normalized;
+  const hash = createHash('sha256').update(`${serverName}\0${rawName}`).digest('hex').slice(0, HASH_LENGTH);
+  return `${normalized.slice(0, MAX_PUBLIC_NAME_LENGTH - HASH_LENGTH - 1)}_${hash}`;
+}
+
+/** Project MCP content blocks into model-visible text. */
+function extractText(content, toolName) {
+  if (!Array.isArray(content) || content.length === 0) return `(${toolName} returned no content)`;
+  const lines = [];
+  for (const block of content) {
+    if (block === null || typeof block !== 'object') { lines.push('[unsupported MCP content block]'); continue; }
+    switch (block.type) {
+      case 'text':
+        if (block.text !== undefined) lines.push(block.text);
+        break;
+      case 'resource_link':
+        lines.push(block.name !== undefined && block.uri !== undefined
+          ? `Resource link: ${block.name} (${block.uri})`
+          : '[resource link unavailable]');
+        break;
+      case 'image':
+        lines.push(`[image result: ${block.mimeType ?? 'unknown media type'}; not rendered as text]`);
+        break;
+      case 'audio':
+        lines.push(`[audio result unsupported: ${block.mimeType ?? 'unknown media type'}]`);
+        break;
+      case 'resource':
+        lines.push('[embedded resource unsupported]');
+        break;
+      default:
+        lines.push(`[unsupported MCP content type: ${block.type}]`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/** Transport failures worth one reconnect + retry; tool-level errors are not. */
+function isTransient(err) {
+  if (err === null || typeof err !== 'object') return false;
+  if (err.name === 'AbortError') return false;
+  if (err instanceof McpError) return err.status === undefined || err.status >= 500 || err.status === 408 || err.status === 429;
+  if (err instanceof TypeError) return true;
+  if (typeof err.code === 'string' && /^(ECONN|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|UND_ERR)/.test(err.code)) return true;
+  return false;
+}
+
+const SUPPORTED_SCHEMA_KEYS = new Set([
+  'type', 'oneOf', 'properties', 'required', 'additionalProperties', 'items',
+  'enum', 'const', 'description', 'title', 'default', 'examples',
+  'deprecated', 'readOnly', 'writeOnly', '$comment',
+]);
+
+/**
+ * The harness accepts a JSON-Schema subset (no `$ref`, boolean
+ * `additionalProperties` only). An unsupported output schema is dropped rather
+ * than rejecting the whole tool — the text projection still carries the result.
+ */
+function isSupportedJsonSchema(schema, depth = 0) {
+  if (depth > 8) return false;
+  if (schema === null || typeof schema !== 'object' || Array.isArray(schema)) return false;
+  for (const key of Object.keys(schema)) if (!SUPPORTED_SCHEMA_KEYS.has(key)) return false;
+  if (schema.type !== undefined && typeof schema.type !== 'string') return false;
+  if (schema.additionalProperties !== undefined && typeof schema.additionalProperties !== 'boolean') return false;
+  if (schema.properties !== undefined) {
+    if (typeof schema.properties !== 'object' || Array.isArray(schema.properties)) return false;
+    for (const value of Object.values(schema.properties)) {
+      if (!isSupportedJsonSchema(value, depth + 1)) return false;
+    }
+  }
+  if (schema.items !== undefined) {
+    const items = Array.isArray(schema.items) ? schema.items : [schema.items];
+    for (const item of items) if (!isSupportedJsonSchema(item, depth + 1)) return false;
+  }
+  if (schema.oneOf !== undefined) {
+    if (!Array.isArray(schema.oneOf)) return false;
+    for (const arm of schema.oneOf) if (!isSupportedJsonSchema(arm, depth + 1)) return false;
+  }
+  if (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.some((v) => typeof v !== 'string'))) return false;
+  return true;
+}
+
+function supportedOutputSchema(candidate) {
+  if (candidate === undefined) return undefined;
+  return isSupportedJsonSchema(candidate) ? candidate : undefined;
+}
+
+/** Build the ToolRuntime definition for one MCP tool. */
+function defineTool(runtime, tool, options) {
+  const publicName = publicToolName(options.serverName, tool.name);
+  const rawName = tool.name;
+  const outputSchema = supportedOutputSchema(tool.outputSchema);
+  const timeoutMs = options.toolCallTimeoutMs;
+
+  const invoke = async (args, exec) => runtime.client().callTool(rawName, args, {
+    signal: exec?.signal,
+    timeoutMs,
+  });
+
+  return {
+    name: publicName,
+    description: tool.description ?? '',
+    parameters: tool.inputSchema ?? { type: 'object', properties: {} },
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          content: { type: 'array', items: {} },
+          structuredContent: outputSchema ?? {},
+        },
+        required: outputSchema === undefined ? ['content'] : ['content', 'structuredContent'],
+        additionalProperties: false,
+      },
+      render(_args, value) {
+        return [{ type: 'text', text: extractText(value.content, rawName) }];
+      },
+    },
+    async execute(args, exec) {
+      if (tool.execution?.taskSupport === 'required') {
+        throw new Error(`Tool "${rawName}" requires task-based execution, which this bridge does not support`);
+      }
+      const callArgs = typeof args === 'object' && args !== null ? args : {};
+      let result;
+      try {
+        result = await invoke(callArgs, exec);
+      } catch (err) {
+        if (runtime.stopped() || !isTransient(err)) throw err;
+        fileLog('WARN', `tool ${rawName} hit a transport error, reconnecting: ${err?.message ?? err}`);
+        await runtime.reconnect();
+        result = await invoke(callArgs, exec);
+      }
+      const content = Array.isArray(result?.content) ? result.content : [];
+      const text = extractText(content, rawName);
+      if (result?.isError === true) throw new Error(text);
+      return {
+        content,
+        ...(result?.structuredContent !== undefined ? { structuredContent: result.structuredContent } : {}),
+      };
+    },
+  };
+}
+
+/** A small always-available tool so authorization can be retried from chat. */
+function authTool(ctx, options, runtime) {
+  const publicName = publicToolName(options.serverName, 'auth');
+  return {
+    name: publicName,
+    description: '生财有术 MCP（scys-mcp）的授权状态与重新授权。未授权时调用会在浏览器打开授权页；授权完成后 MCP 工具会自动注册。',
+    parameters: { type: 'object', properties: { reauthorize: { type: 'boolean', description: '强制重新走一次浏览器授权' } } },
+    output: {
+      schema: { type: 'object', properties: { content: { type: 'array', items: {} } }, required: ['content'], additionalProperties: false },
+      render(_args, value) { return value.content; },
+    },
+    async execute(args) {
+      if (args?.reauthorize === true) runtime.needsAuth = true;
+      const status = tokenStatus();
+      if (!runtime.needsAuth && status.authorized) {
+        const suffix = status.expired ? '（已过期，下一次工具调用会自动刷新）' : '';
+        return { content: [{ type: 'text', text: `已授权，access token 到期时间：${status.expires_at ?? '未知'}${suffix}；已注册 ${runtime.registered} 个工具。` }] };
+      }
+      const url = await runtime.pendingUrl();
+      return { content: [{ type: 'text', text: `已发起授权，请在浏览器完成登录：\n${url}` }] };
+    },
+  };
+}
+
+function normalize(config = {}) {
+  const serverName = config.serverName ?? 'scys-mcp';
+  if (!SERVER_NAME_PATTERN.test(serverName)) throw new Error(`scys-mcp: invalid serverName "${serverName}"`);
+  return {
+    serverName,
+    url: config.url ?? DEFAULT_RESOURCE,
+    resource: config.resource ?? config.url ?? DEFAULT_RESOURCE,
+    port: Number(config.port ?? 18787),
+    openBrowser: config.openBrowser !== false,
+    toolCallTimeoutMs: Number(config.toolCallTimeoutMs ?? 120_000),
+    authorizeTimeoutMs: Number(config.authorizeTimeoutMs ?? 15 * 60 * 1000),
+    clientName: config.clientName,
+  };
+}
+
+export function apply(ctx, config = {}) {
+  const options = normalize(config);
+
+  ctx.effect(() => {
+    const controller = new AbortController();
+    let stopped = false;
+    let disposers = [];
+    let retryTimer;
+    let mcp;
+    let attempt = 0;
+    let authUrl;
+    let authPromise;      // resolves with tokens
+    let urlPromise;       // resolves with the authorization URL
+    let reconnecting = null;
+
+    const tokenOptions = () => ({ ...options, url: options.url });
+    const getToken = (control = {}) => accessToken(tokenOptions(), {
+      ...control,
+      allowInteractive: false,
+      onUrl: (url) => { authUrl = url; },
+    });
+
+    const runtime = {
+      needsAuth: false,
+      authTried: false,
+      registered: 0,
+      stopped: () => stopped,
+      client() {
+        if (!mcp) throw new Error('生财有术 MCP 尚未连接（授权可能未完成）');
+        return mcp;
+      },
+      /** Replace the transport after a transient failure; tools keep working. */
+      reconnect() {
+        if (reconnecting) return reconnecting;
+        reconnecting = (async () => {
+          const next = new McpHttp({ url: options.url, timeoutMs: options.toolCallTimeoutMs, getToken });
+          await next.initialize(controller.signal);
+          const previous = mcp;
+          mcp = next;
+          previous?.close().catch(() => {});
+          fileLog('INFO', 'transport reconnected');
+          return next;
+        })().finally(() => { reconnecting = null; });
+        return reconnecting;
+      },
+      /** Start (or join) the interactive flow and resolve with its URL. */
+      async pendingUrl() {
+        if (authPromise) return urlPromise;
+        authPromise = startAuth();
+        return urlPromise;
+      },
+    };
+
+    async function startAuth() {
+      const deferred = Promise.withResolvers();
+      const stop = watchAuthUrl((url) => {
+        authUrl = url;
+        deferred.resolve(url);
+        fileLog('WARN', `authorization url ${url}`);
+        ctx.logger.warn(`scys-mcp: 请在浏览器完成授权 ${url}`);
+      });
+      urlPromise = deferred.promise;
+      authPromise = authorize({ ...options, openBrowser: true }).then((tokens) => {
+        runtime.needsAuth = false;
+        return tokens;
+      }).catch((err) => {
+        if (!authUrl) deferred.reject(err);
+        ctx.logger.error(`scys-mcp: 授权失败 ${err?.message ?? err}`);
+        throw err;
+      }).finally(() => {
+        stop();
+        authPromise = null;
+        authUrl = undefined;
+      });
+      return authPromise;
+    }
+
+    const resetTools = () => {
+      for (const dispose of disposers) {
+        try { dispose(); } catch { /* already gone */ }
+      }
+      disposers = [];
+      runtime.registered = 0;
+    };
+
+    async function connect() {
+      try {
+        const token = await accessToken(
+          // Only the first attempt opens a browser on its own; later attempts
+          // go through the `auth` tool so a sleeping machine is not spammed.
+          { ...tokenOptions(), openBrowser: runtime.authTried ? false : options.openBrowser },
+          {
+            onUrl: (url) => {
+              authUrl = url;
+              ctx.logger.warn(`scys-mcp: 需要浏览器授权，已打开 ${url}`);
+            },
+          },
+        );
+        if (stopped) return;
+        if (!token) throw new Error('no access token');
+        const client = new McpHttp({ url: options.url, timeoutMs: options.toolCallTimeoutMs, getToken });
+        await client.initialize(controller.signal);
+        if (stopped) return;
+        const tools = await client.listTools(controller.signal);
+        if (stopped) return;
+        mcp = client;
+        resetTools();
+        const definitions = tools.map((tool) => defineTool(runtime, tool, options));
+        definitions.push(authTool(ctx, options, runtime));
+        let failed = 0;
+        for (const definition of definitions) {
+          try {
+            disposers.push(ctx.tools.register(definition));
+          } catch (err) {
+            failed += 1;
+            fileLog('WARN', `register ${definition.name} failed: ${err?.message ?? err}`);
+          }
+        }
+        attempt = 0;
+        runtime.registered = definitions.length - failed;
+        runtime.needsAuth = false;
+        fileLog('INFO', `connected ${options.url}, registered ${runtime.registered}/${definitions.length} tools`);
+        ctx.logger.info(`scys-mcp: connected to ${options.url}, registered ${runtime.registered}/${definitions.length} tools`);
+      } catch (err) {
+        if (stopped) return;
+        runtime.needsAuth = true;
+        runtime.authTried = true;
+        fileLog('ERROR', `connect failed: ${err?.stack ?? err}`);
+        ctx.logger.error(`scys-mcp: connect failed — ${err?.message ?? err}`);
+        // Register the auth escape hatch even when the MCP side is unavailable.
+        if (disposers.length === 0) {
+          try { disposers.push(ctx.tools.register(authTool(ctx, options, runtime))); } catch { /* tools may be gone */ }
+        }
+        const delay = Math.min(RETRY_BASE_MS * 2 ** Math.min(attempt, 5), RETRY_MAX_MS);
+        attempt += 1;
+        retryTimer = setTimeout(connect, delay);
+        retryTimer.unref?.();
+      }
+    }
+
+    connect();
+
+    return () => {
+      stopped = true;
+      controller.abort();
+      if (retryTimer) clearTimeout(retryTimer);
+      resetTools();
+      mcp?.close();
+    };
+  }, 'scys-mcp.connection');
+}
+
+export { openBrowser, tokenStatus };

package/lib/mcp.js

@@ -0,0 +1,165 @@
+/**
+ * Minimal MCP client over the Streamable HTTP transport.
+ *
+ * The plugin only needs request/response MCP (initialize, tools/list,
+ * tools/call), so this speaks JSON-RPC directly and understands both plain
+ * JSON and `text/event-stream` replies. No SDK dependency — the plugin stays
+ * installable on any DSH build.
+ */
+
+const PROTOCOL_VERSION = '2025-06-18';
+const CLIENT_INFO = { name: 'dsh-plugin-scys-mcp', version: '0.1.0' };
+
+export class McpError extends Error {
+  constructor(message, { code, data, status } = {}) {
+    super(message);
+    this.name = 'McpError';
+    this.code = code;
+    this.data = data;
+    this.status = status;
+  }
+}
+
+/** Read an SSE body until the reply for `id` arrives, then cancel the stream. */
+async function readSse(res, id) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) return null;
+      buffer += decoder.decode(value, { stream: true });
+      let split;
+      while ((split = buffer.indexOf('\n\n')) >= 0) {
+        const block = buffer.slice(0, split);
+        buffer = buffer.slice(split + 2);
+        const data = block.split('\n')
+          .filter((line) => line.startsWith('data:'))
+          .map((line) => line.slice(5).trim())
+          .join('\n');
+        if (!data) continue;
+        let message;
+        try { message = JSON.parse(data); } catch { continue; }
+        if (message.id === id || (id === undefined && message.method)) return message;
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {});
+  }
+}
+
+export class McpHttp {
+  /**
+   * @param {object} options
+   * @param {string} options.url MCP endpoint
+   * @param {(control?: {force?: boolean, onUrl?: (url: string) => void}) => Promise<string>} options.getToken
+   * @param {number} [options.timeoutMs] default per-request timeout
+   */
+  constructor({ url, getToken, timeoutMs = 60_000 }) {
+    this.url = url;
+    this.getToken = getToken;
+    this.timeoutMs = timeoutMs;
+    this.sessionId = null;
+    this.protocolVersion = null;
+    this.nextId = 1;
+    this.closed = false;
+  }
+
+  headers(token) {
+    const headers = {
+      'content-type': 'application/json',
+      accept: 'application/json, text/event-stream',
+      authorization: `Bearer ${token}`,
+    };
+    if (this.sessionId) headers['mcp-session-id'] = this.sessionId;
+    if (this.protocolVersion) headers['mcp-protocol-version'] = this.protocolVersion;
+    return headers;
+  }
+
+  async post(payload, { signal, timeoutMs, forceToken = false } = {}) {
+    const timeout = AbortSignal.timeout(timeoutMs ?? this.timeoutMs);
+    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    let token = await this.getToken({ force: forceToken });
+    const send = (bearer) => fetch(this.url, {
+      method: 'POST',
+      headers: this.headers(bearer),
+      body: JSON.stringify(payload),
+      signal: combined,
+    });
+    let res = await send(token);
+    if (res.status === 401) {
+      token = await this.getToken({ force: true });
+      res = await send(token);
+    }
+    const session = res.headers.get('mcp-session-id');
+    if (session) this.sessionId = session;
+    return res;
+  }
+
+  /** Send a request and resolve with its JSON-RPC result. */
+  async request(method, params, control = {}) {
+    const id = this.nextId++;
+    const res = await this.post({ jsonrpc: '2.0', id, method, params }, control);
+    if (!res.ok && res.status !== 200) {
+      const detail = await res.text().catch(() => '');
+      throw new McpError(`${method} failed: HTTP ${res.status} ${detail.slice(0, 300)}`.trim(), { status: res.status });
+    }
+    const contentType = res.headers.get('content-type') ?? '';
+    const message = contentType.includes('text/event-stream')
+      ? await readSse(res, id)
+      : await res.json().catch(() => null);
+    if (!message) throw new McpError(`${method} returned no response`);
+    if (message.error) {
+      throw new McpError(`${method} failed: ${message.error.message ?? 'unknown error'}`, {
+        code: message.error.code,
+        data: message.error.data,
+      });
+    }
+    return message.result;
+  }
+
+  /** Send a notification (no id, no result). */
+  async notify(method, params, control = {}) {
+    const res = await this.post({ jsonrpc: '2.0', method, params }, control);
+    await res.text().catch(() => '');
+    return res.status;
+  }
+
+  async initialize(signal) {
+    const result = await this.request('initialize', {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: CLIENT_INFO,
+    }, { signal });
+    this.protocolVersion = result?.protocolVersion ?? PROTOCOL_VERSION;
+    await this.notify('notifications/initialized', {}, { signal });
+    return result;
+  }
+
+  async listTools(signal) {
+    const tools = [];
+    let cursor;
+    for (let page = 0; page < 100; page++) {
+      const result = await this.request('tools/list', cursor ? { cursor } : {}, { signal });
+      if (Array.isArray(result?.tools)) tools.push(...result.tools);
+      cursor = result?.nextCursor;
+      if (!cursor) break;
+    }
+    return tools;
+  }
+
+  async callTool(name, args, { signal, timeoutMs } = {}) {
+    return this.request('tools/call', { name, arguments: args ?? {} }, { signal, timeoutMs });
+  }
+
+  async close() {
+    this.closed = true;
+    if (!this.sessionId) return;
+    try {
+      const token = await this.getToken();
+      await fetch(this.url, { method: 'DELETE', headers: this.headers(token), signal: AbortSignal.timeout(5000) });
+    } catch { /* best effort */ }
+    this.sessionId = null;
+  }
+}

package/lib/oauth.js

@@ -0,0 +1,332 @@
+/**
+ * OAuth 2.1 for the scys MCP server: protected-resource discovery, dynamic
+ * client registration (RFC 7591), authorization code + PKCE (S256), refresh,
+ * and a loopback callback listener that works on macOS, Windows and Linux.
+ *
+ * No third-party dependencies: only Node built-ins and global fetch.
+ */
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { paths, readJson, writeJson, readTokens } from './store.js';
+
+export const DEFAULT_RESOURCE = 'https://mcp.scys.com/shengcai-web/mcp';
+export const DEFAULT_SCOPE = 'mcp';
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 20_000;
+
+const b64url = (buf) => Buffer.from(buf).toString('base64url');
+/** RFC 8707 resource identifier: the MCP endpoint itself. */
+const resourceOf = (options = {}) => options.resource ?? options.url ?? DEFAULT_RESOURCE;
+
+async function fetchJson(url, init = {}) {
+  const res = await fetch(url, {
+    ...init,
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+  const text = await res.text();
+  let json = null;
+  try { json = JSON.parse(text); } catch { /* not JSON */ }
+  if (!res.ok) {
+    const err = new Error(`${url} -> HTTP ${res.status}${json ? `: ${JSON.stringify(json).slice(0, 300)}` : ''}`);
+    err.status = res.status;
+    err.body = json;
+    throw err;
+  }
+  if (!json) throw new Error(`${url} did not return JSON: ${text.slice(0, 200)}`);
+  return json;
+}
+
+const discovered = new Map();
+
+/**
+ * Resolve the authorization-server metadata advertised by the MCP endpoint.
+ * @param {{resource?: string, resourceMetadata?: string}} options
+ */
+export async function discover(options = {}) {
+  const resource = resourceOf(options);
+  if (discovered.has(resource)) return discovered.get(resource);
+  const prmUrl = options.resourceMetadata
+    ?? new URL('/.well-known/oauth-protected-resource', resource).toString();
+  const prm = await fetchJson(prmUrl);
+  const issuer = prm.authorization_servers?.[0];
+  if (!issuer) throw new Error('protected resource metadata has no authorization_servers');
+  const u = new URL(issuer);
+  const base = `${u.origin}${u.pathname.replace(/\/$/, '')}`;
+  const candidates = [
+    `${u.origin}/.well-known/oauth-authorization-server${u.pathname.replace(/\/$/, '')}`,
+    `${base}/.well-known/oauth-authorization-server`,
+    `${base}/.well-known/openid-configuration`,
+  ];
+  let lastErr;
+  for (const url of candidates) {
+    try {
+      const meta = await fetchJson(url);
+      const resolved = { ...meta, resource: prm.resource ?? resource, prm };
+      discovered.set(resource, resolved);
+      return resolved;
+    } catch (err) { lastErr = err; }
+  }
+  throw lastErr ?? new Error('authorization server metadata not found');
+}
+
+/** Register (or reuse) a public client bound to this loopback redirect URI. */
+export async function ensureClient(redirectUri, metadata, clientName) {
+  const existing = readJson(paths().client);
+  if (existing?.client_id && (existing.redirect_uris ?? []).includes(redirectUri)) return existing;
+  if (!metadata.registration_endpoint) throw new Error('authorization server does not support dynamic client registration');
+  const reg = await fetchJson(metadata.registration_endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', accept: 'application/json' },
+    body: JSON.stringify({
+      client_name: clientName ?? 'DeepSeek Harness · 生财有术 MCP',
+      redirect_uris: [redirectUri],
+      grant_types: ['authorization_code', 'refresh_token'],
+      response_types: ['code'],
+      token_endpoint_auth_method: 'none',
+      scope: DEFAULT_SCOPE,
+    }),
+  });
+  const client = { ...reg, registered_at: new Date().toISOString() };
+  writeJson(paths().client, client);
+  return client;
+}
+
+async function tokenRequest(metadata, params) {
+  return fetchJson(metadata.token_endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
+    body: new URLSearchParams(params).toString(),
+  });
+}
+
+function saveTokens(tok, resource) {
+  const previous = readTokens() ?? {};
+  writeJson(paths().tokens, {
+    access_token: tok.access_token,
+    refresh_token: tok.refresh_token ?? previous.refresh_token ?? null,
+    token_type: tok.token_type ?? 'Bearer',
+    scope: tok.scope ?? previous.scope ?? DEFAULT_SCOPE,
+    expires_at: tok.expires_in ? Date.now() + Number(tok.expires_in) * 1000 : null,
+    resource,
+    updated_at: new Date().toISOString(),
+  });
+  return readTokens();
+}
+
+/** Open a URL in the user's default browser on macOS, Windows or Linux. */
+export function openBrowser(url) {
+  // Windows: rundll32 receives argv directly (no cmd.exe), so URL characters
+  // such as `&` can never be parsed as shell operators.
+  const [command, args] = process.platform === 'darwin'
+    ? ['open', [url]]
+    : process.platform === 'win32'
+      ? ['rundll32.exe', ['url.dll,FileProtocolHandler', url]]
+      : ['xdg-open', [url]];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const page = (title, body) => `<!doctype html><html lang="zh-CN"><meta charset="utf-8">
+<title>${title}</title>
+<style>body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;
+background:#f5f5f7;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;color:#1d1d1f}
+.card{background:#fff;padding:40px 48px;border-radius:16px;box-shadow:0 8px 30px rgba(0,0,0,.08);max-width:560px;text-align:center}
+h1{font-size:20px;margin:0 0 12px}p{color:#555;line-height:1.6;margin:6px 0}
+code{background:#f2f2f4;padding:2px 6px;border-radius:6px}</style>
+<div class="card"><h1>${title}</h1>${body}</div></html>`;
+
+const escapeHtml = (s) => String(s).replace(/[<>&]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' }[c]));
+
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (err) => {
+      server.off('listening', onListening);
+      if (err.code === 'EADDRINUSE' && port !== 0) {
+        // Another login (or an older bridge) owns the default port: take any free one.
+        listen(server, 0).then(resolve, reject);
+        return;
+      }
+      reject(err);
+    };
+    const onListening = () => {
+      server.off('error', onError);
+      resolve(server.address().port);
+    };
+    server.once('error', onError);
+    server.once('listening', onListening);
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+let authInFlight = null;
+let currentAuthUrl = null;
+const urlListeners = new Set();
+
+/** Observe the authorization URL of the running (or next) flow. */
+export function watchAuthUrl(listener) {
+  urlListeners.add(listener);
+  if (currentAuthUrl) {
+    try { listener(currentAuthUrl); } catch { /* listener failure is not fatal */ }
+  }
+  return () => { urlListeners.delete(listener); };
+}
+
+function emitAuthUrl(url) {
+  currentAuthUrl = url;
+  for (const listener of urlListeners) {
+    try { listener(url); } catch { /* listener failure is not fatal */ }
+  }
+}
+
+/**
+ * Run the interactive authorization-code + PKCE flow.
+ * @param {object} options plugin options
+ * @param {(url: string) => void} [onUrl] called with the authorization URL
+ */
+export async function authorize(options = {}, onUrl) {
+  if (authInFlight) return authInFlight;
+  authInFlight = (async () => {
+    const resource = resourceOf(options);
+    const metadata = await discover({ ...options, resource });
+    const server = http.createServer();
+    const port = await listen(server, Number(options.port ?? 18787));
+    const redirectUri = `http://127.0.0.1:${port}/callback`;
+    const client = await ensureClient(redirectUri, metadata, options.clientName);
+
+    const verifier = b64url(crypto.randomBytes(48));
+    const challenge = b64url(crypto.createHash('sha256').update(verifier).digest());
+    const state = b64url(crypto.randomBytes(24));
+
+    const url = new URL(metadata.authorization_endpoint);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('client_id', client.client_id);
+    url.searchParams.set('redirect_uri', redirectUri);
+    url.searchParams.set('scope', options.scope ?? DEFAULT_SCOPE);
+    url.searchParams.set('state', state);
+    url.searchParams.set('code_challenge', challenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    url.searchParams.set('resource', resource);
+
+    const { promise, resolve, reject } = Promise.withResolvers();
+    let settled = false;
+    const finish = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn(value);
+    };
+
+    server.on('request', async (req, res) => {
+      const reqUrl = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+      const reply = (status, title, body) => {
+        res.writeHead(status, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+        res.end(page(title, body));
+      };
+      if (reqUrl.pathname !== '/callback') {
+        res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end('not found');
+        return;
+      }
+      const error = reqUrl.searchParams.get('error');
+      if (error) {
+        reply(400, '授权未完成', `<p><code>${escapeHtml(error)}</code></p><p>${escapeHtml(reqUrl.searchParams.get('error_description') ?? '')}</p>`);
+        finish(reject, new Error(`authorization denied: ${error}`));
+        return;
+      }
+      const code = reqUrl.searchParams.get('code');
+      const returnedState = reqUrl.searchParams.get('state');
+      if (!code || returnedState !== state) {
+        reply(400, '授权回调无效', '<p>缺少授权码或 state 校验失败，请重新发起授权。</p>');
+        finish(reject, new Error('invalid authorization callback'));
+        return;
+      }
+      try {
+        const tok = await tokenRequest(metadata, {
+          grant_type: 'authorization_code',
+          code,
+          redirect_uri: redirectUri,
+          client_id: client.client_id,
+          code_verifier: verifier,
+          resource,
+        });
+        const saved = saveTokens(tok, resource);
+        reply(200, '授权成功', '<p>生财有术 MCP 已连接，可以关闭此页面。</p><p>回到 DeepSeek Harness 继续对话即可使用 <code>mcp__scys-mcp__*</code> 工具。</p>');
+        finish(resolve, saved);
+      } catch (err) {
+        reply(502, '换取令牌失败', `<p>${escapeHtml(err.message ?? err)}</p>`);
+        finish(reject, err);
+      }
+    });
+
+    const timer = setTimeout(() => {
+      finish(reject, new Error(`authorization timed out (${Math.round(Number(options.authorizeTimeoutMs ?? DEFAULT_TIMEOUT_MS) / 60000)} minutes)`));
+    }, Number(options.authorizeTimeoutMs ?? DEFAULT_TIMEOUT_MS));
+    timer.unref?.();
+
+    emitAuthUrl(url.toString());
+    onUrl?.(url.toString());
+    if (options.openBrowser !== false) openBrowser(url.toString());
+
+    try {
+      return await promise;
+    } finally {
+      setTimeout(() => server.close(), 250).unref?.();
+    }
+  })().finally(() => { authInFlight = null; currentAuthUrl = null; });
+  return authInFlight;
+}
+
+let refreshInFlight = null;
+
+/** Exchange the refresh token for a new access token (the server rotates it). */
+export async function refresh(options = {}) {
+  if (refreshInFlight) return refreshInFlight;
+  const current = readTokens();
+  if (!current?.refresh_token) throw new Error('no refresh token stored');
+  const resource = resourceOf(options);
+  const metadata = await discover({ ...options, resource });
+  const client = readJson(paths().client);
+  refreshInFlight = (async () => {
+    const tok = await tokenRequest(metadata, {
+      grant_type: 'refresh_token',
+      refresh_token: current.refresh_token,
+      client_id: client?.client_id ?? '',
+      resource,
+    });
+    return saveTokens(tok, resource);
+  })().finally(() => { refreshInFlight = null; });
+  return refreshInFlight;
+}
+
+/**
+ * Return a usable bearer token, refreshing it shortly before expiry and
+ * falling back to the interactive flow when no grant exists any more.
+ * @param {object} options plugin options
+ * @param {{force?: boolean, onUrl?: (url: string) => void}} [control]
+ */
+export async function accessToken(options = {}, control = {}) {
+  const t = readTokens();
+  const stillFresh = t?.access_token && t.expires_at && Date.now() < t.expires_at - 60_000;
+  if (!control.force && stillFresh) return t.access_token;
+  if (t?.refresh_token) {
+    try {
+      const next = await refresh(options);
+      return next.access_token;
+    } catch (err) {
+      if (err?.status !== 400 && err?.status !== 401) throw err;
+      // invalid_grant: the grant is gone, fall through to a fresh login.
+    }
+  }
+  if (control.allowInteractive === false) {
+    throw new Error('生财有术 MCP 授权已失效：请调用 mcp__scys-mcp__auth 重新授权');
+  }
+  const next = await authorize(options, control.onUrl);
+  return next.access_token;
+}

package/lib/store.js

@@ -0,0 +1,52 @@
+/**
+ * Local state for the scys-mcp plugin: OAuth client registration and tokens.
+ *
+ * Everything lives under `<home>/.dsh/mcp/scys-mcp/` on every platform, so the
+ * macOS and Windows builds behave identically. `SCYS_MCP_STATE_DIR` overrides
+ * the location (tests, multi-account setups).
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export function stateDir() {
+  return process.env.SCYS_MCP_STATE_DIR || path.join(os.homedir(), '.dsh', 'mcp', 'scys-mcp');
+}
+
+export function paths() {
+  const dir = stateDir();
+  return {
+    dir,
+    client: path.join(dir, 'client.json'),
+    tokens: path.join(dir, 'tokens.json'),
+  };
+}
+
+export function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+export function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tmp, file);
+  try { fs.chmodSync(file, 0o600); } catch { /* Windows ignores POSIX modes */ }
+}
+
+export function readTokens() {
+  return readJson(paths().tokens);
+}
+
+export function tokenStatus() {
+  const t = readTokens();
+  if (!t?.access_token) return { authorized: false };
+  return {
+    authorized: true,
+    expires_at: t.expires_at ? new Date(t.expires_at).toISOString() : null,
+    expired: Boolean(t.expires_at && Date.now() >= t.expires_at),
+    has_refresh_token: Boolean(t.refresh_token),
+    scope: t.scope ?? null,
+    updated_at: t.updated_at ?? null,
+  };
+}

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "dsh-plugin-scys-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "生财有术 MCP（scys.com）for DeepSeek Harness — OAuth 2.1 网页授权，原生工具注册，macOS / Windows / Linux",
+  "icon": "./icon.svg",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "icon.svg",
+    "lib/*.js",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "mcp",
+    "scys",
+    "生财有术"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}