ai_co_discuss 0.2.72 → 0.2.73

package/backend/schema.sql

@@ -740,3 +740,28 @@ END;
 -- The review phase behaved exactly like discussing and was retired; move rows left in it.
 UPDATE topic_settings SET phase='discussing' WHERE phase='reviewing';
 UPDATE discussion_runtime SET resume_phase='discussing' WHERE resume_phase='reviewing';
+
+-- A computer running the local service, paired by the site administrator. Only project names and ids and the
+-- configured client of each platform are published; directories and credentials stay on that computer.
+CREATE TABLE IF NOT EXISTS local_machines (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    token_hash TEXT NOT NULL,
+    projects TEXT NOT NULL DEFAULT '[]',
+    clients TEXT NOT NULL DEFAULT '{}',
+    seen_at INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL
+);
+-- A room launch submitted from a device without the local service; the paired computer claims and runs it.
+-- The request (with the room's new credentials) is cleared once the launch finishes or fails.
+CREATE TABLE IF NOT EXISTS remote_launches (
+    id TEXT PRIMARY KEY,
+    machine_id TEXT NOT NULL,
+    request TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','claimed','done','failed')),
+    result TEXT NOT NULL DEFAULT '{}',
+    error TEXT NOT NULL DEFAULT '',
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS remote_launches_machine ON remote_launches(machine_id, status);

package/backend/server.py

@@ -21,6 +21,8 @@ from pathlib import Path
 from urllib.parse import parse_qs, quote, urlsplit
 
 from .admin import AdminError, admin_status, login_admin, logout_admin, register_admin, session_valid, update_profile
+from .remote_launch import (list_machines, machine_launch_action, machine_sync, pair_machine, remote_launch_status,
+                            submit_remote_launch)
 from .free_room import (add_member, after_free_message, authorize_free_write, check_answer, check_proxy, execution_action, free_view,
                         inbox, interrupt_member, member_action, member_values, migrate_free_tables, proxy_member, reserve_execution,
                         discussion_members, room_mode, save_room_access, sync_discussion_members, view_execution)
@@ -1835,7 +1837,7 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         site = self.local_request_site(method)
         route = parts[2:]
         if method == "OPTIONS" and route in (["settings"], ["launch"], ["room-models"], ["room-member"], ["models"], ["api-key"], ["api-check"],
-                                             ["scheduler-check"], ["pick-directory"]):
+                                             ["scheduler-check"], ["pick-directory"], ["projects"], ["machine-link"]):
             return self.respond({"ok": True})
         if route == ["settings"] and method in ("GET", "POST"):
             command = "settings"
@@ -1857,6 +1859,10 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             command = "room-member"
         elif route == ["pick-directory"] and method == "POST":
             command = "pick-directory"
+        elif route == ["projects"] and method == "POST":
+            command = "projects"
+        elif route == ["machine-link"] and method == "POST":
+            command = "machine-link"
         else:
             raise LookupError("本机入口不存在")
         payload = None
@@ -1867,6 +1873,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             if command in ("start", "room-config", "room-models", "room-member"):
                 payload.pop("access_file", None)
                 payload.update(site=site, entry="web")
+            if command == "machine-link":
+                payload = {"site": site}
         if command == "room-config" and "participants" in payload:
             return self.save_local_room_configuration(command, payload)
         return self.run_local_command(command, payload)
@@ -1943,6 +1951,30 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         connection.commit()
         return self.respond(result, 201 if parts[2] == "register" else 200)
 
+    def handle_remote_launch_api(self, connection, parts, method):
+        """Pair computers and relay room launches; a computer authenticates with its own token, everything else as the administrator."""
+        now = int(time.time())
+        if len(parts) in (4, 5) and parts[1] == "machines" and method == "POST" and (len(parts) == 4 and parts[3] == "sync" or parts[3:4] == ["launches"]):
+            token = self.headers.get("X-Machine-Token", "")
+            result = (machine_sync(connection, parts[2], token, self.read_payload(), now) if len(parts) == 4
+                      else machine_launch_action(connection, parts[2], parts[4], token, self.read_payload(), now))
+            connection.commit()
+            return self.respond(result)
+        if not self.admin_session(connection):
+            raise AdminError("需要登录管理员账号", 401)
+        if parts == ["api", "machines"] and method == "GET":
+            return self.respond(list_machines(connection, now))
+        if parts == ["api", "machines"] and method == "POST":
+            result = pair_machine(connection, self.read_payload(), now)
+        elif parts == ["api", "remote-launches"] and method == "POST":
+            result = submit_remote_launch(connection, self.read_payload(), now)
+        elif len(parts) == 3 and parts[1] == "remote-launches" and method == "GET":
+            return self.respond(remote_launch_status(connection, parts[2]))
+        else:
+            raise LookupError("地址不存在")
+        connection.commit()
+        return self.respond(result)
+
     def handle_api(self, connection, parts, params, method):
         """Handle room, state, and message operations used by the web UI."""
         if parts == ["api", "health"] and method == "GET":
@@ -1953,6 +1985,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             if not self.admin_session(connection):
                 raise AdminError("需要登录管理员账号", 401)
             return self.respond(list_feedback_cases(connection, int(params.get("after", 0))))
+        if parts[1:2] in (["machines"], ["remote-launches"]):
+            return self.handle_remote_launch_api(connection, parts, method)
         if parts == ["api", "rooms"]:
             if method == "GET":
                 return self.respond({**list_rooms(connection, params), "participants": PARTICIPANTS})

package/docs/runner.md

@@ -92,7 +92,7 @@ codiscuss local stop
 - **本机软件默认配置**：按参与者保存 CLI / App 类型、原生可执行文件、App 来源聊天 / Sidecar、可选工具许可及软件项目 / 目录。保存在服务目录的 `launch-settings.json`，两个入口复用；不保存全局当前房间、身份或会话 ID。
 - **单场配置**：议题、主持人、专家和上限由房间保存；本次软件覆盖、实际会话绑定、项目 / cwd 与凭据只保存在服务目录 `launches/` 下。默认新建参与会话，显式 `session_id` 才复用；对话入口的主持使用当前实际会话。
 
-可执行文件、cwd 和 Sidecar 目录须填写完整绝对路径，避免从不同入口启动时解析到不同位置。网页直接显示本次目录、会话新建 / 复用及项目含义；Codex / Claude CLI 的项目名是任务说明，不代表关联 App 项目，未指定目录时使用本次讨论的独立草稿目录。网页成功启动或恢复原启动后，清除与已提交快照相同的单场会话 ID、公共 cwd / 项目草稿，保留等待期间的新编辑；创建并启动失败时保留表单和原草稿，在表单内显示具体参与者的错误，原配置重试沿用提交编号。
+可执行文件、cwd 和 Sidecar 目录须填写完整绝对路径，避免从不同入口启动时解析到不同位置。公共 cwd 可从“项目”列表选择：项目名称与绝对路径保存在服务目录的 `launch-projects.json`（`codiscuss launch projects`，保存时整体替换并核对每个路径是这台电脑上已存在的文件夹），只在本机，不上传网站。本机网页另有文件夹按钮，在本机弹出系统目录选择窗口；已连接的线上网页不显示该按钮，因为窗口只会出现在运行服务的电脑上。网页直接显示本次目录、会话新建 / 复用及项目含义；Codex / Claude CLI 的项目名是任务说明，不代表关联 App 项目，未指定目录时使用本次讨论的独立草稿目录。网页成功启动或恢复原启动后，清除与已提交快照相同的单场会话 ID、公共 cwd / 项目草稿，保留等待期间的新编辑；创建并启动失败时保留表单和原草稿，在表单内显示具体参与者的错误，原配置重试沿用提交编号。
 
 单场省略参与者字段表示继承本机默认值；明确将该 AI 的 `cwd`、`project_name` 或 `project_id` 设为空字符串，则取消该字段的默认覆盖，采用本次公共目录 / 项目或软件默认位置。网页清空字段也遵循此规则；不点击保存默认配置就不会改动后续讨论的默认值。
 
@@ -140,7 +140,7 @@ codiscuss local connect https://你的站点
 
 `connect` 只接受 HTTPS 根地址（本机验证允许 `http://127.0.0.1:端口` 或 `http://localhost:端口`），不接受用户名、密码、路径、查询或片段。它启动或复用本机网站及讨论服务，为该站点生成独立的随机连接凭据，打开线上网页。页面从链接片段读取连接后立即清除地址栏片段，保存到该站点的浏览器本地存储；片段不会发送到线上 HTTP 服务。`--no-open` 只输出连接链接供手动打开，链接具有本机配置与启动权限，不应分享。
 
-连接成功后，线上页面可以读取 / 保存本机软件默认配置、新建并启动讨论、启动本机尚未登记的现有未启动房间；程序复用原有持久启动日志和会话绑定。首次连接可能需要允许浏览器访问本机网络；[Chrome 的 Local Network Access 说明](https://developer.chrome.com/blog/local-network-access)规定了这类访问的权限要求。须在运行 AI 的同一台电脑和保存连接的浏览器中使用；手机、另一台电脑、未获本机网络权限的浏览器不因此获得远程控制能力。已有的线上房间事件消费方式不变。
+连接成功后，线上页面可以读取 / 保存本机软件默认配置、新建并启动讨论、启动本机尚未登记的现有未启动房间；程序复用原有持久启动日志和会话绑定。首次连接可能需要允许浏览器访问本机网络；[Chrome 的 Local Network Access 说明](https://developer.chrome.com/blog/local-network-access)规定了这类访问的权限要求。须在运行 AI 的同一台电脑和保存连接的浏览器中使用；手机、另一台电脑、未获本机网络权限的浏览器不直接访问本机服务，只能经下文的[已配对电脑](#其他设备经已配对电脑建房)建房。已有的线上房间事件消费方式不变。
 
 软件路径、连接凭据与启动配置由浏览器直接发到 `http://127.0.0.1:<本机端口>/api/local/`，不经过线上服务器。服务目录的 `site-connections.json` 仅保存站点来源及凭据 SHA-256；每次请求重新核对来源、凭据、回环 Host 和自定义头。CORS 仅返回已登记的精确 Origin，实际请求仍必须提供凭据；预检不启动进程或写配置。启动目标固定为已授权 Origin，忽略请求中伪造的 `site`、`entry` 和 `access_file`。原有控制凭据、去重与暂停后不自动恢复规则继续生效。
 
@@ -150,7 +150,19 @@ codiscuss local connect https://你的站点
 codiscuss local disconnect https://你的站点
 ```
 
-撤销阻止该站点继续读取配置或发起新启动，不终止已运行的讨论，须另行暂停。连接失败或响应丢失时保留原启动待办，恢复后重试原请求；不换编号重建。线上连接暂不开放 `/api/local/room-config`，既有房间的路径修正仍限本机网站的数据库锁保护流程。未连接浏览器仍可使用[下载配置与登记](deployment.md#可选的全自动接入)方式。
+撤销阻止该站点继续读取配置或发起新启动，同时解除该站点的电脑配对，不终止已运行的讨论，须另行暂停。连接失败或响应丢失时保留原启动待办，恢复后重试原请求；不换编号重建。线上连接暂不开放 `/api/local/room-config`，既有房间的路径修正仍限本机网站的数据库锁保护流程。未连接浏览器仍可使用[下载配置与登记](deployment.md#可选的全自动接入)方式。
+
+### 其他设备经已配对电脑建房
+
+手机、平板等没有本机服务的设备，登录同一网站的管理员账号后，可以新建由电脑唤醒成员的房间。流程：
+
+1. **配对**：管理员在已 `connect` 的电脑浏览器中登录后，页面自动向本机服务取得这台电脑的编号与随机凭据（服务目录 `machine-links.json`，按站点各一份），再以管理员身份登记到网站（`POST /api/machines`）。网站只保存凭据 SHA-256。
+2. **同步**：讨论服务每 3 秒用电脑凭据调用 `POST /api/machines/<编号>/sync`，上报常用项目的编号与名称、各平台已配置的客户端类型，并取回待执行的启动。路径、软件可执行文件与 API 密钥不上传。
+3. **提交**：其他设备读取 `GET /api/machines`（先了解），在建房表单里选择项目与成员，把与已连接浏览器相同的启动请求（含新房间凭据，项目以 `local_project` 编号表示）提交到 `POST /api/remote-launches`（再输出）。网站拒绝携带 `cwd` / `access_file` 的请求，项目编号不在电脑最近上报的列表中时返回 409（程序兜底）。
+4. **执行**：电脑领取（`claim`）后把项目编号换成本机路径，补齐本机保存的 API 密钥引用，按网页启动同一流程（同一 `submission_id` 的持久日志，可安全重试）创建并登记房间，再回报 `finish` 或 `fail`（附失败阶段）。请求结束后网站清空其中的凭据；失败的请求以同一编号重新提交即可重试。
+5. **等待**：提交方最多等待 45 秒；电脑离线或尚未领取时保留在启动待办中，电脑上线后继续。
+
+管理员才能列出电脑、配对和提交，只有持有电脑凭据的服务能领取。常用项目在电脑浏览器的“项目目录”控件里管理（`codiscuss launch projects`），保存时核对每个路径是这台电脑上已存在的文件夹；项目编号在改名、改路径后保持不变。
 
 ### 从 AI 对话发起
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai_co_discuss",
-  "version": "0.2.72",
+  "version": "0.2.73",
   "bin": {
     "codiscuss": "runner/codiscuss.mjs"
   },
@@ -8,7 +8,7 @@
     "dev": "npm run build && wrangler pages dev --ip 127.0.0.1 --port 8787",
     "db:local": "wrangler d1 execute DB --local --file backend/schema.sql",
     "db:remote": "wrangler d1 execute DB --remote --file backend/schema.sql",
-    "check": "node --check backend/worker.mjs && node --check web/app.js && node --check runner/discussion_runner.mjs && node --check runner/discussion_adapters.mjs && node --check runner/discussion_sidecar.mjs && node --check runner/codex_app_client.mjs && node --check runner/discussion_service.mjs && node --check runner/codiscuss.mjs && node --check runner/discussion_launch.mjs && node --check runner/discussion_models.mjs && node --check runner/discussion_setup.mjs && node --check runner/discussion_skills.mjs && node --check runner/discussion_tui.mjs && node --check runner/discussion_local.mjs && node --check runner/free_runner.mjs && node --check runner/discussion_api.mjs && node --check runner/api_participant.mjs && node --check runner/scheduler.mjs",
+    "check": "node --check backend/worker.mjs && node --check web/app.js && node --check runner/discussion_runner.mjs && node --check runner/discussion_adapters.mjs && node --check runner/discussion_sidecar.mjs && node --check runner/codex_app_client.mjs && node --check runner/discussion_service.mjs && node --check runner/codiscuss.mjs && node --check runner/discussion_launch.mjs && node --check runner/discussion_models.mjs && node --check runner/discussion_setup.mjs && node --check runner/discussion_skills.mjs && node --check runner/discussion_tui.mjs && node --check runner/discussion_local.mjs && node --check runner/free_runner.mjs && node --check runner/discussion_api.mjs && node --check runner/api_participant.mjs && node --check runner/scheduler.mjs && node --check runner/remote_launch.mjs",
     "runner": "node runner/discussion_runner.mjs",
     "service": "node runner/discussion_service.mjs",
     "build:ui": "vite build --config frontend/vite.config.mjs --mode markdown && vite build --config frontend/vite.config.mjs --mode backup && vite build --config frontend/vite.config.mjs",

package/runner/discussion_launch.mjs

@@ -50,6 +50,8 @@ const HELP = `用法：codiscuss launch settings [--file FILE]
       codiscuss launch scheduler-check --file FILE
       codiscuss launch room-member --file FILE
       codiscuss launch pick-directory
+      codiscuss launch projects [--file FILE]
+      codiscuss launch machine-link --file FILE
 
 settings 读取本机软件默认配置；指定文件时保存，不启动 AI。
 start 使用启动 JSON 创建或接入房间并启动；--dry-run 只校验和预览。
@@ -60,6 +62,8 @@ api-key 将 base_url、api_key 保存于本机私有目录，只返回 api_key_r
 api-check 用 API profile 向模型发送一次极短请求，核对地址、密钥、协议与模型是否可用。
 scheduler-check 用智能调度配置（provider、model、api_key_ref）向决策模型发送一道是非题，核对供应商、模型与密钥是否可用。
 pick-directory 在本机弹出系统目录选择窗口，返回所选路径；取消时不返回路径。
+projects 读取本机已配置的项目（名称与绝对路径）；提供 JSON（projects 列表）时整体替换保存。
+machine-link 返回本机连接指定 site 的电脑编号、名称与凭据，供已登录管理员的网页完成配对；不存在时创建。
 room-member 为运行中的自由房间或讨论邀请、请回一位成员（讨论只接受本机唤醒的成员）；须提供 site、room_id、token、action（add/rejoin）、name。
 JSON 指定 site、entry（conversation/web）、room（建房内容，含 submission_id）
 或 room_id（已有房间）、participants（本次软件覆盖配置）。
@@ -71,7 +75,9 @@ conversation 还须 current_session_id，当前会话接手首个主持任务。
 // Windows PowerShell 5.1 ships WinForms. A background process cannot take the foreground, so the owner must be
 // shown (off-screen) as a topmost window; the dialog it owns then stays above the browser that asked for it.
 // windowsHide turns the process's first Show into a hide, so the owner is shown a second time to really appear.
-// Foreground rights are not guaranteed to a background process either, so a timer in the dialog's message loop pins the dialog owned by the hidden form topmost.
+// Under the local service the whole process chain has no console and no foreground rights: Windows then silently ignores
+// SetWindowPos(HWND_TOPMOST) on the dialog (it returns success). So once the dialog exists, a timer in its message loop
+// briefly attaches to the foreground window's input thread (the browser that asked) to borrow its right to raise the dialog.
 // The C# source must not contain single quotes: it is embedded in a single-quoted PowerShell string.
 const PICKER_RAISE_SOURCE = [
   'using System; using System.Runtime.InteropServices;',
@@ -80,8 +86,21 @@ const PICKER_RAISE_SOURCE = [
   '  [DllImport("user32.dll")] static extern bool EnumWindows(EnumProc proc, IntPtr arg);',
   '  [DllImport("user32.dll")] static extern IntPtr GetWindow(IntPtr handle, uint command);',
   '  [DllImport("user32.dll")] static extern bool SetWindowPos(IntPtr handle, IntPtr after, int x, int y, int width, int height, uint flags);',
-  '  public static void OwnedBy(IntPtr owner) {',
-  '    EnumWindows((handle, arg) => { if (GetWindow(handle, 4) == owner) SetWindowPos(handle, (IntPtr)(-1), 0, 0, 0, 0, 0x13); return true; }, IntPtr.Zero);',
+  '  [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();',
+  '  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr handle, IntPtr process);',
+  '  [DllImport("kernel32.dll")] static extern uint GetCurrentThreadId();',
+  '  [DllImport("user32.dll")] static extern bool AttachThreadInput(uint attach, uint to, bool on);',
+  '  [DllImport("user32.dll")] static extern bool BringWindowToTop(IntPtr handle);',
+  '  [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr handle);',
+  '  public static bool OwnedBy(IntPtr owner) {',
+  '    IntPtr dialog = IntPtr.Zero;',
+  '    EnumWindows((handle, arg) => { if (GetWindow(handle, 4) == owner) dialog = handle; return dialog == IntPtr.Zero; }, IntPtr.Zero);',
+  '    if (dialog == IntPtr.Zero) return false;',
+  '    uint current = GetCurrentThreadId(), foreground = GetWindowThreadProcessId(GetForegroundWindow(), IntPtr.Zero);',
+  '    bool attached = foreground != 0 && foreground != current && AttachThreadInput(current, foreground, true);',
+  '    SetWindowPos(dialog, (IntPtr)(-1), 0, 0, 0, 0, 0x13); BringWindowToTop(dialog); SetForegroundWindow(dialog);',
+  '    if (attached) AttachThreadInput(current, foreground, false);',
+  '    return true;',
   '  }',
   '}',
 ].join(' ');
@@ -91,7 +110,7 @@ const WINDOWS_PICKER = [
   '$owner = New-Object System.Windows.Forms.Form -Property @{ TopMost = $true; ShowInTaskbar = $false; FormBorderStyle = "None"; StartPosition = "Manual"; Location = New-Object System.Drawing.Point(-32000, -32000); Size = New-Object System.Drawing.Size(1, 1) }',
   `Add-Type -TypeDefinition '${PICKER_RAISE_SOURCE}'`,
   '$owner.Show(); $owner.Hide(); $owner.Show(); $owner.Activate()',
-  '$timer = New-Object System.Windows.Forms.Timer -Property @{ Interval = 150 }; $timer.Add_Tick({ [PickerRaise]::OwnedBy($owner.Handle) }); $timer.Start()',
+  '$timer = New-Object System.Windows.Forms.Timer -Property @{ Interval = 150 }; $timer.Add_Tick({ if ([PickerRaise]::OwnedBy($owner.Handle)) { $timer.Stop() } }); $timer.Start()',
   '$dialog = New-Object System.Windows.Forms.FolderBrowserDialog -Property @{ Description = "选择项目目录"; ShowNewFolderButton = $true }',
   'if ($dialog.ShowDialog($owner) -eq "OK") { $dialog.SelectedPath }',
   '$owner.Close()',
@@ -188,6 +207,34 @@ export function save_launch_settings(home, input) {
   return settings;
 }
 
+const PROJECT_NAME_LIMIT = 80;
+const PROJECT_ID_PATTERN = /^[0-9a-f]{8,32}$/;
+
+/** Read the named project directories saved on this computer, offered as launch cwd choices. */
+export function launch_projects(home) {
+  const path = join(home, 'launch-projects.json');
+  return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : { projects: [] };
+}
+
+/** Replace the project list; every path must be an existing folder on this computer. */
+// The id outlives renames and moves: other devices choose a project by id and never see its path.
+export function save_launch_projects(home, input) {
+  if (!Array.isArray(input.projects)) throw new Error('projects 必须为列表');
+  const projects = input.projects.map(item => ({ id: PROJECT_ID_PATTERN.test(item?.id) ? item.id : randomUUID().replaceAll('-', '').slice(0, 16),
+    name: String(item?.name || '').trim(), path: String(item?.path || '').trim() }));
+  const names = new Set();
+  for (const { name, path } of projects) {
+    if (!name || name.length > PROJECT_NAME_LIMIT) throw new Error(`项目名称不能为空，且不超过 ${PROJECT_NAME_LIMIT} 字`);
+    if (names.has(name)) throw new Error(`项目名称重复：${name}`);
+    names.add(name);
+    if (!isAbsolute(path)) throw new Error(`${name}：路径必须为完整绝对路径`);
+    if (!existsSync(path) || !statSync(path).isDirectory()) throw new Error(`${name}：这台电脑上不存在此文件夹：${path}`);
+  }
+  mkdirSync(home, { recursive: true, mode: 0o700 });
+  atomic_json(join(home, 'launch-projects.json'), { projects });
+  return { projects };
+}
+
 /** Reject malformed client fields before saving defaults or creating any discussion. */
 function validate_profile(name, profile, binding = false) {
   if (!clients_of(name) || !profile || typeof profile !== 'object' || Array.isArray(profile)) throw new Error(`不支持的软件配置：${name}`);
@@ -775,7 +822,8 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
   assert_shared_home(home);
   let result;
   if (positionals[0] === 'settings') result = { ...(input ? save_launch_settings(home, input) : launch_settings(home)), api_providers: API_PROVIDERS,
-    scheduler_providers: SCHEDULER_PROVIDERS, api_keys: saved_api_keys(home) };
+    scheduler_providers: SCHEDULER_PROVIDERS, api_keys: saved_api_keys(home), projects: launch_projects(home).projects };
+  else if (positionals[0] === 'projects') result = input ? save_launch_projects(home, input) : launch_projects(home);
   else if (positionals[0] === 'api-key' && input) result = save_api_key(home, input);
   else if (positionals[0] === 'api-check' && input) result = await api_check(home, input);
   else if (positionals[0] === 'scheduler-check' && input) result = await scheduler_check(home, input);
@@ -788,6 +836,7 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
   }
   else if (positionals[0] === 'room-member' && input) result = await room_member(home, input);
   else if (positionals[0] === 'pick-directory') result = await pick_directory();
+  else if (positionals[0] === 'machine-link' && input) result = (await import('./remote_launch.mjs')).machine_link(home, input.site);
   else if (positionals[0] === 'start' && input) result = await launch_discussion(home, input, { dry_run: values['dry-run'], browser_request: values.browser });
   else if (positionals[0] === 'room-config' && input) result = await room_configuration(home, input, { local_guard: values['configuration-locked'] });
   else throw new Error(HELP);

package/runner/discussion_local.mjs

@@ -11,6 +11,7 @@ import { atomic_json } from './discussion_adapters.mjs';
 import { acquire_lock } from './discussion_runner.mjs';
 import { assert_shared_home, main as service_main, service_home, service_pid, service_ready, start_service } from './discussion_service.mjs';
 import { detect_python, local_settings } from './discussion_setup.mjs';
+import { unlink_machine } from './remote_launch.mjs';
 import { tone } from './discussion_tui.mjs';
 
 const SCRIPT = fileURLToPath(import.meta.url);
@@ -25,7 +26,7 @@ const LOCAL_HELP = `用法：codiscuss local open|start|status|stop [--json]
       codiscuss local disconnect SITE
 
 connect 允许指定 HTTPS 站点通过此浏览器使用本机软件配置并启动 AI，打开连接链接完成接入。
-disconnect 撤销该站点的新启动权限；已运行的讨论须另行暂停。
+disconnect 撤销该站点的新启动权限（含其他设备经网站转来的启动）；已运行的讨论须另行暂停。
 数据保留在服务目录中；重新 connect 会替换该站点的旧连接。
 结果摘要写入终端；输出被重定向或加 --json 时 JSON 写入 stdout。
 `;
@@ -48,7 +49,7 @@ export function save_site_connection(home, site, token = null) {
     const path = join(home, 'site-connections.json');
     const settings = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : { sites: {} };
     if (token) settings.sites[origin] = { token_hash: createHash('sha256').update(token).digest('hex') };
-    else delete settings.sites[origin];
+    else { delete settings.sites[origin]; unlink_machine(home, origin); }
     atomic_json(path, settings);
   } finally { release(); }
 }

package/runner/discussion_service.mjs

@@ -13,6 +13,7 @@ import { DiscussionRunner, DiscussionStore, acquire_lock, api, load_config, paus
 import { FreeRoomRunner } from './free_runner.mjs';
 
 const POLL_MS = 2000;
+const REMOTE_SYNC_MS = 3000;
 const START_WAIT_MS = 5000;
 const STOP_WAIT_MS = 20_000;
 const REGISTRY_WAIT_MS = 5000;
@@ -400,8 +401,15 @@ export async function run_service(home, output = () => {}) {
     log_line(`讨论服务已启动 pid=${process.pid}`);
     atomic_json(join(home, 'status.json'), { pid: process.pid, ready: true,
       updated_at: Math.floor(Date.now() / 1000), rooms: [] });
+    // Loaded lazily: the relay runs launches, and the launch module itself depends on this one.
+    const { sync_remote_launches } = await import('./remote_launch.mjs');
+    let synced_at = 0;
     while (!stopped && !existsSync(stop_path)) {
       try { await service.tick(); } catch (error) { log_line(`服务检查失败：${error.message}`); }
+      if (Date.now() - synced_at >= REMOTE_SYNC_MS) {
+        synced_at = Date.now();
+        try { await sync_remote_launches(home, { log: log_line }); } catch (error) { log_line(`远程启动检查失败：${error.message}`); }
+      }
       await sleep(POLL_MS);
     }
   } finally {

package/runner/remote_launch.mjs

@@ -0,0 +1,101 @@
+/** Run room launches that other devices relay through a paired website; directories and credentials stay here. */
+import { randomBytes, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { join } from 'node:path';
+
+import { atomic_json } from './discussion_adapters.mjs';
+import { saved_api_keys } from './discussion_api.mjs';
+import { launch_discussion, launch_projects, launch_settings, platform_of } from './discussion_launch.mjs';
+
+const MACHINE_TOKEN_BYTES = 32;
+const MACHINE_NAME_MAX = 60;
+const SYNC_TIMEOUT_MS = 10000;
+const LINKS_FILE = 'machine-links.json';
+
+/** Read every site this computer is paired with. */
+export function machine_links(home) {
+  const path = join(home, LINKS_FILE);
+  return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : { sites: {} };
+}
+
+/** Return this computer's identity for one site, creating it on first use; the browser then pairs it as administrator. */
+export function machine_link(home, site) {
+  const origin = new URL(site).origin;
+  const links = machine_links(home);
+  links.sites[origin] ||= { id: randomUUID().replaceAll('-', ''), token: randomBytes(MACHINE_TOKEN_BYTES).toString('hex'),
+    name: (hostname() || '本机').slice(0, MACHINE_NAME_MAX) };
+  mkdirSync(home, { recursive: true, mode: 0o700 });
+  atomic_json(join(home, LINKS_FILE), links);
+  return links.sites[origin];
+}
+
+/** Forget a site's pairing so it can no longer hand launches to this computer. */
+export function unlink_machine(home, site) {
+  const links = machine_links(home);
+  if (!links.sites[site]) return;
+  delete links.sites[site];
+  atomic_json(join(home, LINKS_FILE), links);
+}
+
+/** Resolve the API key saved for a profile's base URL, as the connected browser does. */
+function api_key_ref(profile, keys) {
+  if (profile.api_key_ref || !profile.base_url) return profile.api_key_ref;
+  try { return keys[new URL(profile.base_url).href.replace(/\/+$/, '')]; } catch { return undefined; }
+}
+
+/** Platforms this computer can wake without further setup, and the client each uses. */
+export function ready_clients(home) {
+  const keys = saved_api_keys(home);
+  return Object.fromEntries(Object.entries(launch_settings(home).participants).filter(([, profile]) => profile.adapter === 'api'
+    ? Boolean(profile.base_url && profile.api_protocol && profile.model && api_key_ref(profile, keys))
+    : Boolean(profile.adapter && (profile.adapter === 'antigravity' ? profile.ipc_directory : profile.executable))).map(([name, profile]) => [name, profile.adapter]));
+}
+
+/** Turn a relayed request into the request the connected browser would send, using this computer's directory and keys. */
+export function local_request(home, site, request) {
+  const { local_project, ...input } = request;
+  if (input.cwd || input.access_file) throw new Error('远程启动只能选择电脑上已配置的项目');
+  const project = local_project ? launch_projects(home).projects.find(item => item.id === local_project) : null;
+  if (local_project && !project) throw new Error('所选项目已从这台电脑移除，请重新选择');
+  const keys = saved_api_keys(home), defaults = launch_settings(home).participants;
+  const participants = { ...(input.participants || {}) };
+  for (const member of input.room?.members || []) {
+    const profile = defaults[platform_of(member.name)];
+    const ref = profile?.adapter === 'api' && !participants[member.name]?.api_key_ref ? api_key_ref(profile, keys) : undefined;
+    if (ref) participants[member.name] = { ...participants[member.name], api_key_ref: ref };
+  }
+  return { ...input, participants, site, entry: 'web', ...(project ? { cwd: project.path } : {}) };
+}
+
+async function machine_request(site, link, path, body) {
+  const response = await fetch(`${site}/api/machines/${link.id}${path}`, { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(SYNC_TIMEOUT_MS),
+    headers: { 'Content-Type': 'application/json', 'X-Machine-Token': link.token }, body: JSON.stringify(body) });
+  const result = await response.json();
+  if (!response.ok) throw new Error(`HTTP ${response.status}: ${result.error || '请求失败'}`);
+  return result;
+}
+
+/** Publish projects and clients to each paired site, then run every launch it relays, one at a time. */
+export async function sync_remote_launches(home, { launch = launch_discussion, log = () => {} } = {}) {
+  const projects = launch_projects(home).projects.filter(project => project.id).map(({ id, name }) => ({ id, name }));
+  const clients = ready_clients(home);
+  for (const [site, link] of Object.entries(machine_links(home).sites)) {
+    let launches;
+    try { ({ launches } = await machine_request(site, link, '/sync', { projects, clients })); }
+    catch (error) { log(`${site}: 同步电脑状态失败：${error.message}`); continue; }
+    for (const { id, request } of launches) {
+      const action = body => machine_request(site, link, `/launches/${encodeURIComponent(id)}`, body);
+      try {
+        await action({ action: 'claim' });
+        const result = await launch(home, local_request(home, site, request), { browser_request: true });
+        await action({ action: 'finish', room_id: result.room.id, status: result.status });
+        log(`${site}: 远程启动 ${id} 已创建房间 ${result.room.id}`);
+      } catch (error) {
+        log(`${site}: 远程启动 ${id} 失败：${error.message}`);
+        await action({ action: 'fail', error: error.message, stage: error.launch?.stage || 'not_started',
+          ...(error.launch?.room_id ? { room_id: error.launch.room_id } : {}) }).catch(() => {});
+      }
+    }
+  }
+}

package/web/app.js

@@ -28,6 +28,9 @@ const MEMBER_ACCESS_PREFIX = "discuss-members:";
 const MEMBER_PENDING_PREFIX = "discuss-member-pending:";
 const LOCAL_CONNECTION_KEY = "discuss-local-connection";
 const LOCAL_CONNECTION_TIMEOUT_MS = 15000;
+// A relayed launch waits this long for the paired computer before the request is kept as a pending item.
+const RELAY_WAIT_MS = 45000;
+const RELAY_POLL_MS = 1500;
 const MODEL_CATALOG_TIMEOUT_MS = 35000;
 let local_connection = null;
 const DEFAULT_USER_LABEL = "User";
@@ -71,7 +74,7 @@ state.directory_pending = new Map();
 state.directory_version = 0;
 state.navigation_version = 0;
 state.admin = { loaded: false, local: false, registered: false, setup_available: false, logged_in: false, profile: null, identity_version: 0 };
-state.launch = { available: false, remote: false, connect_command: "", profiles: {}, workspace: {}, scheduler: {}, create: true, error: "", notice: "", recoveries: [] };
+state.launch = { available: false, remote: false, relay: null, connect_command: "", profiles: {}, projects: [], workspace: {}, scheduler: {}, create: true, error: "", notice: "", recoveries: [] };
 const PLATFORM_CLIENTS = { Codex: [{ value: "codex_cli", label: "Codex CLI" }, { value: "codex", label: "Codex App" }],
   Claude: [{ value: "claude", label: "Claude Code CLI" }],
   Gemini: [{ value: "antigravity_cli", label: "Antigravity CLI" }, { value: "antigravity", label: "Antigravity App" }] };
@@ -221,6 +224,8 @@ function admin_error(error) {
 function accept_admin_session({ token, profile }) {
   store_admin_token(token);
   apply_admin_state({ registered: true, setup_available: false, logged_in: true, profile });
+  // Pairing and the paired computer both need the session, so read them again now.
+  load_launch_settings();
 }
 
 /** Create the single administrator account and sign in with it. */
@@ -244,6 +249,7 @@ async function logout_admin() {
   catch { /* The token is removed below either way. */ }
   store_admin_token("");
   state.admin.logged_in = false;
+  state.launch.relay = null;
   publish_view();
 }
 
@@ -1540,8 +1546,9 @@ async function submit_room(event, folder_id = null) {
   const free = payload.mode === "free";
   // A discussion can still be created without the local service and started later from the room;
   // a free room needs the service only for members it wakes or for smart scheduling.
-  const launching = free ? Object.values(payload.experts).includes("cli") || (state.launch.available && Boolean(creation_launch_options().scheduler || state.launch.workspace.cwd)) : state.launch.create && state.launch.available;
-  if (launching && !state.launch.available) throw new Error("本机唤醒的成员需要连接本机服务；也可改为手动接入或网页代发");
+  const launchable = state.launch.available || Boolean(state.launch.relay);
+  const launching = free ? Object.values(payload.experts).includes("cli") || (launchable && Boolean(creation_launch_options().scheduler || state.launch.workspace.cwd || state.launch.workspace.local_project)) : state.launch.create && state.launch.available;
+  if (launching && !launchable) throw new Error("本机唤醒的成员需要连接本机服务；也可改为手动接入或网页代发");
   const launch_draft = launching ? creation_launch_options() : null;
   // A discussion is only a way to push the room forward: the room is created as a free room, then opened with these limits.
   const discussion = free && state.create_discussion ? { goal: payload.goal.trim(), named_followup: state.named_followup,
@@ -1675,7 +1682,8 @@ async function submit_local_launch(input, title, direct = false, signature) {
   const id = input.room?.submission_id || `room-${input.room_id}`;
   const key = LAUNCH_PENDING_PREFIX + id;
   const previous = localStorage.getItem(key);
-  const record = previous ? JSON.parse(previous) : { id, title, input, room_id: input.room_id, direct, signature };
+  const relay = !direct && !state.launch.available ? state.launch.relay?.id : undefined;
+  const record = previous ? JSON.parse(previous) : { id, title, input, room_id: input.room_id, direct, signature, ...(relay ? { machine_id: relay } : {}) };
   if (previous && JSON.stringify(record.input) !== JSON.stringify(input)) throw new Error("此房间有未完成的原启动请求，请先继续该请求，不要替换配置");
   record.attempt_id = crypto.randomUUID();
   try { localStorage.setItem(key, JSON.stringify(record)); }
@@ -1683,7 +1691,7 @@ async function submit_local_launch(input, title, direct = false, signature) {
   refresh_launch_recoveries();
   try {
     const result = record.direct ? { room: await request_json("/api/rooms", record.input.room, record.input.token), status: "created" }
-      : await local_launch_request("launch", record.input);
+      : record.machine_id ? await relay_launch_request(record.input, record.machine_id) : await local_launch_request("launch", record.input);
     save_room_credentials(result.room, record.input.token, record.input.room?.members || []);
     localStorage.removeItem(key);
     refresh_launch_recoveries();
@@ -1752,21 +1760,54 @@ async function load_launch_settings() {
     local_connection = restore_local_connection();
     state.launch.remote = Boolean(local_connection);
     if (local_connection) state.launch.connect_command = `codiscuss local connect "${location.origin}"`;
-    if (!local_connection && !local) return;
+    if (!local_connection && !local) { state.launch.relay = await load_relay_machine(); return; }
     const settings = await local_launch_request("settings");
     // Keep the saved machine defaults so every new form can start from them again.
     state.launch.saved_profiles = JSON.parse(JSON.stringify(settings.participants || {}));
-    Object.assign(state.launch, { available: true, profiles: settings.participants, api_providers: settings.api_providers || {}, api_keys: settings.api_keys || {},
+    Object.assign(state.launch, { available: true, profiles: settings.participants, projects: settings.projects || [], api_providers: settings.api_providers || {}, api_keys: settings.api_keys || {},
       scheduler_providers: settings.scheduler_providers || {}, error: "",
       notice: local_connection ? "已连接本机服务，讨论保存在当前网站" : "" });
     Object.values(state.launch.profiles).forEach(fill_api_key);
+    if (local_connection) pair_local_machine();
     // Settings arrive after the form was reset; only an untouched draft gets the default.
     if (!Object.keys(state.launch.scheduler).length) state.launch.scheduler = default_scheduler();
     load_room_models();
-  } catch (error) { state.launch.available = false; state.launch.room_models = null; state.launch.error = error.message; }
+  } catch (error) {
+    Object.assign(state.launch, { available: false, room_models: null, error: error.message });
+    // Without a reachable local service, launches can still go through the paired computer.
+    state.launch.relay = await load_relay_machine();
+    if (state.launch.relay) state.launch.error = "";
+  }
   finally { refresh_launch_recoveries(); render_launch_settings(); publish_view(); }
 }
 
+/** The computer paired with this site, most recently seen first; only the administrator can read or use it. */
+async function load_relay_machine() {
+  if (!admin_token()) return null;
+  try { return (await request_json("/api/machines")).machines[0] || null; } catch { return null; }
+}
+
+/** Pair the connected computer so devices without the local service can launch on it; needs the administrator session. */
+async function pair_local_machine() {
+  if (!admin_token()) return;
+  try { await request_json("/api/machines", await local_launch_request("machine-link", {})); }
+  catch (error) { console.warn("Pairing this computer failed:", error.message); }
+}
+
+/** Hand a room creation to the paired computer through the website and wait for it to finish. */
+async function relay_launch_request(input, machine_id) {
+  const id = input.room.submission_id;
+  let launch = await request_json("/api/remote-launches", { id, machine_id, request: input });
+  for (let waited = 0; ["pending", "claimed"].includes(launch.status) && waited < RELAY_WAIT_MS; waited += RELAY_POLL_MS) {
+    await new Promise(resolve => setTimeout(resolve, RELAY_POLL_MS));
+    launch = await request_json(`/api/remote-launches/${encodeURIComponent(id)}`);
+  }
+  if (launch.status === "failed") throw Object.assign(new Error(launch.error), { launch: { stage: launch.result.stage, room_id: launch.result.room_id } });
+  const name = state.launch.relay?.name || "电脑";
+  if (launch.status !== "done") throw Object.assign(new Error(`${name}${launch.status === "pending" ? "尚未接手" : "仍在启动"}，请保持它开机并运行 codiscuss，稍后在待办中继续`), { launch: { stage: "unconfirmed" } });
+  return { room: await request_json(`/api/rooms/${launch.result.room_id}`, undefined, input.token), status: launch.result.status };
+}
+
 /** Re-check the local connection and explain when nothing has been connected yet. */
 async function retry_launch_connection() {
   await load_launch_settings();
@@ -1948,7 +1989,9 @@ function restore_launch_profile(name, profile) {
 
 /** Capture local overrides before asynchronous work or navigation can change the draft. */
 function launch_options() {
-  const draft = JSON.parse(JSON.stringify({ participants: state.launch.profiles, ...state.launch.workspace, entry: "web" }));
+  const { local_project, ...workspace } = state.launch.workspace;
+  // The paired computer resolves a project id to its own folder; a browser with the local service sends the folder itself.
+  const draft = JSON.parse(JSON.stringify({ participants: state.launch.profiles, ...workspace, ...(!state.launch.available && local_project ? { local_project } : {}), entry: "web" }));
   for (const profile of Object.values(draft.participants)) if (profile.adapter === "api") profile.project_access = "read";
   return draft;
 }
@@ -2077,23 +2120,35 @@ function clear_launch_overrides(draft) {
       if (state.launch.profiles[name]?.[field] === profile[field]) delete state.launch.profiles[name]?.[field];
     }
   }
-  for (const field of ["cwd", "discussion_project", "project_access"]) {
+  for (const field of ["cwd", "local_project", "discussion_project", "project_access"]) {
     if (state.launch.workspace[field] === draft[field]) delete state.launch.workspace[field];
   }
   render_launch_settings();
   publish_view();
 }
 
+/** Browse for a folder on the computer running the local service; resolves to "" when cancelled. */
+async function browse_local_directory() {
+  return (await local_launch_request("pick-directory", {})).path || "";
+}
+
 /** Let the user browse for the project folder on the computer running the local service. */
 async function pick_launch_directory() {
   try {
-    const result = await local_launch_request("pick-directory", {});
-    if (result.path) write_launch_field("workspace", "cwd", result.path);
+    const path = await browse_local_directory();
+    if (path) write_launch_field("workspace", "cwd", path);
     state.launch.error = "";
   } catch (error) { state.launch.error = error.message; }
   publish_view();
 }
 
+/** Replace the named project directories kept on the computer running the local service. */
+async function save_launch_projects(projects) {
+  const result = await local_launch_request("projects", { projects });
+  state.launch.projects = result.projects;
+  publish_view();
+}
+
 /** Save machine defaults without per-discussion session IDs or project write access. */
 async function save_launch_defaults() {
   // Defaults are per platform; an extra instance's model and effort apply to its own discussion only.
@@ -3367,7 +3422,7 @@ function change_view_theme(theme) {
 
 window.discuss_view = { snapshot: view_snapshot, write_field: write_view_field,
   write_launch: write_launch_field, write_room_connection, write_room_adapter, launch_clients: LAUNCH_CLIENTS,
-  launch_model_state, load_launch_models, write_launch_model, save_launch_api_key, write_scheduler, save_scheduler_api_key, check_scheduler, write_named_followup, write_create_discussion, check_launch_api, launch_summary, launch_can_set_access, launch_can_bind_session, pick_launch_directory, restore_launch_profile, reset_create_form, empty_discussion_message,
+  launch_model_state, load_launch_models, write_launch_model, save_launch_api_key, write_scheduler, save_scheduler_api_key, check_scheduler, write_named_followup, write_create_discussion, check_launch_api, launch_summary, launch_can_set_access, launch_can_bind_session, pick_launch_directory, browse_local_directory, save_launch_projects, restore_launch_profile, reset_create_form, empty_discussion_message,
   start_drag: start_directory_drag,
   attachment_markup, attachment_size, attachment_file_icon, drop_attachments, paste_attachments,
   write_expert: write_view_expert, add_instance: add_view_instance, platform_of, execute: execute_view_action, theme: change_view_theme,