ones-fetch 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,19 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm install:*)",
+      "Bash(node:*)",
+      "Bash(timeout 3 npm start)",
+      "Bash(ls:*)",
+      "Bash(python process_icon.py)",
+      "Bash(python -c \"from PIL import Image; img = Image.open\\('public/icon.png'\\); print\\(f'尺寸: {img.size}, 模式: {img.mode}'\\)\")",
+      "Bash(git add:*)",
+      "Bash(git reset:*)",
+      "Bash(git mv:*)",
+      "Bash(gh --version)",
+      "Bash(gh repo:*)",
+      "Bash(npm whoami:*)",
+      "Bash(npm login:*)"
+    ]
+  }
+}

package/README.md

@@ -0,0 +1,149 @@
+# ONES 子任务采集工具
+
+一个本地 Web 工具，用浏览器界面批量解析 ONES 任务链接或任务编号，并递归抓取所有子任务。
+
+## 快速安装（推荐）
+
+策划电脑上已有 Node.js，执行一条命令即可：
+
+```bash
+npx ones-fetch
+```
+
+这会自动：
+- 安装依赖（约 30MB）
+- 在桌面创建快捷方式
+- 完成后双击桌面图标即可使用
+
+---
+
+## 环境要求
+
+- Node.js 18+
+- Chrome 或 Edge 浏览器（系统已安装）
+- 可访问的 ONES 租户 URL
+
+## 手动安装
+
+```bash
+git clone <repo-url>
+cd ones-fetch
+npm install
+```
+
+---
+
+## 使用方法
+
+### 方式 1：双击启动（推荐给非技术用户）
+
+**Windows 用户：**
+- 双击 `启动 ONES 采集工具.vbs`
+- 首次运行会自动安装依赖
+- 浏览器会自动打开工具页面
+
+### 方式 2：命令行启动
+
+```bash
+npm start
+# 或开发模式（自动重启）
+npm run dev
+```
+
+启动后会自动打开浏览器访问 `http://localhost:3000`。
+
+### 使用流程
+
+1. **首次使用 - 连接 ONES**
+   - 页面会提示"连接 ONES"
+   - 点击后会打开浏览器登录页
+   - 登录完成后，系统会自动捕获认证信息和 team-id
+
+2. **粘贴任务文本**
+   - 支持粘贴完整 ONES 任务链接
+   - 也支持直接粘贴 `#90182|#90183` 这种编号文本
+   - 页面会自动提取任务编号并递归抓取所有子任务
+
+3. **查看结果**
+   - 任务列表会显示所有子任务
+   - 包含任务编号、标题、状态、负责人、截止日期等信息
+
+---
+
+## 技术说明
+
+### 认证机制
+
+- 首次登录时，系统会启动浏览器窗口
+- 自动从页面 URL 提取 team-id（格式：`/team/{uuid}/...`）
+- 认证信息保存在 `~/.ones-fetch/credentials.json`（权限 600）
+- 令牌过期时会提示重新登录
+
+### Web API
+
+服务提供以下接口：
+
+| 方法 | 路径 | 说明 |
+|---|---|---|
+| `GET` | `/` | Web UI 首页 |
+| `GET` | `/api/auth/status` | 当前认证状态 |
+| `POST` | `/api/auth/login` | 启动浏览器登录采集 |
+| `POST` | `/api/crawl` | 批量采集接口 |
+
+**`/api/crawl` 请求格式：**
+
+```json
+{
+  "taskIds": ["90182", "90183", "HM6gttraKPOVnrdy"],
+  "baseUrl": "https://your-team.ones.cn",
+  "teamId": "<team-uuid>"
+}
+```
+
+**响应格式：**
+
+```json
+{
+  "roots": ["<uuid1>", "<uuid2>"],
+  "tasks": [
+    { "uuid": "...", "root_uuid": "<uuid1>", "number": "...", "summary": "...", ... },
+    ...
+  ]
+}
+```
+
+错误时返回 `401`（需要登录或令牌过期）或 `500`（采集失败）。
+
+---
+
+## 环境变量
+
+可选的环境变量：
+
+| 变量 | 说明 |
+|---|---|
+| `PORT` | 服务端口（默认 3000） |
+| `ONES_BASE_URL` | ONES 基础 URL |
+| `ONES_TEAM_ID` | 团队 UUID（通常自动检测） |
+
+---
+
+## 本地凭证文件
+
+| 路径 | 用途 |
+|---|---|
+| `~/.ones-fetch/credentials.json` | 登录时保存的认证令牌（权限 600） |
+
+---
+
+## 项目结构
+
+```
+ones-fetch/
+├── src/
+│   ├── server.mjs      # HTTP 服务器和任务爬取逻辑
+│   └── auth.mjs        # 浏览器登录和凭证管理
+├── public/
+│   └── index.html      # Web UI 界面
+└── package.json
+```

