@agentguardx/helper 0.0.0-stage → 0.3.88

package/README.md

@@ -1,3 +1,42 @@
-# Temporary Holding Version
+# AgentGuard 员工接入助手
 
-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.
+需要 Node.js 18 或更新版本。企业将包发布到可信 npm 仓库后，可使用：
+
+```sh
+npx @agentguardx/helper
+npm i -g @agentguardx/helper
+agentguard init --server https://企业服务器域名
+```
+
+公共 npmjs 尚未发布；可发布到企业私有仓库后用 `npx --registry <仓库地址> @agentguardx/helper`（见 docs/client/B13_INSTALLATION.md 的发布步骤），或使用管理员分发的离线 tgz。离线安装时同时安装主包和本机对应的平台包；全局命令仍为 `agentguard`。包不固定企业服务器地址；可交互填写，或使用 `--server` / `AGENTGUARD_SERVER`。支持 HTTP/HTTPS；HTTP 每个新服务器先明确确认明文风险，确认前不发送令牌。
+
+npx 即用不会创建全局 `agentguard` 命令；后续使用 `npx @agentguardx/helper launch opencode`、`npx @agentguardx/helper uninstall`，或全局安装后使用短命令。
+
+向导先显示当前服务器地址（优先级：`--server` 参数 > 环境变量 `AGENTGUARD_SERVER` > 上次保存的配置）作为默认值：回车沿用，也可直接输入别的 IP 或域名；输入后重新校验 `/client/v1/config`，HTTP 只提示一次明文风险。已有登录属于旧服务器时，向导提示需要重新登录，并在你确认后先退出旧登录（撤销旧令牌、恢复已接入工具配置）；旧令牌绝不会发给新服务器。命令行同样可用：`agentguard server show` 查看当前地址，`agentguard server set <地址>` 修改（加 `--switch` 同时退出旧登录并恢复工具配置；旧服务器无法访问时可再加 `--local-only`，只清除本机登录，旧令牌在服务端仍有效直到到期或由管理员撤销）。
+
+登录方式为“浏览器网页授权”（`agentguard login`）：命令行在本机回环地址开一次性回调，打开控制台 `/client-authorize` 授权页，由控制台当前登录的人点“授权”，成功后显示“已登录为 姓名（账号）”。无浏览器时命令行会打印授权链接，须在本机浏览器打开（回调只监听 127.0.0.1）。也可以隐藏输入个人令牌。令牌只通过匿名标准输入交给 Go 核心，经网关校验后写系统钥匙串，不进入命令行或普通配置文件。方向键移动，空格多选已检测的工具，Enter 确认；配置完成后显示实际 doctor 结果。
+
+企业对话正文留存不要求员工告知或确认，向导不展示告知步骤、不提交已读；正常对话不会因告知流程被阻断。留存开启仍须独立双审，正文访问按当前角色与服务端审批结果执行，平台管理员可审核本人申请；正式环境默认关闭。
+
+支持入口为 OpenCode、OpenClaw、Cursor 远程 MCP、Claude Desktop MCP 桥接及 Cherry Studio 手动说明；厂商原生实测范围以企业兼容记录为准。Codex 暂缓，Gemini 和 Claude Code 不接入。B15 为 OpenCode 同时注册本机安全 stdio MCP，并写入关闭自带本机工具的配置；仅经 ag_* 入口的调用由服务端逐次授权、执行上报和输出检查。其他厂商未验证关闭原生工具时，其自带本机终端、文件操作不受该 MCP 管控。客户端可被员工修改的边界不等同操作系统强制隔离。
+
+启动器每次执行 Go 核心前，使用内置固定公钥验证 originless npm 清单的 RSA-3072/SHA-256 签名，再检查平台二进制与 macOS 钥匙串 helper 的大小和 SHA-256。验证失败拒绝执行，不下载替换公钥。
+
+卸载先执行 `agentguard uninstall`，确认配置恢复、令牌撤销和钥匙串清理后，再执行 `npm rm -g @agentguardx/helper`。直接 npm 卸载不会清理用户数据；`preuninstall` 仅作提示，部分 npm 版本不会运行卸载生命周期，不能依赖该提示代替清理。
+
+离线安装若将主包与平台 tgz 同时全局安装，npm 可能把平台包登记为显式根依赖。移除主包后若该平台包仍在，请同时 `npm rm -g @agentguardx/helper-<平台>-<架构>`；正常 registry 安装的 optional 依赖由 npm 管理。卸载检查只确认命令消失和用户凭据/配置清理，不声称清空全部 npm 缓存。
+
+Claude Desktop 的 stdio 桥接保存当前 Node 程序与主包启动器的绝对路径，复用同一个执行前验签入口，再由 Go 自行复核自身和 helper。若清理了对应 npx 缓存，或原 Node 路径已失效，须重新接入；可全局安装后再接入，不能保证 npx 缓存永久保留。
+
+本机安全工具命令（全局安装示例；仅 npx 使用时替换为 `npx -- @agentguardx/helper`）：
+
+```sh
+agentguard connect opencode
+agentguard launch opencode
+agentguard mcp serve
+agentguard pause
+agentguard resume
+agentguard activity
+```
+
+`mcp serve` 的 stdout 专用于 stdio MCP 协议，工作根固定为进程启动目录，不接受模型自报身份或 root。`pause` 是本机应急停用，不是企业级一键暂停，也不能撤回已发生的副作用。

