ai_co_discuss 0.3.57 → 0.3.59

package/.agents/skills/workflow-creator/SKILL.md

@@ -75,7 +75,7 @@ project_access: write
 
 - **工作流 ID**（文件夹名 = SKILL.md 的 `name`）：小写英文和数字，可用单个连字符连接（不在首尾），1—40 位。`label` 最多 32 字。
 - **`description`** 最多 500 字：写清做什么、什么时候用。主持人只凭它判断一条请求该不该按这个工作流做，写含糊了，该用时会不用、不该用时会套用。
-- **卡片**：最多 30 张。`name` 是卡片 ID，等于文件名，只用小写英文、数字和下划线，最多 16 位。`platform` 是平台 ID：`Claude`、`Codex`、`Antigravity`、`DeepSeek`、`Qwen`、`Grok`（网页显示的 Gemini 写 `Antigravity`），须是本机已配置的平台。成员名由程序拼成 `平台-卡片ID`。
+- **卡片**：最多 30 张。`name` 是卡片 ID，等于文件名，只用小写英文、数字和下划线，最多 16 位。`platform` 是平台 ID：`Claude`、`Codex`、`Antigravity`、`DeepSeek`、`Qwen`、`Grok`（网页显示的 Gemini 写 `Antigravity`），须是本机已配置的软件，或已在本机保存 API Key 的模型 API（没有本地软件的平台按官方 API 加入）。成员名由程序拼成 `平台-卡片ID`。
 - **卡片可选字段**：`label`、`description`、`project_access`（read / write / auto / full）、`model`、`effort`。不用的字段直接省略；模型和强度省略即用本机默认值。接入方式、可执行文件、密钥不写进卡片，由各自电脑的配置决定。
 - 头信息只支持单行 `key: value`；不支持多行值、列表和嵌套。
 - 卡片正文留空时使用该软件的默认提示。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai_co_discuss",
-  "version": "0.3.57",
+  "version": "0.3.59",
   "bin": {
     "codiscuss": "runner/codiscuss.mjs"
   },

package/runner/discussion_launch.mjs