package/bin/install.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = join(__dirname, '..');
+
+async function createWindowsShortcut() {
+  const desktop = join(homedir(), 'Desktop');
+  const shortcutPath = join(desktop, 'ONES 采集工具.lnk');
+  const iconPath = join(projectRoot, 'public', 'icon.png');
+  const vbsLauncher = join(projectRoot, 'public', 'launcher.vbs');
+
+  // 创建 PowerShell 脚本来生成快捷方式
+  const psScript = `
+$WshShell = New-Object -ComObject WScript.Shell
+$Shortcut = $WshShell.CreateShortcut("${shortcutPath.replace(/\\/g, '\\\\')}")
+$Shortcut.TargetPath = "wscript.exe"
+$Shortcut.Arguments = '"${vbsLauncher.replace(/\\/g, '\\\\')}"'
+$Shortcut.WorkingDirectory = "${projectRoot.replace(/\\/g, '\\\\')}"
+$Shortcut.IconLocation = "${iconPath.replace(/\\/g, '\\\\')}"
+$Shortcut.Description = "ONES 任务采集工具"
+$Shortcut.Save()
+`;
+
+  const tempPs1 = join(projectRoot, 'temp-create-shortcut.ps1');
+  await writeFile(tempPs1, psScript, 'utf8');
+
+  try {
+    await execAsync(`powershell -ExecutionPolicy Bypass -File "${tempPs1}"`);
+    console.log(`✓ 桌面快捷方式已创建: ${shortcutPath}`);
+  } finally {
+    // 清理临时文件
+    try {
+      await execAsync(`del "${tempPs1}"`);
+    } catch {}
+  }
+}
+
+async function createMacShortcut() {
+  const desktop = join(homedir(), 'Desktop');
+  const appPath = join(desktop, 'ONES 采集工具.command');
+
+  const scriptContent = `#!/bin/bash
+cd "${projectRoot}"
+node src/server.mjs &
+sleep 2
+open http://localhost:3000
+`;
+
+  await writeFile(appPath, scriptContent, 'utf8');
+  await execAsync(`chmod +x "${appPath}"`);
+  console.log(`✓ 桌面快捷方式已创建: ${appPath}`);
+}
+
+async function createLinuxShortcut() {
+  const desktop = join(homedir(), 'Desktop');
+  const desktopFile = join(desktop, 'ones-fetch.desktop');
+
+  const content = `[Desktop Entry]
+Version=1.0
+Type=Application
+Name=ONES 采集工具
+Exec=bash -c "cd ${projectRoot} && node src/server.mjs & sleep 2 && xdg-open http://localhost:3000"
+Icon=utilities-terminal
+Terminal=false
+Categories=Utility;
+`;
+
+  await writeFile(desktopFile, content, 'utf8');
+  await execAsync(`chmod +x "${desktopFile}"`);
+  console.log(`✓ 桌面快捷方式已创建: ${desktopFile}`);
+}
+
+async function main() {
+  console.log('ONES Fetch 安装程序\n');
+
+  // 安装依赖
+  console.log('正在安装依赖...');
+  try {
+    await execAsync('npm install', { cwd: projectRoot });
+    console.log('✓ 依赖安装完成\n');
+  } catch (err) {
+    console.error('✗ 依赖安装失败:', err.message);
+    process.exit(1);
+  }
+
+  // 创建桌面快捷方式
+  console.log('正在创建桌面快捷方式...');
+  try {
+    const os = platform();
+    if (os === 'win32') {
+      await createWindowsShortcut();
+    } else if (os === 'darwin') {
+      await createMacShortcut();
+    } else {
+      await createLinuxShortcut();
+    }
+  } catch (err) {
+    console.error('✗ 快捷方式创建失败:', err.message);
+    process.exit(1);
+  }
+
+  console.log('\n✓ 安装完成！');
+  console.log('\n使用方法：');
+  console.log('  1. 双击桌面上的 "ONES 采集工具" 图标');
+  console.log('  2. 浏览器会自动打开工具页面');
+  console.log('\n或者在命令行运行：');
+  console.log(`  cd ${projectRoot}`);
+  console.log('  npm start');
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "ones-fetch",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "ONES Fetch — Web app for recursive ONES subtask crawling",
+  "bin": {
+    "ones-fetch": "./bin/install.mjs"
+  },
+  "scripts": {
+    "start": "node src/server.mjs",
+    "dev": "node --watch src/server.mjs"
+  },
+  "dependencies": {
+    "playwright-core": "^1.58.2"
+  },
+  "keywords": ["ones", "task", "crawler", "project-management"],
+  "author": "",
+  "license": "MIT"
+}

package/public/index.html