package/bin/agentguard.cjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+'use strict';
+const { verifiedRuntime, run } = require('../lib/runtime.cjs');
+async function main() {
+  if (Number(process.versions.node.split('.')[0]) < 18) throw new Error('node_18_required');
+  const runtime = verifiedRuntime();
+  const args = process.argv.slice(2);
+  // The wizard starts with no arguments, "init", or only --server/--config-dir
+  // pairs; anything else (for example "--server X server show") goes to the Go core.
+  const initArgs = args[0] === 'init' ? args.slice(1) : args;
+  const wizardOnly = initArgs.length % 2 === 0 && initArgs.every((value, index) => index % 2 ? !value.startsWith('--') : value === '--server' || value === '--config-dir');
+  if (!args.length || args[0] === 'init' || wizardOnly) {
+    await require('../lib/wizard.cjs').init(runtime, initArgs);
+  } else {
+    process.exitCode = await run(runtime, args);
+  }
+}
+main().catch(error => {
+  const code = /^[a-z0-9_]+$/.test(error.message) ? error.message : 'helper_operation_failed';
+  process.stderr.write(`接入助手未完成：${code}\n`); process.exitCode = 1;
+});

package/lib/preuninstall.cjs

@@ -0,0 +1,2 @@
+'use strict';
+process.stderr.write('卸载 npm 包不会清理登录和工具配置。请先执行 agentguard uninstall，确认撤销令牌、清理钥匙串并恢复配置，再执行 npm rm -g @agentguardx/helper。\n');

package/lib/runtime.cjs