@@ -1400,8 +1400,7 @@ export function workflows_command(home, input = {}) {
   if (action === 'save') return save_workflow(home, input.workflow, validate_preset);
   if (action === 'delete') return delete_workflow(home, input.id);
   if (action === 'preview') {
-    const configured = launch_settings(home).participants;
-    return preview_workflow(input, validate_preset, name => Boolean(configured[platform_of(name)]));
+    return preview_workflow(input, validate_preset, name => card_platform_ready(home, name));
   }
   if (action === 'room-cards') return room_cards(home, input);
   throw new Error('action 须为 list、get、save、delete、preview 或 room-cards');
@@ -1494,6 +1493,24 @@ async function host_room(home, access_file) {
   return { path, config, roster };
 }
 
+/**
+ * The API settings a program-started card on a platform without local software starts from, as the invite form fills
+ * them: the platform's official API with the key last saved here for that root. Null when the platform has saved
+ * software settings or local software, or no key is saved.
+ */
+function card_api_profile(home, platform) {
+  if (launch_settings(home).participants[platform] || platform_adapters(platform).some(id => adapter_profile(id).kind !== 'api')) return null;
+  const provider = API_PROVIDERS[platform];
+  const api_key_ref = provider && saved_api_keys(home)[provider.base_url];
+  return api_key_ref ? { adapter: 'api', base_url: provider.base_url, api_protocol: provider.api_protocol, model: provider.models[0], api_key_ref } : null;
+}
+
+/** Whether a card's platform can start here: saved software settings, or an API with a saved key. */
+function card_platform_ready(home, name) {
+  const platform = platform_of(name || '');
+  return Boolean(platform && (launch_settings(home).participants[platform] || card_api_profile(home, platform)));
+}
+
 /**
  * Give cards of the room's workflow a member: a present one stays, one that left is brought back, and a card with
  * none (or whose member was removed) is invited as a program-started member with the card's settings, label and
@@ -1508,7 +1525,11 @@ async function join_workflow_cards(home, config, roster, workflow, members, card
     if (current?.status === 'away') { await room_member(home, { ...owner, action: 'rejoin', name: current.name }); continue; }
     const taken = new Set([...roster.map(member => member.name), ...Object.values(next)]);
     const name = taken.has(agent.name) ? free_instance(agent.name, taken) : agent.name;
-    const profile = Object.fromEntries(['project_access', 'model', 'effort'].filter(field => agent[field]).map(field => [field, agent[field]]));
+    const api = card_api_profile(home, platform_of(agent.name));
+    const card = Object.fromEntries(['project_access', 'model', 'effort'].filter(field => agent[field] && !(api && field === 'effort')).map(field => [field, agent[field]]));
+    // An API member has no command line, so a card asking for more than writing gets the most it allows.
+    if (api && card.project_access && !access_levels('api').includes(card.project_access)) card.project_access = 'write';
+    const profile = { ...api, ...card };
     const joined = await room_member(home, { ...owner, action: 'add', name, participants: { [name]: profile } });
     next[agent.card] = joined.member;
     if (agent.label) labels[joined.member] = agent.label;
@@ -1591,9 +1612,11 @@ export async function adopt_workflow(home, { access_file, draft_file, workflow_i
     if (bound !== draft.id && list_workflows(home).some(item => item.id === draft.id)) throw new Error(`工作流库已有 ${draft.id}，主持人不能覆盖其他工作流；要启用它请用 --id ${draft.id}，新建请换一个 ID`);
     workflow = draft;
   }
-  const configured = launch_settings(home).participants;
-  const missing = workflow.agents.filter(agent => !configured[platform_of(agent.name || '')]).map(agent => agent.name || agent.card);
-  if (missing.length) throw new Error(`本机没有配置这些卡片的软件：${missing.join('、')}；卡片的 platform 只能用本机已配置的平台 ID：${Object.keys(configured).join('、')}`);
+  const missing = workflow.agents.filter(agent => !card_platform_ready(home, agent.name)).map(agent => agent.name || agent.card);
+  if (missing.length) {
+    const ready = [...new Set([...Object.keys(launch_settings(home).participants), ...Object.keys(API_PROVIDERS).filter(platform => card_api_profile(home, platform))])];
+    throw new Error(`本机没有配置这些卡片的软件或 API Key：${missing.join('、')}；卡片的 platform 只能用本机已配置的平台 ID：${ready.join('、')}`);
+  }
   workflow = workflow_id ? { ...workflow, agents: host_cards(workflow.agents) }
     : save_workflow(home, { ...workflow, agents: host_cards(workflow.agents) }, validate_preset);
   const owner = { site: config.site, room_id: config.room, token: config.token };

package/web/app.js

@@ -48,6 +48,12 @@ const RELAY_COMMAND_POLL_MS = 250;
 const RELAY_SETTINGS_WAIT_MS = 20000;
 // The computer allows each operation 60 seconds, as the local website does.
 const RELAY_COMMAND_WAIT_MS = 75000;
+// The website answers a relayed request within its wait (9 seconds unless asked for more); a request still unanswered
+// this much later is stuck in the network and is given up, so a hung connection cannot hold back reconnecting.
+const RELAY_DEFAULT_WAIT_MS = 9000;
+const MACHINE_REQUEST_MARGIN_MS = 15000;
+// How long a pairing request waits for the computer over the relay, in milliseconds as the relay counts.
+const PAIR_WAIT_MS = 15000;
 const RELAY_CIPHER_INFO = "codiscuss-relay-v1";
 // The rooms kept on the paired computer are read and written through its relay connection; only room routes go there.
 const RELAY_PROTOCOL = "codiscuss-relay";
@@ -231,6 +237,7 @@ async function request_json(path, payload, access_token) {
     options.headers["Content-Type"] = "application/json";
     options.body = JSON.stringify(payload);
   }
+  if (/^\/api\/(machines|admin)/.test(path)) options.signal = AbortSignal.timeout((Number.isInteger(payload?.wait) ? payload.wait : RELAY_DEFAULT_WAIT_MS) + MACHINE_REQUEST_MARGIN_MS);
   const response = await fetch(path, options);
   const result = await response.json();
   if (!response.ok) throw Object.assign(new Error(result.error || "请求失败，请重试"), { preflight: response.status >= 400 && response.status < 500, status: response.status });
@@ -2303,7 +2310,7 @@ async function pair_exchange(machine, payload) {
   const id = crypto.randomUUID();
   const { key, envelope } = await seal_relay_request(machine, id, { action: "device-pair", payload });
   const path = `/api/machines/${encodeURIComponent(machine.id)}/pair`;
-  const response = await fetch(path, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id, envelope, wait: 15 }) });
+  const response = await fetch(path, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id, envelope, wait: PAIR_WAIT_MS }) });
   const result = await response.json();
   if (!response.ok) throw new Error(result.error || "配对请求被网站拒绝");
   if (result.status === "done") return open_relay_response(key, id, result.response);
@@ -2435,7 +2442,12 @@ async function relay_exchange(action, payload, wait) {
   const target = computer_rooms_only() ? { target: "computer" } : {};
   const { key, envelope } = await seal_relay_request(machine, id, { action, payload, ...target });
   const result = await request_json(`/api/machines/${encodeURIComponent(machine.id)}/relay`, { id, envelope, ...(wait ? { wait } : {}) })
-    .catch(error => { throw error.status === 401 ? Object.assign(error, { need: "pairing" }) : error; });
+    .catch(error => {
+      // A request given up in the network may still have reached the computer, so its outcome is unconfirmed.
+      if (error.name === "TimeoutError") throw Object.assign(new Error(`结果待确认：电脑「${machine.name}」未在限时内答复，请稍后查看房间，确认是否已生效后再重试`),
+        { unconfirmed: true, launch: { stage: "unconfirmed" } });
+      throw error.status === 401 ? Object.assign(error, { need: "pairing" }) : error;
+    });
   if (result.status === "done") return open_relay_response(key, id, result.response);
   if (result.status === "offline") throw Object.assign(new Error(`电脑「${machine.name}」不在线，请确认它开机并运行 codiscuss`), { offline: true });
   throw Object.assign(new Error(`结果待确认：电脑「${machine.name}」未在限时内答复，请稍后查看房间，确认是否已生效后再重试`),
@@ -2619,15 +2631,29 @@ async function show_computer_rooms(remote) {
   await select_room(undefined);
 }
 
-/** Once signed in, find the paired computer and show its rooms; the poll calls this again until the computer answers. */
-async function connect_computer_rooms() {
+let computer_retry = null, computer_attempt = 0;
+/**
+ * Once signed in, find the paired computer and show its rooms. This is the only way the computer's rooms appear; until
+ * they do, it tries again by itself, backing off while the computer stays away. `reload: false` reuses settings just read.
+ */
+async function connect_computer_rooms({ reload = true } = {}) {
   if (!state.admin.logged_in || computer_connecting) return;
   computer_connecting = true;
+  clearTimeout(computer_retry);
+  computer_retry = null;
   try {
-    await load_launch_settings();
+    if (reload) await load_launch_settings();
     if (relay_machine && !state.remote_rooms) await show_computer_rooms(true);
   } catch (error) { console.warn("Connecting to the computer failed:", error.message); }
-  finally { computer_connecting = false; }
+  finally {
+    computer_connecting = false;
+    if (state.remote_rooms) computer_attempt = 0;
+    else if (state.admin.logged_in && !document.hidden) {
+      const delay = RECONNECT_DELAYS_MS[Math.min(computer_attempt, RECONNECT_DELAYS_MS.length - 1)];
+      computer_attempt += 1;
+      computer_retry = setTimeout(() => { computer_retry = null; connect_computer_rooms(); }, delay);
+    }
+  }
 }
 
 /** The relay's change notices for the computer's rooms, shaped like the website's update stream. */
@@ -2796,7 +2822,9 @@ async function load_launch_settings() {
       state.launch.relay = await load_relay_machine();
       // An online computer that publishes a command key does everything the local service would; an older one only creates rooms.
       // The previous one stays in use until this answer arrives, so requests made meanwhile still reach the computer.
-      relay_machine = state.launch.relay?.online && state.launch.relay.public_key ? state.launch.relay : null;
+      // A website without rooms of its own asks the relay itself, which knows at once whether the computer is connected;
+      // the website's own record of the computer's last heartbeat can lag behind when that heartbeat is slow to arrive.
+      relay_machine = state.launch.relay?.public_key && (state.launch.relay.online || computer_rooms_only()) ? state.launch.relay : null;
       if (!relay_machine) return;
       state.launch.remote = true;
     }
@@ -2815,7 +2843,10 @@ async function load_launch_settings() {
     load_room_models();
   } catch (error) {
     // An unpaired or expired device keeps its way to the computer: pairing and renewal go through it.
-    relay_machine = error.need === "pairing" || error.need === "renew" ? relay_machine : null;
+    // A website without rooms of its own reaches the computer only through the relay, so one failed request keeps it.
+    relay_machine = computer_rooms_only() || error.need === "pairing" || error.need === "renew" ? relay_machine : null;
+    // The relay answering that the computer is not connected is shown as the computer being offline.
+    if (computer_rooms_only() && !state.remote_rooms) state.remote_online = error.offline ? false : null;
     state.launch.remote = Boolean(local_connection);
     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.
@@ -2841,7 +2872,10 @@ async function load_relay_machine() {
       return null;
     }
     return machine;
-  } catch { return null; }
+  } catch {
+    // A failed read says nothing about the pairing, so the computer known so far stays in use.
+    return state.launch.relay ?? null;
+  }
 }
 
 /** Hand a room creation to the paired computer through the website and wait for it to finish. */