@@ -0,0 +1,385 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>ONES 任务解析器</title>
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #f5f7fa; color: #1a1a2e; min-height: 100vh; }
+  .container { max-width: 1100px; margin: 0 auto; padding: 24px 16px; }
+  h1 { font-size: 1.5rem; font-weight: 700; margin-bottom: 4px; color: #1a1a2e; }
+  .subtitle { font-size: 0.875rem; color: #6b7280; margin-bottom: 20px; }
+  .input-card { background: #fff; border-radius: 10px; padding: 20px; box-shadow: 0 1px 4px rgba(0,0,0,.08); margin-bottom: 16px; }
+  textarea { width: 100%; height: 140px; border: 1px solid #d1d5db; border-radius: 6px; padding: 10px 12px; font-size: 0.875rem; font-family: inherit; resize: vertical; outline: none; transition: border-color .2s; }
+  textarea:focus { border-color: #6366f1; }
+  .row { display: flex; gap: 10px; align-items: center; margin-top: 12px; flex-wrap: wrap; }
+  .hint { font-size: 0.8125rem; color: #6b7280; }
+  button { cursor: pointer; border: none; border-radius: 6px; padding: 8px 18px; font-size: 0.875rem; font-weight: 500; transition: opacity .15s, background .15s; }
+  button:disabled { opacity: .5; cursor: not-allowed; }
+  .btn-primary { background: #6366f1; color: #fff; }
+  .btn-primary:hover:not(:disabled) { background: #4f46e5; }
+  .btn-secondary { background: #e5e7eb; color: #374151; }
+  .btn-secondary:hover:not(:disabled) { background: #d1d5db; }
+  .btn-success { background: #10b981; color: #fff; }
+  .btn-success:hover:not(:disabled) { background: #059669; }
+  .btn-link { background: #f59e0b; color: #fff; }
+  .btn-link:hover:not(:disabled) { background: #d97706; }
+  .status { font-size: 0.8125rem; color: #6b7280; }
+  .status.error { color: #ef4444; }
+  .preview-chips { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 10px; }
+  .chip { background: #ede9fe; color: #5b21b6; font-size: 0.75rem; padding: 3px 10px; border-radius: 999px; font-family: monospace; }
+  .toolbar { display: flex; gap: 8px; align-items: center; margin-bottom: 12px; flex-wrap: wrap; }
+  .results-card { background: #fff; border-radius: 10px; box-shadow: 0 1px 4px rgba(0,0,0,.08); overflow: hidden; }
+  .table-wrap { overflow-x: auto; }
+  table { width: 100%; border-collapse: collapse; font-size: 0.8125rem; }
+  th { background: #f9fafb; text-align: left; padding: 10px 14px; font-weight: 600; color: #6b7280; border-bottom: 1px solid #e5e7eb; white-space: nowrap; }
+  td { padding: 9px 14px; border-bottom: 1px solid #f3f4f6; vertical-align: middle; }
+  tr:last-child td { border-bottom: none; }
+  tr:hover td { background: #fafafa; }
+  .indent { display: inline-block; }
+  .toggle-btn { cursor: pointer; background: none; border: none; padding: 0 4px 0 0; font-size: 0.75rem; color: #9ca3af; line-height: 1; vertical-align: middle; }
+  .toggle-btn:hover { color: #6366f1; }
+  .num-cell { font-weight: 600; color: #4f46e5; white-space: nowrap; }
+  .num-link { color: inherit; text-decoration: none; }
+  .num-link:hover { text-decoration: underline; }
+  .tag { display: inline-block; font-size: 0.7rem; padding: 2px 7px; border-radius: 4px; background: #dbeafe; color: #1d4ed8; }
+  .empty { text-align: center; color: #9ca3af; padding: 40px; font-size: 0.875rem; }
+  .loading { text-align: center; color: #6b7280; padding: 40px; }
+  .spinner { display: inline-block; width: 18px; height: 18px; border: 2px solid #e5e7eb; border-top-color: #6366f1; border-radius: 50%; animation: spin .7s linear infinite; vertical-align: middle; margin-right: 6px; }
+  @keyframes spin { to { transform: rotate(360deg); } }
+  .copied { background: #10b981 !important; }
+</style>
+</head>
+<body>
+<div class="container">
+  <h1>ONES 任务解析器</h1>
+  <p class="subtitle">粘贴包含 ONES 任务链接或 #任务编号 的文本，自动提取并递归获取所有子任务</p>
+
+  <div class="input-card">
+    <textarea id="input" placeholder="粘贴任务文本，例如：&#10;#80487 【9.12】去掉封印英雄相关的内容&#10;https://ones.kingamer.cn/project/#/team/EPySA1xa/task/Dw3sXNfzJOJ73Gfg"></textarea>
+    <div class="row">
+      <button class="btn-primary" id="parseBtn" onclick="parse()">解 析</button>
+      <button class="btn-secondary" onclick="clearAll()">清 空</button>
+      <button class="btn-link" id="authBtn" onclick="connectOnes()" style="display:none">连接 ONES</button>
+      <span class="status" id="status"></span>
+    </div>
+    <div class="hint" id="authHint"></div>
+    <div class="preview-chips" id="chips"></div>
+  </div>
+
+  <div id="resultsSection" style="display:none">
+    <div class="toolbar">
+      <button class="btn-success" id="copyBtn" onclick="copyAllNumbers()">复制所有编号</button>
+      <button class="btn-secondary" onclick="expandAll()">展开全部</button>
+      <button class="btn-secondary" onclick="collapseAll()">折叠全部</button>
+      <span class="status" id="countLabel"></span>
+    </div>
+    <div class="results-card">
+      <div class="table-wrap">
+        <table>
+          <thead>
+            <tr>
+              <th>编号</th>
+              <th>标题</th>
+              <th>状态</th>
+              <th>负责人</th>
+              <th>截止日期</th>
+            </tr>
+          </thead>
+          <tbody id="tbody"></tbody>
+        </table>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+let allTasks = [];
+let collapsed = new Set();
+let authPollingTimer = null;
+let authContext = { baseUrl: '', teamId: '' };
+
+function extractContext(text) {
+  const match = text.match(/(https?:\/\/[^/\s]+)\/project\/#\/team\/([^/\s]+)\/task\/([A-Za-z0-9]{10,})/);
+  if (!match) return { baseUrl: '', teamId: '' };
+  return { baseUrl: match[1], teamId: match[2] };
+}
+
+function extractTaskIds(text) {
+  const uuids = [];
+  const numbers = [];
+
+  for (const match of text.matchAll(/\/task\/([A-Za-z0-9]{10,})/g)) {
+    uuids.push(match[1]);
+  }
+
+  const textWithoutUrls = text.replace(/https?:\/\/[^\s]+/g, '');
+  for (const match of textWithoutUrls.matchAll(/#(\d+)/g)) {
+    numbers.push(match[1]);
+  }
+
+  const seen = new Set();
+  return [...uuids, ...numbers].filter(id => {
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+
+function setStatus(msg, isError = false) {
+  const el = document.getElementById('status');
+  el.textContent = msg;
+  el.className = 'status' + (isError ? ' error' : '');
+}
+
+function setAuthHint(msg) {
+  document.getElementById('authHint').textContent = msg || '';
+}
+
+function updateAuthContext(next) {
+  authContext = {
+    baseUrl: next?.baseUrl || authContext.baseUrl || '',
+    teamId: next?.teamId || authContext.teamId || '',
+  };
+}
+
+function showAuthButton(show, label = '连接 ONES') {
+  const btn = document.getElementById('authBtn');
+  btn.style.display = show ? '' : 'none';
+  btn.textContent = label;
+  btn.disabled = false;
+}
+
+function renderChips(taskIds) {
+  const el = document.getElementById('chips');
+  if (taskIds.length === 0) { el.innerHTML = ''; return; }
+  el.innerHTML = taskIds.map(id => `<span class="chip">${id}</span>`).join('');
+}
+
+async function parse() {
+  const text = document.getElementById('input').value.trim();
+  if (!text) { setStatus('请先粘贴文本', true); return; }
+  const taskIds = extractTaskIds(text);
+  const context = extractContext(text);
+  updateAuthContext(context);
+  if (taskIds.length === 0) { setStatus('未找到任务 ID（支持 /task/UUID 链接或 #数字编号）', true); return; }
+  renderChips(taskIds);
+  setStatus(`已提取 ${taskIds.length} 个任务 ID，正在抓取...`);
+  setAuthHint(context.baseUrl ? `已识别站点：${context.baseUrl}${context.teamId ? `，团队：${context.teamId}` : ''}` : '');
+  document.getElementById('parseBtn').disabled = true;
+  document.getElementById('tbody').innerHTML = '<tr><td colspan="5" class="loading"><span class="spinner"></span>加载中...</td></tr>';
+  document.getElementById('resultsSection').style.display = '';
+
+  try {
+    const resp = await fetch('/api/crawl', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ taskIds, baseUrl: authContext.baseUrl || context.baseUrl || undefined, teamId: authContext.teamId || context.teamId || undefined }),
+    });
+    const data = await resp.json();
+    if (!resp.ok) {
+      if (data.error === 'auth_required' || data.error === 'token_expired') {
+        updateAuthContext(data);
+        showAuthButton(true, data.error === 'token_expired' ? '重新连接 ONES' : '连接 ONES');
+        setAuthHint(`将打开一个浏览器窗口用于登录 ONES，完成后会自动重试。${authContext.baseUrl ? ` 当前站点：${authContext.baseUrl}` : ''}`);
+      }
+      const msg = data.error === 'token_expired'
+        ? '登录状态已过期，请点击“连接 ONES”重新登录'
+        : data.error === 'auth_required'
+          ? '当前还没有可用的 ONES 凭据，请先连接 ONES'
+          : (data.detail ?? data.error ?? '抓取失败');
+      setStatus(msg, true);
+      document.getElementById('tbody').innerHTML = `<tr><td colspan="5" class="empty">${msg}</td></tr>`;
+      return;
+    }
+    showAuthButton(false);
+    updateAuthContext(data);
+    allTasks = data.tasks ?? [];
+    collapsed = new Set();
+    renderTable();
+    setStatus(`共获取 ${allTasks.length} 条任务`);
+    document.getElementById('countLabel').textContent = `共 ${allTasks.length} 条`;
+  } catch (e) {
+    setStatus('网络错误：' + e.message, true);
+  } finally {
+    document.getElementById('parseBtn').disabled = false;
+  }
+}
+
+async function connectOnes() {
+  const text = document.getElementById('input').value;
+  const context = extractContext(text);
+  updateAuthContext(context);
+  const btn = document.getElementById('authBtn');
+
+  if (!authContext.baseUrl) {
+    setStatus('当前没有可用的 ONES 站点地址，请先粘贴任务链接或配置 ONES_BASE_URL', true);
+    return;
+  }
+
+  btn.disabled = true;
+  btn.textContent = '正在打开登录窗口...';
+  setStatus('正在打开 ONES 登录窗口，请在弹出的浏览器里完成登录');
+
+  const resp = await fetch('/api/auth/login', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ baseUrl: authContext.baseUrl, teamId: authContext.teamId || undefined }),
+  });
+  const data = await resp.json();
+  if (!resp.ok) {
+    btn.disabled = false;
+    btn.textContent = '连接 ONES';
+    setStatus(data.detail ?? data.error ?? '无法启动登录流程', true);
+    return;
+  }
+
+  updateAuthContext(data);
+  setAuthHint(`已打开 ${authContext.baseUrl} 的登录窗口，登录完成后将自动重试解析。`);
+  startAuthPolling();
+}
+
+function startAuthPolling() {
+  if (authPollingTimer) window.clearInterval(authPollingTimer);
+  authPollingTimer = window.setInterval(async () => {
+    const resp = await fetch('/api/auth/status');
+    const data = await resp.json();
+    if (data.status === 'pending') {
+      showAuthButton(true, '等待登录完成...');
+      document.getElementById('authBtn').disabled = true;
+      return;
+    }
+
+    window.clearInterval(authPollingTimer);
+    authPollingTimer = null;
+
+    if (data.status === 'authenticated') {
+      updateAuthContext(data);
+      showAuthButton(false);
+      setStatus('ONES 已连接，正在重新解析...');
+      setAuthHint(`当前站点：${authContext.baseUrl}${authContext.teamId ? `，团队：${authContext.teamId}` : ''}`);
+      await parse();
+      return;
+    }
+
+    showAuthButton(true, '连接 ONES');
+    setStatus(data.error === 'LOGIN_TIMEOUT' ? '登录超时，请重试' : '登录未完成，请重试', true);
+  }, 1500);
+}
+
+function buildTree(tasks) {
+  const byUuid = new Map(tasks.map(t => [t.uuid, { ...t, children: [] }]));
+  const roots = [];
+  for (const node of byUuid.values()) {
+    if (node.parent_uuid && byUuid.has(node.parent_uuid)) {
+      byUuid.get(node.parent_uuid).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}
+
+function flattenTree(nodes, depth = 0) {
+  const result = [];
+  for (const node of nodes) {
+    result.push({ ...node, _depth: depth });
+    if (!collapsed.has(node.uuid) && node.children.length > 0) {
+      result.push(...flattenTree(node.children, depth + 1));
+    }
+  }
+  return result;
+}
+
+function renderTable() {
+  const roots = buildTree(allTasks);
+  const flat = flattenTree(roots);
+
+  const rows = flat.map(t => {
+    const hasChildren = t.children.length > 0;
+    const isCollapsed = collapsed.has(t.uuid);
+    const toggleIcon = hasChildren ? `<button class="toggle-btn" onclick="toggleRow('${t.uuid}')">${isCollapsed ? '▶' : '▼'}</button>` : '<span style="display:inline-block;width:18px"></span>';
+    const indent = `<span class="indent" style="width:${t._depth * 20}px"></span>`;
+    const taskUrl = authContext.baseUrl && authContext.teamId
+      ? `${authContext.baseUrl}/project/#/team/${authContext.teamId}/task/${t.uuid}`
+      : '';
+    const numberCell = taskUrl
+      ? `<a class="num-link" href="${escAttr(taskUrl)}" target="_blank" rel="noreferrer">#${esc(t.number ?? '')}</a>`
+      : `#${esc(t.number ?? '')}`;
+    return `<tr data-uuid="${t.uuid}">
+      <td class="num-cell">${numberCell}</td>
+      <td>${indent}${toggleIcon}${esc(t.summary ?? '')}</td>
+      <td>${t.status_name ? `<span class="tag">${esc(t.status_name)}</span>` : ''}</td>
+      <td>${esc(t.assign_name ?? '')}</td>
+      <td>${esc(t.deadline ?? '')}</td>
+    </tr>`;
+  }).join('');
+
+  document.getElementById('tbody').innerHTML = rows || '<tr><td colspan="5" class="empty">无结果</td></tr>';
+}
+
+function esc(str) {
+  return String(str).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+}
+
+function escAttr(str) {
+  return String(str).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+
+function toggleRow(uuid) {
+  if (collapsed.has(uuid)) collapsed.delete(uuid);
+  else collapsed.add(uuid);
+  renderTable();
+}
+
+function expandAll() {
+  collapsed.clear();
+  renderTable();
+}
+
+function collapseAll() {
+  for (const t of allTasks) {
+    const node = allTasks.find(x => x.parent_uuid === t.uuid);
+    if (node) collapsed.add(t.uuid);
+  }
+  renderTable();
+}
+
+function copyAllNumbers() {
+  const numbers = allTasks.map(t => `#${t.number}`).join('|');
+  navigator.clipboard.writeText(numbers).then(() => {
+    const btn = document.getElementById('copyBtn');
+      btn.textContent = '已复制 ✓';
+      btn.classList.add('copied');
+      setTimeout(() => {
+      btn.textContent = '复制所有编号';
+      btn.classList.remove('copied');
+    }, 2000);
+  });
+}
+
+function clearAll() {
+  document.getElementById('input').value = '';
+  document.getElementById('chips').innerHTML = '';
+  document.getElementById('status').textContent = '';
+  setAuthHint('');
+  showAuthButton(false);
+  authContext = { baseUrl: '', teamId: '' };
+  document.getElementById('resultsSection').style.display = 'none';
+  allTasks = [];
+}
+
+// Auto-extract chips on input
+document.getElementById('input').addEventListener('input', () => {
+  const text = document.getElementById('input').value;
+  const taskIds = extractTaskIds(text);
+  const context = extractContext(text);
+  updateAuthContext(context);
+  renderChips(taskIds);
+  setStatus(taskIds.length ? `检测到 ${taskIds.length} 个任务 ID` : '');
+  setAuthHint(authContext.baseUrl ? `已识别站点：${authContext.baseUrl}${authContext.teamId ? `，团队：${authContext.teamId}` : ''}` : '');
+});
+</script>
+</body>
+</html>

package/public/launcher.vbs

@@ -0,0 +1,34 @@
+Set WshShell = CreateObject("WScript.Shell")
+Set fso = CreateObject("Scripting.FileSystemObject")
+
+' 获取脚本所在目录
+scriptDir = fso.GetParentFolderName(WScript.ScriptFullName)
+
+' 检查 Node.js 是否安装
+On Error Resume Next
+WshShell.Run "node --version", 0, True
+If Err.Number <> 0 Then
+    MsgBox "未检测到 Node.js，请先安装 Node.js 18 或更高版本。" & vbCrLf & vbCrLf & "下载地址：https://nodejs.org/", vbCritical, "ONES 采集工具"
+    WScript.Quit
+End If
+On Error Goto 0
+
+' 检查是否已安装依赖
+If Not fso.FolderExists(scriptDir & "\node_modules") Then
+    result = MsgBox("首次运行需要安装依赖（约 30MB），是否继续？", vbYesNo + vbQuestion, "ONES 采集工具")
+    If result = vbNo Then
+        WScript.Quit
+    End If
+
+    ' 显示安装窗口
+    WshShell.Run "cmd /c cd /d """ & scriptDir & """ && npm install && pause", 1, True
+End If
+
+' 启动服务器（后台运行）
+WshShell.Run "cmd /c cd /d """ & scriptDir & """ && node src/server.mjs", 0, False
+
+' 等待服务器启动
+WScript.Sleep 2000
+
+' 打开浏览器
+WshShell.Run "http://localhost:3000", 1

package/src/auth.mjs

@@ -0,0 +1,181 @@
+// auth.mjs — browser login for ones-fetch web mode
+// Credentials stored at ~/.ones-fetch/credentials.json (mode 600 on non-Windows)
+
+import os from "node:os";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { chromium } from "playwright-core";
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+export function getCredentialsPath() {
+  return path.join(os.homedir(), ".ones-fetch", "credentials.json");
+}
+
+// ---------------------------------------------------------------------------
+// Read / write credentials
+// ---------------------------------------------------------------------------
+
+export async function readCredentials() {
+  const file = getCredentialsPath();
+  try {
+    const raw = await fsp.readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export async function writeCredentials(obj) {
+  const file = getCredentialsPath();
+  await fsp.mkdir(path.dirname(file), { recursive: true });
+  await fsp.writeFile(file, JSON.stringify(obj, null, 2), "utf8");
+  if (process.platform !== "win32") {
+    await fsp.chmod(file, 0o600);
+  }
+}
+
+function getLoginUrl(baseUrl) {
+  return `${baseUrl}/project/#/3rd_party_connect/ldap/login?path=/auth/third_login&ones_from=${encodeURIComponent(baseUrl + "/project/#/workspace")}`;
+}
+
+async function extractSessionFromPage(page) {
+  return page.evaluate(() => {
+    const fromStorage = (key) => window.localStorage.getItem(key) || window.sessionStorage.getItem(key);
+
+    let authToken = fromStorage("ones-auth-token") || fromStorage("authToken") || fromStorage("token");
+    let userId = fromStorage("ones-user-id") || fromStorage("userId") || fromStorage("uid");
+
+    if (!authToken || !userId) {
+      const cookies = document.cookie.split(";").map((item) => item.trim()).filter(Boolean);
+      for (const cookie of cookies) {
+        const eqIndex = cookie.indexOf("=");
+        if (eqIndex === -1) continue;
+        const key = cookie.slice(0, eqIndex);
+        const value = decodeURIComponent(cookie.slice(eqIndex + 1));
+        if (!authToken && key.includes("ones-auth-token")) authToken = value;
+        if (!userId && key.includes("ones-user-id")) userId = value;
+      }
+    }
+
+    // Extract team-id from URL: /team/{uuid}/...
+    let teamId = null;
+    const teamMatch = window.location.href.match(/\/team\/([a-zA-Z0-9]{16,})/);
+    if (teamMatch) teamId = teamMatch[1];
+
+    return authToken && userId ? { authToken, userId, teamId } : null;
+  });
+}
+
+export async function runBrowserLoginCapture({ baseUrl, timeoutMs = 300000, verbose = false }) {
+  const browser = await chromium.launch({ headless: false });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  const loginUrl = getLoginUrl(baseUrl);
+
+  let resolved = false;
+
+  return new Promise(async (resolve, reject) => {
+    const finish = async (result, error) => {
+      if (resolved) return;
+      try {
+        if (error) throw error;
+        const credentialsToSave = { ...result, baseUrl };
+        await writeCredentials(credentialsToSave);
+        resolved = true;
+        resolve(credentialsToSave);
+      } catch (innerError) {
+        resolved = true;
+        reject(innerError);
+      } finally {
+        clearTimeout(timeout);
+        clearInterval(poller);
+        page.removeListener("response", onResponse);
+        page.removeListener("framenavigated", onNavigation);
+        try {
+          await browser.close();
+        } catch {
+          // Ignore browser close failures during auth teardown.
+        }
+      }
+    };
+
+    const tryPageSession = async () => {
+      let session = null;
+      try {
+        session = await extractSessionFromPage(page);
+      } catch {
+        // Cross-page transitions can temporarily break page evaluation.
+      }
+      if (session?.authToken && session?.userId) {
+        await finish(session, null);
+      }
+    };
+
+    const onResponse = async (res) => {
+      if (!res.url().includes("/sso/login") && !res.url().includes("/auth/login")) return;
+      try {
+        const headers = res.headers();
+        const authToken = headers["ones-auth-token"] ?? null;
+        const userId = headers["ones-user-id"] ?? null;
+        if (authToken && userId) {
+          // Try to extract teamId from current page URL
+          let teamId = null;
+          try {
+            const currentUrl = page.url();
+            const teamMatch = currentUrl.match(/\/team\/([a-zA-Z0-9]{16,})/);
+            if (teamMatch) teamId = teamMatch[1];
+          } catch { /* ignore */ }
+          await finish({ authToken, userId, teamId }, null);
+          return;
+        }
+      } catch {
+        // Ignore response parsing issues and fall back to page polling.
+      }
+      await tryPageSession();
+    };
+
+    const onNavigation = () => {
+      void tryPageSession();
+    };
+
+    const timeout = setTimeout(() => {
+      void finish(null, new Error("LOGIN_TIMEOUT"));
+    }, timeoutMs);
+
+    const poller = setInterval(() => {
+      void tryPageSession();
+    }, 1000);
+
+    page.on("response", onResponse);
+    page.on("framenavigated", onNavigation);
+
+    try {
+      if (verbose) process.stderr.write(`Opening browser login at ${loginUrl}\n`);
+      await page.goto(loginUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
+      await tryPageSession();
+    } catch (error) {
+      await finish(null, error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+// loadAuth — read credentials for use in server
+// ---------------------------------------------------------------------------
+
+export async function loadAuth(cliBaseUrl) {
+  const creds = await readCredentials();
+  const authToken = creds.authToken;
+  const userId = creds.userId;
+  const baseUrl = cliBaseUrl ?? creds.baseUrl;
+  const teamId = creds.teamId;
+
+  if (!authToken || !userId || !baseUrl) {
+    throw new Error("Not authenticated");
+  }
+
+  return { authToken, userId, baseUrl, teamId };
+}

package/src/server.mjs

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+import http from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+import { exec } from 'node:child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PUBLIC_DIR = join(__dirname, '..', 'public');
+const PORT = process.env.PORT ?? 3000;
+
+function openBrowser(url) {
+  const start = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  exec(`${start} ${url}`);
+}
+
+const authFlow = {
+  status: 'idle',
+  error: null,
+  startedAt: 0,
+  baseUrl: '',
+  teamId: '',
+};
+
+function normalizeBaseUrl(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
+async function readJsonBody(req, res) {
+  let body = '';
+  for await (const chunk of req) body += chunk;
+  try {
+    return body ? JSON.parse(body) : {};
+  } catch {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'invalid_json' }));
+    return null;
+  }
+}
+
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(payload));
+}
+
+async function resolveRuntimeContext(overrides = {}) {
+  const { loadAuth } = await import('./auth.mjs');
+
+  const overrideBaseUrl = normalizeBaseUrl(overrides.baseUrl);
+  const envBaseUrl = normalizeBaseUrl(process.env.ONES_BASE_URL);
+  const requestedBaseUrl = overrideBaseUrl || envBaseUrl;
+
+  let auth = null;
+  try {
+    auth = await loadAuth();
+  } catch {
+    auth = null;
+  }
+
+  const authBaseUrl = normalizeBaseUrl(auth?.baseUrl);
+  if (requestedBaseUrl && authBaseUrl && requestedBaseUrl !== authBaseUrl) {
+    auth = null;
+  }
+
+  const baseUrl = requestedBaseUrl || authBaseUrl || '';
+  const teamId = overrides.teamId ?? auth?.teamId ?? process.env.ONES_TEAM_ID ?? '';
+
+  return {
+    authToken: auth?.authToken ?? null,
+    userId: auth?.userId ?? null,
+    baseUrl,
+    teamId,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Task crawling logic (inlined from ones-subtasks-cli.mjs)
+// ---------------------------------------------------------------------------
+
+async function resolveTaskNumber(baseUrl, teamId, taskNumber, authToken, userId) {
+  const url = `${baseUrl}/project/api/project/team/${teamId}/items/graphql?t=resolve-by-number`;
+  const body = JSON.stringify({
+    query: `{ tasks(filter: { number_equal: ${taskNumber} }) { uuid number } }`,
+    variables: {},
+  });
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "accept": "application/json, text/plain, */*",
+      "content-type": "application/json;charset=UTF-8",
+      "ones-auth-token": authToken,
+      "ones-user-id": userId,
+      "referer": `${baseUrl}/project/`,
+    },
+    body,
+  });
+  if (res.status === 401) throw new Error("TOKEN_EXPIRED");
+  if (!res.ok) throw new Error(`GraphQL resolve → ${res.status}`);
+  const json = await res.json();
+  if (json?.errors?.length > 0) {
+    const msg = json.errors[0].message ?? String(json.errors[0]);
+    throw new Error(`GraphQL query failed for task number "${taskNumber}": ${msg}`);
+  }
+  const tasks = json?.data?.tasks ?? [];
+  if (tasks.length === 0) throw new Error(`No task found with number ${taskNumber}`);
+  return tasks[0].uuid;
+}
+
+async function fetchTaskInfo(baseUrl, teamId, taskUuid, authToken, userId) {
+  const url = `${baseUrl}/project/api/project/team/${teamId}/task/${taskUuid}/info`;
+  const res = await fetch(url, {
+    headers: {
+      "accept": "application/json, text/plain, */*",
+      "ones-auth-token": authToken,
+      "ones-user-id": userId,
+      "referer": `${baseUrl}/project/`,
+    },
+  });
+  if (res.status === 401) throw new Error("TOKEN_EXPIRED");
+  if (!res.ok) throw new Error(`GET ${url} → ${res.status}`);
+  return res.json();
+}
+
+function chunk(list, size) {
+  const chunks = [];
+  for (let i = 0; i < list.length; i += size) chunks.push(list.slice(i, i + size));
+  return chunks;
+}
+
+function getImportantFieldValue(task, fieldName) {
+  const match = (task.importantField ?? []).find((field) => field.name === fieldName);
+  return match?.value ?? null;
+}
+
+async function enrichTasks(baseUrl, teamId, tasks, authToken, userId) {
+  const details = new Map();
+
+  for (const uuidChunk of chunk([...new Set(tasks.map((task) => task.uuid))], 200)) {
+    const res = await fetch(`${baseUrl}/project/api/project/team/${teamId}/items/graphql?t=task-enrich`, {
+      method: "POST",
+      headers: {
+        accept: "application/json, text/plain, */*",
+        "content-type": "application/json;charset=UTF-8",
+        "ones-auth-token": authToken,
+        "ones-user-id": userId,
+        referer: `${baseUrl}/project/`,
+      },
+      body: JSON.stringify({
+        query: `query TaskEnrich($uuids: [String!]) {
+  tasks(filter: { uuid_in: $uuids }) {
+    uuid
+    number
+    name
+    deadline(unit: ONESDATE)
+    status {
+      uuid
+      name
+      category
+    }
+    parent {
+      uuid
+    }
+    project {
+      uuid
+    }
+    importantField {
+      name
+      value
+      fieldUUID
+    }
+  }
+}`,
+        variables: {
+          uuids: uuidChunk,
+        },
+      }),
+    });
+
+    if (res.status === 401) throw new Error("TOKEN_EXPIRED");
+    if (!res.ok) throw new Error(`GraphQL enrich → ${res.status}`);
+
+    const json = await res.json();
+    const enrichedTasks = json?.data?.tasks ?? [];
+    for (const enriched of enrichedTasks) {
+      details.set(enriched.uuid, {
+        summary: enriched.name,
+        status_uuid: enriched.status?.uuid ?? null,
+        status_name: enriched.status?.name ?? null,
+        assign_name: getImportantFieldValue(enriched, "负责人"),
+        deadline: enriched.deadline ?? null,
+        parent_uuid: enriched.parent?.uuid || null,
+        project_uuid: enriched.project?.uuid ?? null,
+      });
+    }
+  }
+
+  return tasks.map((task) => {
+    const enriched = details.get(task.uuid);
+    if (!enriched) return task;
+    return {
+      ...task,
+      summary: enriched.summary ?? task.summary,
+      status_uuid: enriched.status_uuid ?? task.status_uuid,
+      status_name: enriched.status_name ?? task.status_name,
+      assign_name: enriched.assign_name ?? task.assign_name,
+      deadline: enriched.deadline ?? task.deadline,
+      parent_uuid: enriched.parent_uuid ?? task.parent_uuid,
+      project_uuid: enriched.project_uuid ?? task.project_uuid,
+    };
+  });
+}
+
+function extractTask(data) {
+  const status = typeof data.status === "object" && data.status ? data.status : null;
+  return {
+    uuid: data.uuid,
+    number: data.number,
+    summary: data.summary ?? data.name,
+    status_uuid: data.status_uuid ?? status?.uuid ?? "",
+    status_name: status?.name ?? null,
+    assign: typeof data.assign === "string" ? data.assign : data.assign?.uuid ?? "",
+    assign_name: typeof data.assign === "object" && data.assign ? data.assign.name : null,
+    priority: data.priority,
+    deadline: typeof data.deadline === "number" ? new Date(data.deadline * 1000).toISOString().slice(0, 10) : data.deadline ?? null,
+    parent_uuid: data.parent_uuid || data.parent?.uuid || null,
+    project_uuid: data.project_uuid || data.project?.uuid || null,
+  };
+}
+
+async function crawlTask(baseUrl, teamId, taskUuid, authToken, userId, depth, maxDepth, seen) {
+  if (depth > maxDepth || seen.has(taskUuid)) return [];
+  seen.add(taskUuid);
+
+  const data = await fetchTaskInfo(baseUrl, teamId, taskUuid, authToken, userId);
+  const task = extractTask(data);
+  const results = [task];
+
+  const subtasks = data.subtasks ?? data.subTasks ?? [];
+  for (const sub of subtasks) {
+    const children = await crawlTask(baseUrl, teamId, sub.uuid, authToken, userId, depth + 1, maxDepth, seen);
+    results.push(...children);
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// HTTP handlers
+// ---------------------------------------------------------------------------
+
+async function handleAuthStatus(_req, res) {
+  if (authFlow.status === 'pending') {
+    return sendJson(res, 200, {
+      status: 'pending',
+      error: authFlow.error,
+      baseUrl: authFlow.baseUrl,
+      teamId: authFlow.teamId,
+    });
+  }
+
+  const context = await resolveRuntimeContext();
+  if (context.authToken && context.userId && context.baseUrl) {
+    return sendJson(res, 200, {
+      status: 'authenticated',
+      baseUrl: context.baseUrl,
+      teamId: context.teamId,
+    });
+  }
+
+  return sendJson(res, 200, {
+    status: 'unauthenticated',
+    error: authFlow.error,
+    baseUrl: context.baseUrl,
+    teamId: context.teamId,
+  });
+}
+
+async function handleAuthLogin(req, res) {
+  const body = await readJsonBody(req, res);
+  if (!body) return;
+
+  const context = await resolveRuntimeContext({ baseUrl: body.baseUrl, teamId: body.teamId });
+  if (!context.baseUrl) {
+    return sendJson(res, 400, { error: 'missing_base_url', detail: 'Need ONES base URL to open the login window.' });
+  }
+
+  if (authFlow.status === 'pending') {
+    return sendJson(res, 200, { status: 'pending', baseUrl: authFlow.baseUrl });
+  }
+
+  authFlow.status = 'pending';
+  authFlow.error = null;
+  authFlow.startedAt = Date.now();
+  authFlow.baseUrl = context.baseUrl;
+  authFlow.teamId = context.teamId;
+
+  void (async () => {
+    try {
+      const { runBrowserLoginCapture } = await import('./auth.mjs');
+      await runBrowserLoginCapture({ baseUrl: context.baseUrl });
+      authFlow.status = 'idle';
+      authFlow.error = null;
+      authFlow.baseUrl = '';
+      authFlow.teamId = '';
+    } catch (error) {
+      authFlow.status = 'idle';
+      authFlow.error = error?.message ?? String(error);
+      authFlow.baseUrl = context.baseUrl;
+      authFlow.teamId = context.teamId;
+    }
+  })();
+
+  return sendJson(res, 200, { status: 'pending', baseUrl: context.baseUrl });
+}
+
+async function handleCrawl(req, res) {
+  const body = await readJsonBody(req, res);
+  if (!body) return;
+
+  const { taskIds, baseUrl: requestBaseUrl, teamId: requestTeamId } = body;
+  if (!Array.isArray(taskIds) || taskIds.length === 0) {
+    return sendJson(res, 400, { error: 'taskIds must be a non-empty array' });
+  }
+
+  try {
+    const { authToken, userId, baseUrl, teamId } = await resolveRuntimeContext({
+      baseUrl: requestBaseUrl,
+      teamId: requestTeamId,
+    });
+
+    if (!authToken || !userId || !baseUrl) {
+      return sendJson(res, 401, {
+        error: 'auth_required',
+        detail: 'Connect ONES first to let the local service capture credentials.',
+        baseUrl,
+        teamId,
+      });
+    }
+
+    if (!teamId) {
+      return sendJson(res, 500, { error: 'missing_config', detail: 'team-id not configured. Please login to auto-detect it.' });
+    }
+
+    const seen = new Set();
+    const roots = [];
+    const allTasks = [];
+
+    for (const rawId of taskIds) {
+      let rootUuid;
+      if (/^\d+$/.test(rawId)) {
+        rootUuid = await resolveTaskNumber(baseUrl, teamId, rawId, authToken, userId);
+      } else {
+        rootUuid = rawId;
+      }
+      roots.push(rootUuid);
+      const tasks = await crawlTask(baseUrl, teamId, rootUuid, authToken, userId, 0, 10, seen);
+      for (const t of tasks) allTasks.push({ ...t, root_uuid: rootUuid });
+    }
+
+    const enrichedTasks = await enrichTasks(baseUrl, teamId, allTasks, authToken, userId).catch(() => allTasks);
+
+    return sendJson(res, 200, { roots, tasks: enrichedTasks, baseUrl, teamId });
+  } catch (err) {
+    const tokenExpired = err.message?.includes('401') || err.message?.includes('Token expired') || err.message?.includes('TOKEN_EXPIRED');
+    return sendJson(res, tokenExpired ? 401 : 500, { error: tokenExpired ? 'token_expired' : 'crawl_failed', detail: err.message });
+  }
+}
+
+const server = http.createServer(async (req, res) => {
+  if (req.method === 'GET' && req.url === '/') {
+    try {
+      const html = await readFile(join(PUBLIC_DIR, 'index.html'), 'utf8');
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(html);
+    } catch {
+      res.writeHead(404); res.end('index.html not found');
+    }
+    return;
+  }
+  if (req.method === 'GET' && req.url === '/api/auth/status') {
+    return handleAuthStatus(req, res);
+  }
+  if (req.method === 'POST' && req.url === '/api/auth/login') {
+    return handleAuthLogin(req, res);
+  }
+  if (req.method === 'POST' && req.url === '/api/crawl') {
+    return handleCrawl(req, res);
+  }
+  res.writeHead(404); res.end('Not found');
+});
+
+server.listen(PORT, () => {
+  const url = `http://localhost:${PORT}`;
+  process.stdout.write(`ONES Fetch Web UI → ${url}\n`);
+  openBrowser(url);
+});