@@ -0,0 +1,106 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+const PIN = 'b6ad0e1a776a0db7b3edc5c4a9a367d1cd3801dc97dc0e27af0ea0d3e7b52e1f';
+const KEY_ID = 'agentguard-cli-rsa3072-20261023';
+const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+function ordinary(file, limit) {
+  const before = fs.lstatSync(file);
+  if (!before.isFile() || before.size > limit || before.isSymbolicLink()) throw new Error('npm_artifact_invalid');
+  const fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+  try {
+    const after = fs.fstatSync(fd);
+    if (after.dev !== before.dev || after.ino !== before.ino || !after.isFile()) throw new Error('npm_artifact_changed');
+    return fs.readFileSync(fd);
+  } finally { fs.closeSync(fd); }
+}
+function verifiedRuntime() {
+  const owner = path.resolve(__dirname, '..');
+  const metadata = JSON.parse(ordinary(path.join(owner, 'package.json'), 65536));
+  const target = `${process.platform}-${process.arch}`;
+  if (!Object.hasOwn(metadata.optionalDependencies, `@agentguardx/helper-${target}`)) throw new Error('npm_platform_unsupported');
+  let directory;
+  try { directory = path.dirname(require.resolve(`@agentguardx/helper-${target}/package.json`)); }
+  catch { throw new Error('npm_platform_package_missing'); }
+  directory = fs.realpathSync(directory);
+  const platformMetadata = JSON.parse(ordinary(path.join(directory, 'package.json'), 65536));
+  if (platformMetadata.name !== `@agentguardx/helper-${target}` || platformMetadata.version !== metadata.version) throw new Error('npm_package_version_mismatch');
+  const key = ordinary(path.join(owner, 'release-public.pem'), 8192);
+  if (hash(key) !== PIN) throw new Error('npm_release_key_changed');
+  const bytes = ordinary(path.join(directory, 'manifest.tsv'), 1 << 20);
+  const signature = ordinary(path.join(directory, 'manifest.tsv.sig'), 8192);
+  if (!crypto.verify('RSA-SHA256', bytes, { key, padding: crypto.constants.RSA_PKCS1_PADDING }, signature)) throw new Error('npm_release_signature_invalid');
+  const values = new Map(), artifacts = new Map();
+  if (!bytes.length || bytes[bytes.length - 1] !== 10 || bytes.includes(13)) throw new Error('npm_manifest_invalid');
+  for (const line of bytes.toString('utf8').slice(0, -1).split('\n')) {
+    const row = line.split('\t');
+    if (row.length === 2 && ['format', 'distribution', 'version', 'key_id', 'public_key_sha256'].includes(row[0]) && !values.has(row[0])) values.set(row[0], row[1]);
+    else if (row.length === 4 && row[0] === 'artifact' && /^agentguard(?:-keychain)?-(?:darwin|linux|windows)-(?:amd64|arm64)(?:\.exe)?$/.test(row[1]) && /^[1-9][0-9]*$/.test(row[2]) && /^[0-9a-f]{64}$/.test(row[3]) && !artifacts.has(row[1])) artifacts.set(row[1], { size: Number(row[2]), hash: row[3] });
+    else throw new Error('npm_manifest_invalid');
+  }
+  if (values.size !== 5 || values.get('format') !== '1' || values.get('distribution') !== 'npm' || values.get('version') !== `v${metadata.version}` || values.get('key_id') !== KEY_ID || values.get('public_key_sha256') !== PIN) throw new Error('npm_manifest_identity_invalid');
+  const goOS = process.platform === 'win32' ? 'windows' : process.platform;
+  const goArch = process.arch === 'x64' ? 'amd64' : process.arch;
+  const binaryName = `agentguard-${goOS}-${goArch}${goOS === 'windows' ? '.exe' : ''}`;
+  const names = [binaryName];
+  if (process.platform === 'darwin') names.push(`agentguard-keychain-${goOS}-${goArch}`);
+  for (const name of names) {
+    const expected = artifacts.get(name), actual = ordinary(path.join(directory, name), 128 << 20);
+    if (!expected || actual.length !== expected.size || hash(actual) !== expected.hash) throw new Error('npm_artifact_hash_mismatch');
+  }
+  return { binary: path.join(directory, binaryName), directory, owner, version: metadata.version };
+}
+function run(runtime, args, input) {
+  // Verify again directly before each process launch; never download a new key.
+  const current = verifiedRuntime();
+  if (current.binary !== runtime.binary) throw new Error('npm_runtime_changed');
+  const env = { ...process.env, AGENTGUARD_DISTRIBUTION: 'npm', AGENTGUARD_NPM_PACKAGE_DIR: runtime.owner, AGENTGUARD_NPM_PLATFORM_DIR: runtime.directory, AGENTGUARD_NPM_NODE_EXECUTABLE: process.execPath };
+  return new Promise((resolve, reject) => {
+    const child = spawn(runtime.binary, args, { env, shell: false, stdio: [input === undefined ? 'inherit' : 'pipe', 'inherit', 'inherit'] });
+    child.once('error', () => reject(new Error('npm_binary_launch_failed')));
+    child.once('exit', code => resolve(code === null ? 1 : code));
+    if (input !== undefined) { child.stdin.on('error', () => {}); child.stdin.end(input); }
+  });
+}
+function queryConsent(runtime, server, prefix) {
+  const current = verifiedRuntime();
+  if (current.binary !== runtime.binary) throw new Error('npm_runtime_changed');
+  const env = { ...process.env, AGENTGUARD_DISTRIBUTION: 'npm', AGENTGUARD_NPM_PACKAGE_DIR: runtime.owner, AGENTGUARD_NPM_PLATFORM_DIR: runtime.directory, AGENTGUARD_NPM_NODE_EXECUTABLE: process.execPath };
+  return new Promise((resolve, reject) => {
+    const child = spawn(runtime.binary, [...prefix, 'http-consent', '--server', server], { env, shell: false, stdio: ['ignore', 'pipe', 'ignore'] });
+    let bytes = 0, chunks = [];
+    child.stdout.on('data', chunk => { bytes += chunk.length; if (bytes > 65536) { child.kill(); reject(new Error('http_consent_query_failed')); } else chunks.push(chunk); });
+    child.once('error', () => reject(new Error('http_consent_query_failed')));
+    child.once('close', code => {
+      try {
+        if (code !== 0) throw new Error();
+        const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (value.server !== server || typeof value.acknowledged !== 'boolean' || typeof value.requires_confirmation !== 'boolean') throw new Error();
+        resolve(value);
+      } catch { reject(new Error('http_consent_query_failed')); }
+    });
+  });
+}
+// Reads one bounded, non-secret JSON object printed by the verified Go core.
+function queryJSON(runtime, args) {
+  const current = verifiedRuntime();
+  if (current.binary !== runtime.binary) throw new Error('npm_runtime_changed');
+  const env = { ...process.env, AGENTGUARD_DISTRIBUTION: 'npm', AGENTGUARD_NPM_PACKAGE_DIR: runtime.owner, AGENTGUARD_NPM_PLATFORM_DIR: runtime.directory, AGENTGUARD_NPM_NODE_EXECUTABLE: process.execPath };
+  return new Promise((resolve, reject) => {
+    const child = spawn(runtime.binary, args, { env, shell: false, stdio: ['ignore', 'pipe', 'ignore'] });
+    let bytes = 0, chunks = [];
+    child.stdout.on('data', chunk => { bytes += chunk.length; if (bytes > 65536) { child.kill(); reject(new Error('core_query_failed')); } else chunks.push(chunk); });
+    child.once('error', () => reject(new Error('core_query_failed')));
+    child.once('close', code => {
+      try {
+        if (code !== 0) throw new Error();
+        const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error();
+        resolve(value);
+      } catch { reject(new Error('core_query_failed')); }
+    });
+  });
+}
+module.exports = { verifiedRuntime, run, queryConsent, queryJSON };