@@ -4449,8 +4483,10 @@ async function initialize() {
     if (name && field === "model") write_launch_model(name, event.target.value);
     else if (name) write_launch_field(name, field, event.target.type === "checkbox" ? event.target.checked : event.target.value);
   });
-  // Whether this website keeps rooms of its own decides how settings and rooms are read.
-  await load_admin_state();
+  // Whether this website keeps rooms of its own decides how settings and rooms are read, so it is asked until it answers.
+  for (let attempt = 0; await load_admin_state(), !state.admin.loaded; attempt++) {
+    await new Promise(resolve => setTimeout(resolve, RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)]));
+  }
   const launch_settings = load_launch_settings();
   document.addEventListener("click", download_relay_file, true);
   new MutationObserver(() => { if (state.remote_rooms) show_relay_images(); }).observe(document.body, { childList: true, subtree: true });
@@ -4466,14 +4502,18 @@ async function initialize() {
   });
   if (computer_rooms_only()) {
     await launch_settings;
-    state.remote_rooms = Boolean(relay_machine) && await load_remote_site().then(() => true, () => false);
+    // The computer's rooms appear only through connecting, which keeps trying by itself, so nothing here can hide them.
+    await connect_computer_rooms({ reload: false });
   }
   try {
-    const result = computer_rooms_only() && !state.remote_rooms ? { rooms: [] } : await request_json("/api/rooms");
-    state.rooms = result.rooms;
-    state.last_room = result.last_room || "";
-    set_folder_directory(result);
-    await select_room(opening_room());
+    // Connecting has already opened the computer's rooms when it reached them.
+    if (!computer_rooms_only() || !state.remote_rooms) {
+      const result = computer_rooms_only() ? { rooms: [] } : await request_json("/api/rooms");
+      state.rooms = result.rooms;
+      state.last_room = result.last_room || "";
+      set_folder_directory(result);
+      await select_room(opening_room());
+    }
     set_connection(true);
   } catch (error) { set_connection(false); show_toast(error.message, true); }
   start_live_updates();