package/lib/wizard.cjs

@@ -0,0 +1,196 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const http = require('node:http');
+const https = require('node:https');
+const readline = require('node:readline');
+const { run, queryConsent, queryJSON } = require('./runtime.cjs');
+
+function terminal() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error('init_requires_interactive_terminal');
+  readline.emitKeypressEvents(process.stdin);
+  return handler => new Promise((resolve, reject) => {
+    const previous = !!process.stdin.isRaw;
+    let finished = false;
+    const finish = (error, value) => {
+      if (finished) return;
+      finished = true;
+      process.stdin.removeListener('keypress', listener); process.stdin.setRawMode(previous); process.stdin.pause();
+      error ? reject(error) : resolve(value);
+    };
+    const listener = (text, key = {}) => {
+      if (finished) return;
+      if (key.ctrl && key.name === 'c') { process.stdout.write('\n'); finish(new Error('init_cancelled')); }
+      else handler(text, key, value => finish(null, value));
+    };
+    process.stdin.on('keypress', listener);
+    process.stdin.setRawMode(true); process.stdin.resume();
+  });
+}
+const SOURCE_LABEL = { flag: '命令行参数', env: '环境变量', saved: '上次保存的配置' };
+async function question(ask, label, masked = false) {
+  let value = '';
+  const pending = ask((text, key, done) => {
+    if (key.name === 'return' || key.name === 'enter') { process.stdout.write('\n'); done(value); }
+    else if (key.name === 'backspace') {
+      if (value.length) { value = Array.from(value).slice(0, -1).join(''); process.stdout.write('\b \b'); }
+    } else if (text && !key.ctrl && !key.meta && !/[\x00-\x1f\x7f]/.test(text)) {
+      if (value.length + text.length <= 8192) { value += text; process.stdout.write(masked ? '*'.repeat(Array.from(text).length) : text); }
+    }
+  });
+  // Install raw/no-echo input before exposing the token prompt to a fast paste.
+  process.stdout.write(label);
+  return pending;
+}
+async function choose(ask, label, options, multiple = false) {
+  let cursor = 0, selected = new Set();
+  const render = first => {
+    if (!first) process.stdout.write(`\x1b[${options.length}A`);
+    options.forEach((option, index) => process.stdout.write(`\x1b[2K\r${cursor === index ? '›' : ' '} ${multiple ? `[${selected.has(index) ? '✓' : ' '}] ` : ''}${option.label}\n`));
+  };
+  const pending = ask((text, key, done) => {
+    if (key.name === 'up') cursor = (cursor + options.length - 1) % options.length;
+    else if (key.name === 'down') cursor = (cursor + 1) % options.length;
+    else if (multiple && key.name === 'space') selected.has(cursor) ? selected.delete(cursor) : selected.add(cursor);
+    else if (key.name === 'return' || key.name === 'enter') { done(multiple ? [...selected].sort().map(i => options[i].value) : options[cursor].value); return; }
+    render(false);
+  });
+  process.stdout.write(label + (multiple ? '（↑↓ 移动，空格勾选，Enter 确认）\n' : '（↑↓ 选择，Enter 确认）\n')); render(true);
+  return pending;
+}
+function serverOrigin(raw) {
+  let url; try { url = new URL(raw.trim()); } catch { throw new Error('server_address_invalid'); }
+  if (url.username || url.password || url.search || url.hash || url.pathname !== '/' || !['https:', 'http:'].includes(url.protocol)) throw new Error('server_address_invalid');
+  return url.origin;
+}
+function config(server) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(server + '/client/v1/config');
+    const options = { timeout: 10000, headers: { Accept: 'application/json' } };
+    if (target.protocol === 'https:' && process.env.AGENTGUARD_CA_FILE) options.ca = fs.readFileSync(process.env.AGENTGUARD_CA_FILE);
+    const request = (target.protocol === 'https:' ? https : http).get(target, options, response => {
+      if (response.statusCode !== 200) { response.resume(); reject(new Error('server_config_unavailable')); return; }
+      let bytes = 0, chunks = [];
+      response.on('data', chunk => { bytes += chunk.length; if (bytes > 65536) { response.destroy(); reject(new Error('server_config_invalid')); } else chunks.push(chunk); });
+      response.on('error', () => reject(new Error('server_config_unavailable')));
+      response.on('end', () => {
+        try {
+          const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+          if (body.code && body.code !== 'ok') throw new Error('server_config_invalid');
+          const result = body.data || body;
+          if (!result || typeof result !== 'object' || typeof result.version !== 'string') throw new Error('server_config_invalid');
+          resolve(result);
+        } catch { reject(new Error('server_config_invalid')); }
+      });
+    });
+    request.on('timeout', () => request.destroy()); request.on('error', () => reject(new Error('server_config_unavailable')));
+  });
+}
+function detectedTools() {
+  const home = os.homedir(), windows = process.platform === 'win32';
+  const command = name => (process.env.PATH || '').split(path.delimiter).some(dir => (windows ? ['', '.exe', '.cmd', '.bat'] : ['']).some(ext => {
+    try { const file = path.join(dir, name + ext); return fs.statSync(file).isFile() && (windows || (fs.accessSync(file, fs.constants.X_OK), true)); } catch { return false; }
+  }));
+  const apps = (mac, win) => process.platform === 'darwin' ? ['/Applications', path.join(home, 'Applications')].some(dir => fs.existsSync(path.join(dir, mac))) : windows && !!process.env.LOCALAPPDATA && fs.existsSync(path.join(process.env.LOCALAPPDATA, win));
+  return [
+    { label: 'OpenCode（模型与远程 MCP）', value: 'opencode', present: command('opencode') },
+    { label: 'OpenClaw（模型）', value: 'openclaw', present: command('openclaw') },
+    { label: 'Cursor（远程 MCP）', value: 'cursor', present: command('cursor') || apps('Cursor.app', 'Programs/Cursor/Cursor.exe') },
+    { label: 'Claude Desktop（MCP 桥接）', value: 'claude-desktop', present: command('claude-desktop') || apps('Claude.app', 'AnthropicClaude/Claude.exe') },
+    { label: 'Cherry Studio（手动填写说明）', value: 'cherry-studio', present: apps('Cherry Studio.app', 'Programs/Cherry Studio/Cherry Studio.exe') },
+  ].filter(item => item.present);
+}
+async function currentServer(runtime, prefix, flagServer) {
+  // Priority --server > AGENTGUARD_SERVER > saved configuration is resolved by the Go core.
+  try { return await queryJSON(runtime, [...prefix, ...(flagServer ? ['--server', flagServer] : []), 'server', 'show']); }
+  catch { return {}; }
+}
+function normalizeInput(raw) {
+  let value = raw.trim();
+  const explicit = /^https?:\/\//i.test(value);
+  if (value && !explicit) value = 'https://' + value;
+  return { server: serverOrigin(value), explicit };
+}
+async function init(runtime, args) {
+  let flagServer = '', root = '';
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--server' && args[i + 1]) flagServer = args[++i];
+    else if (args[i] === '--config-dir' && args[i + 1]) root = args[++i];
+    else throw new Error('init_arguments_invalid');
+  }
+  const prefix = root ? ['--config-dir', root] : [];
+  const ask = terminal();
+  process.stdout.write('AgentGuard 企业接入助手\n');
+  const state = await currentServer(runtime, prefix, flagServer);
+  const fallback = typeof state.server === 'string' ? state.server : '';
+  let server = '', details;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const hint = fallback ? `（${SOURCE_LABEL[state.source] || '当前配置'}：${fallback}，回车沿用，或输入新的 IP/域名）` : '（https://企业域名，或 http://IP:端口）';
+    const typed = (await question(ask, `企业服务器地址${hint}：`)).trim();
+    const chosen = typed || fallback;
+    if (!chosen) throw new Error('server_address_invalid');
+    const normalized = normalizeInput(chosen);
+    try { details = await config(normalized.server); server = normalized.server; break; }
+    catch (error) {
+      if (attempt === 2) throw error;
+      process.stdout.write(`无法连接 ${normalized.server}（${error.message}）。${normalized.explicit ? '' : '未写协议时按 HTTPS 访问；如服务器使用 HTTP，请输入 http://地址。'}请重新输入。\n`);
+    }
+  }
+  if (typeof details.enterprise_name === 'string') process.stdout.write(details.enterprise_name.replace(/[\x00-\x1f\x7f-\x9f]/g, '').slice(0, 100) + '\n');
+  process.stdout.write('服务器配置可达。\n');
+  const choices = [{ label: '浏览器网页授权登录（以控制台当前登录的人授权）', value: 'browser' }, { label: '粘贴个人访问令牌', value: 'token' }];
+  let httpFlags = [];
+  if (new URL(server).protocol === 'http:') {
+    const consent = await queryConsent(runtime, server, prefix);
+    if (!consent.acknowledged) {
+      const answer = await choose(ask, 'HTTP 会以明文传输登录信息、个人令牌和业务内容，网络中间人可能读取或篡改。是否确认对该服务器继续？', [
+        { label: '取消，不发送登录信息或令牌', value: false },
+        { label: '我已了解明文风险，确认继续', value: true },
+      ]);
+      if (!answer) throw new Error('http_confirmation_required');
+    }
+    httpFlags = ['--allow-http'];
+  }
+  let code, loggedInHere = false;
+  if (state.logged_in && state.login_server && state.login_server !== server) {
+    process.stdout.write(`本机已有登录属于另一台服务器（${state.login_server}）。该登录不会发送给新服务器，切换后需要重新登录。\n`);
+    const action = await choose(ask, '如何处理旧登录？', [
+      { label: '退出旧服务器登录（撤销旧令牌）并恢复已接入工具的原配置，然后登录新服务器', value: 'switch' },
+      { label: '取消，保持原服务器和登录不变', value: 'cancel' },
+    ]);
+    if (action !== 'switch') throw new Error('server_switch_cancelled');
+    code = await run(runtime, [...prefix, 'server', 'set', server, ...httpFlags, '--switch'], '');
+    if (code) {
+      const local = await choose(ask, '旧服务器登录没有退出。若旧服务器已无法访问，可只清除本机登录：', [
+        { label: '只清除本机旧登录（旧令牌在服务端仍有效，直到到期或由管理员撤销）', value: 'local' },
+        { label: '取消', value: 'cancel' },
+      ]);
+      if (local !== 'local') { process.exitCode = code; return; }
+      code = await run(runtime, [...prefix, 'server', 'set', server, ...httpFlags, '--switch', '--local-only'], '');
+      if (code) { process.exitCode = code; return; }
+    }
+  } else if (state.logged_in && state.login_server === server) {
+    process.stdout.write('本机已登录该服务器，沿用现有登录。如需换人，请先执行 agentguard logout。\n');
+    loggedInHere = true;
+  }
+  if ((process.env.AGENTGUARD_SERVER || '') && process.env.AGENTGUARD_SERVER.replace(/\/+$/, '') !== server) process.stdout.write(`提示：环境变量 AGENTGUARD_SERVER 指向 ${process.env.AGENTGUARD_SERVER}，与本次所选服务器不同；后续命令请取消该变量或用 --server 指定。\n`);
+  const method = loggedInHere ? 'existing' : await choose(ask, '选择登录方式', choices);
+  if (method === 'existing') code = 0;
+  else if (method === 'token') {
+    let token = await question(ask, '个人访问令牌（输入隐藏）：', true);
+    if (!token.trim() || /[\r\n]/.test(token)) throw new Error('personal_token_invalid');
+    code = await run(runtime, [...prefix, 'auth', 'token', '--server', server, ...httpFlags, '--defer-notice'], token.trim() + '\n'); token = '';
+  } else code = await run(runtime, [...prefix, 'login', '--server', server, ...httpFlags, '--defer-notice'], '');
+  if (code) { process.exitCode = code; return; }
+  const tools = detectedTools();
+  if (!tools.length) process.stdout.write('未检测到本批支持的工具；安装工具后可运行 agentguard connect <工具名>。\n');
+  else {
+    const selected = await choose(ask, '选择要接入的已检测工具', tools, true);
+    for (const tool of selected) { code = await run(runtime, [...prefix, 'connect', tool], ''); if (code) { process.exitCode = code; return; } }
+    if (selected.includes('opencode')) process.stdout.write('OpenCode 接入包含本机安全 MCP 配置。请通过 launch 启动，使用 ag_* 工具；实际连接与授权结果以诊断和服务端记录为准。\n');
+  }
+  process.stdout.write('运行实际诊断：\n'); code = await run(runtime, [...prefix, 'doctor'], ''); process.exitCode = code;
+  process.stdout.write(code === 0 ? '初始化完成。用 npx @agentguardx/helper launch <工具名> 启动；全局安装后也可用 agentguard launch <工具名>。\n' : '诊断未全部通过，请按上述实际结果处理。\n');
+}
+module.exports = { init, serverOrigin, detectedTools };

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@agentguardx/helper",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.88",
+  "description": "AgentGuard \u5458\u5de5\u63a5\u5165\u52a9\u624b",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "agentguard": "bin/agentguard.cjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "release-public.pem",
+    "README.md"
+  ],
+  "scripts": {
+    "preuninstall": "node lib/preuninstall.cjs"
+  },
+  "optionalDependencies": {
+    "@agentguardx/helper-darwin-x64": "0.3.88",
+    "@agentguardx/helper-darwin-arm64": "0.3.88",
+    "@agentguardx/helper-linux-x64": "0.3.88",
+    "@agentguardx/helper-linux-arm64": "0.3.88",
+    "@agentguardx/helper-win32-x64": "0.3.88",
+    "@agentguardx/helper-win32-arm64": "0.3.88"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/release-public.pem

@@ -0,0 +1,11 @@
+-----BEGIN PUBLIC KEY-----
+MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAzfALBceoxdwk8B6i+mHv
+7L8DFBMM+WD7/WVOGY33/PVeO1UwGIn1sehHG4FXvFUGXPcEiDYrkAZJ4ZgidGhk
+4W0efJCTLyIHuntRbWfCdhnxg+whTzfnPw0lLQp0PPRPjLWHT0LSQTM47nMvbMEK
+/BbB3aF6FMoIzhib/uNNyjR6eVDDr89hsU5Gk70ki2aIkPCoiWrMbo7NX0yPjuAN
+nSb04i1tQZKM9uYzqGu/IS6UvRIMP9N77PgPY5nHtx5UeN4jSzmedY2FH5CwBdNR
+Ldt5h6n9m6/kxUho5KNWVbCpsg3DgjSOn97LjZqXu2L6liplrHlmo1vHxuodamdf
+BbqBFVC/zLtzrE++ZiYlqQiS30WwY7cHa70Fed5B955uCG2vTFgwTT3Noa/Nv7in
+Tszfi/4IHkXJuyqzR4gOvfgl3A6MdHEsnnna0FoJmFbT8AZxNpHqFRk1RE0s9+F6
+jQadzdy4BMOrMbzg6ga1WJvHCZuSMRijve5N4ZbOgMC3AgMBAAE=
+-----END PUBLIC KEY-----