ai_co_discuss 0.3.53 → 0.3.55

package/docs/runner.md

@@ -63,7 +63,7 @@ codiscuss local connect https://你的站点
 
 手机或平板与电脑配对后，只要这台电脑开机并运行 codiscuss，就能像在电脑上一样操作：建房、邀请与请回成员、翻开卡片设置软件、模型和权限、录入 API 密钥、管理常用项目等。这些操作由网站转交给电脑执行，内容端到端加密，网站只经手密文。
 
-其他设备能用的目录由电脑决定：只能选择**常用项目**及其中的文件夹。点项目目录栏末尾的文件夹按钮，可以逐层浏览常用项目中的文件夹（只显示文件夹名）。想让其他设备使用更大的范围，就在电脑上把上级目录加为常用项目。以下设置只能在电脑上修改：软件位置、“全放开”权限档、常用项目范围之外的目录。转交的命令只执行一次，发出 10 分钟后作废，所以手机时间需要大致准确。
+其他设备能用的目录由电脑决定：只能选择**常用项目**及其中的文件夹。点项目目录栏末尾的文件夹按钮，可以逐层浏览常用项目中的文件夹（只显示文件夹名）。想让其他设备使用更大的范围，就在电脑上把上级目录加为常用项目。以下设置只能在电脑上修改：软件位置、常用项目范围之外的目录。转交的命令只执行一次，发出 10 分钟后作废，所以手机时间需要大致准确。
 
 **设备配对**：每台手机、平板或其他电脑第一次使用前，都要在这台电脑前配对一次，不需要注册账号或记住密码。
 1. 在电脑的本机网页“设置 → 账号 → 已配对的设备”中点“添加设备”，显示一个二维码和 12 位配对码，2 分钟有效，只能用一次。
@@ -74,12 +74,10 @@ codiscuss local connect https://你的站点
 - 设备在浏览器里保存一把不可导出的设备密钥，之后打开网站直接可用。网站只认电脑签过名的设备名单，没有能被盗用的账号密码。
 - 每台设备授权 30 天，到期前用通行密钥续期。勾选“临时设备”的只授权 1 天，用于借来的电脑。
 - 新设备只能在电脑前添加，已配对设备不能远程添加。设备丢失时，在其他已配对设备或电脑上撤销它；只有一台外出设备时，回到电脑前撤销并重新配对。
-- 设备列表下的“最近记录”列出电脑记下的配对、撤销、远程可写和远程操作（不含内容）。看到不是你做的操作，立即撤销对应设备。
+- 设备列表下的“最近记录”列出电脑记下的配对、撤销、每日确认和远程操作（不含内容）。看到不是你做的操作，立即撤销对应设备。
 - 清除浏览器数据会删掉设备密钥，需要回到电脑前重新配对。
 
-**远程可写**：房间里有可写（或自动、全放开）成员时，在其他设备上第一次给它发消息或调整它，会先请你用通行密钥确认。确认后，这台设备在这个房间里 12 小时内可以远程操作，可在设备列表中提前撤销。
-- 其他设备新建房间时，成员只能是只读；建好后再在房间里开启可写。
-- 撤销只阻止之后的远程操作，已经在运行的工作和已改动的文件不会因此撤回。
+**每日确认**：每台设备每天第一次打开网页时，用面容、指纹或设备密码确认一次，之后 24 小时内建房、发消息、设置任意权限档（含可写、全放开）都不再询问。配对和续期本身也算一次确认。撤销设备只阻止之后的远程操作，已经在运行的工作和已改动的文件不会因此撤回。
 
 配对后目录“协作房间”直接列出电脑上的房间，与在电脑上看到的一致，可以发消息、上传附件、管理成员、导出备份，并实时更新。对话只保存在电脑上，网站只转交加密内容。
 

package/package.json

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

package/runner/device_auth.mjs

@@ -1,7 +1,7 @@
 /**
  * Which browsers this computer trusts, decided here alone (see .dev/plans/远程访问安全加固/PROTOCOL.md): pairing by a
- * code shown on a trusted screen, a signature on every relayed command, passkeys kept per device, and per-room write
- * grants. The website only forwards; nothing it stores can add a device or a grant.
+ * code shown on a trusted screen, a signature on every relayed command, passkeys kept per device, and a daily unlock
+ * by passkey. The website only forwards; nothing it stores can add a device or unlock one.
  */
 import { createHash, createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { appendFileSync, existsSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
@@ -24,7 +24,8 @@ export const DEVICE_DAYS = 30;
 const TEMPORARY_DAYS = 1;
 // An expired device may still renew itself with its passkey for this long; after that it pairs again.
 const RENEW_GRACE_DAYS = 30;
-export const WRITE_GRANT_MS = 12 * 3600000;
+// A paired device works for this long after its passkey confirms it, then asks again: once a day, not per room.
+export const UNLOCK_MS = 24 * 3600000;
 const PAIRING_MS = 120000;
 const PAIRING_ATTEMPTS = 5;
 const CHALLENGE_MS = 120000;
@@ -36,11 +37,13 @@ const CODE_LENGTH = 12;
 const PAIR_CONTEXT = 'codiscuss-pair-v1';
 // What an expired (not yet removed) device may still ask for: only to renew itself.
 const EXPIRED_ACTIONS = new Set(['passkey-challenge', 'device-renew']);
+// What a locked device may still ask for: only to unlock (or renew) itself with its passkey.
+const LOCKED_ACTIONS = new Set(['passkey-challenge', 'device-unlock', 'device-renew']);
 // The one action an unpaired browser may send, unsigned: proving it holds a pairing code.
 export const UNSIGNED_ACTIONS = new Set(['device-pair']);
 // Device actions answered by this module rather than the launch entrypoint.
 // New devices are added only at this computer's own screen, so no relayed action starts a pairing.
-export const DEVICE_ACTIONS = new Set(['device-pair', 'device-list', 'device-revoke', 'passkey-challenge', 'device-renew', 'write-grant', 'write-revoke']);
+export const DEVICE_ACTIONS = new Set(['device-pair', 'device-list', 'device-revoke', 'passkey-challenge', 'device-renew', 'device-unlock']);
 // Actions after which the website must receive the new signed device list.
 const LIST_CHANGES = new Set(['device-pair', 'device-revoke', 'device-renew']);
 
@@ -58,16 +61,14 @@ function with_lock(home, task) {
   try {
     const file = join(home, DEVICES_FILE);
     const registry = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
-    registry.devices ||= {}; registry.pairings ||= {}; registry.challenges ||= {}; registry.write_grants ||= {};
+    registry.devices ||= {}; registry.pairings ||= {}; registry.challenges ||= {};
+    // Per-room write grants were replaced by the daily unlock.
+    delete registry.write_grants;
     const now = Date.now();
     // Drop what has expired so the file stays small and nothing stale can be used.
     for (const [key, item] of Object.entries(registry.pairings)) if (item.expires_at <= now) delete registry.pairings[key];
     for (const [key, item] of Object.entries(registry.challenges)) if (item.expires_at <= now) delete registry.challenges[key];
     for (const [key, device] of Object.entries(registry.devices)) if (device.expires_at + RENEW_GRACE_DAYS * DAY_MS <= now) delete registry.devices[key];
-    for (const [device, rooms] of Object.entries(registry.write_grants)) {
-      for (const [room, until] of Object.entries(rooms)) if (until <= now || !registry.devices[device]) delete rooms[room];
-      if (!Object.keys(rooms).length) delete registry.write_grants[device];
-    }
     // Saved even when the task refuses: a used challenge or a counted failure must not come back.
     try { return task(registry, now); } finally { atomic_json(file, registry); }
   } finally { rmSync(path, { force: true }); }
@@ -94,7 +95,7 @@ export function recent_audit(home, limit = AUDIT_SHOWN) {
 function read_registry(home) {
   const file = join(home, DEVICES_FILE);
   const registry = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
-  return { devices: registry.devices || {}, write_grants: registry.write_grants || {} };
+  return { devices: registry.devices || {} };
 }
 
 /** The uncompressed P-256 point of a JWK, which names the device. */
@@ -152,7 +153,9 @@ export function start_pairing(home, { site, fingerprint = '', temporary = false,
 function add_device(registry, now, { public_key, label, temporary, by, passkey }) {
   const id = device_id_of(public_key);
   registry.devices[id] = { public_key: { kty: 'EC', crv: 'P-256', x: public_key.x, y: public_key.y }, label: clean_label(label), by,
-    temporary: Boolean(temporary), created_at: now, expires_at: now + (temporary ? TEMPORARY_DAYS : DEVICE_DAYS) * DAY_MS, passkeys: [passkey] };
+    temporary: Boolean(temporary), created_at: now, expires_at: now + (temporary ? TEMPORARY_DAYS : DEVICE_DAYS) * DAY_MS, passkeys: [passkey],
+    // Pairing itself was confirmed with the passkey, so the device starts unlocked.
+    unlocked_until: Math.min(now + UNLOCK_MS, now + (temporary ? TEMPORARY_DAYS : DEVICE_DAYS) * DAY_MS) };
   return { device_id: id, expires_at: registry.devices[id].expires_at, temporary: Boolean(temporary) };
 }
 
@@ -206,20 +209,12 @@ export async function open_signed_request(home, id, sealed, machine_id) {
   if (device.expires_at <= Date.now() && !EXPIRED_ACTIONS.has(request.action)) {
     throw Object.assign(new Error(device.temporary ? '临时设备授权已到期，请重新配对' : '设备授权已到期，请用通行密钥续期'), { need: device.temporary ? 'pairing' : 'renew' });
   }
+  if (!(device.unlocked_until > Date.now()) && !LOCKED_ACTIONS.has(request.action)) {
+    throw Object.assign(new Error('请用通行密钥确认这台设备（每天一次）'), { need: 'unlock' });
+  }
   return { request, device_id: sealed.device_id };
 }
 
-/** Whether a device holds a live write grant for a room. */
-export function write_allowed(home, device_id, room_id, now = Date.now()) {
-  const until = read_registry(home).write_grants[device_id]?.[room_id];
-  return Boolean(until && until > now);
-}
-
-/** The error that asks the page to confirm remote writing with a passkey, then retry. */
-export function write_needed(room_id) {
-  return Object.assign(new Error('这个房间的成员可以改动电脑上的文件；远程操作前需要用通行密钥确认（12 小时有效）'), { need: 'write-grant', room_id });
-}
-
 /**
  * The device list this computer signs for the website: each device's public key and expiry, nothing else. The website
  * checks requests against it and cannot add a device of its own.
@@ -235,10 +230,10 @@ export async function signed_device_list(home, link, now = Date.now()) {
 
 /** List paired devices with their passkeys and write grants, newest first, and the recent audit entries. */
 export function list_devices(home, current = null) {
-  const { devices, write_grants } = read_registry(home);
+  const { devices } = read_registry(home);
   return { audit: recent_audit(home), devices: Object.entries(devices).map(([id, device]) => ({ id, label: device.label, temporary: device.temporary, created_at: device.created_at,
     expires_at: device.expires_at, passkeys: device.passkeys.length, current: id === current,
-    write_rooms: Object.entries(write_grants[id] || {}).map(([room, until]) => ({ room_id: room, until })) }))
+    unlocked_until: device.unlocked_until || 0 }))
     .sort((left, right) => right.created_at - left.created_at) };
 }
 
@@ -251,20 +246,10 @@ export function revoke_device(home, device_id) {
   return with_lock(home, registry => {
     const passkeys = (registry.devices[device_id]?.passkeys || []).map(passkey => passkey.id);
     delete registry.devices[device_id];
-    delete registry.write_grants[device_id];
     return { ok: true, passkeys };
   });
 }
 
-/** End one device's write grant for one room before it runs out. */
-export function revoke_write(home, device_id, room_id) {
-  audit(home, { event: 'write.revoked', device: device_id, room: room_id });
-  return with_lock(home, registry => {
-    if (registry.write_grants[device_id]) delete registry.write_grants[device_id][room_id];
-    return { ok: true };
-  });
-}
-
 /** The relying party of a site: its exact origin and host name. */
 function relying_party(site) {
   const url = new URL(site);
@@ -276,8 +261,7 @@ function relying_party(site) {
  * other purposes return request options listing only this device's passkeys.
  */
 export function passkey_options(home, device_id, site, { purpose, room_id }) {
-  if (!['write', 'renew'].includes(purpose)) throw new Error('通行密钥用途无效');
-  if (purpose === 'write' && (typeof room_id !== 'string' || !room_id)) throw new Error('须指定要开启可写的房间');
+  if (!['unlock', 'renew'].includes(purpose)) throw new Error('通行密钥用途无效');
   const { rp_id } = relying_party(site);
   return with_lock(home, (registry, now) => {
     const device = registry.devices[device_id];
@@ -321,13 +305,12 @@ async function check_assertion(home, device_id, site, { challenge_id, assertion
   });
 }
 
-/** Grant this device remote writing in one room for twelve hours, never past the device's own expiry. */
-export async function grant_write(home, device_id, site, { challenge_id, assertion, room_id }) {
-  return check_assertion(home, device_id, site, { challenge_id, assertion }, 'write', room_id, (device, registry, now) => {
-    const until = Math.min(now + WRITE_GRANT_MS, device.expires_at);
-    (registry.write_grants[device_id] ||= {})[room_id] = until;
-    audit(home, { event: 'write.granted', device: device_id, room: room_id, until });
-    return { room_id, until };
+/** Unlock this device for a day after its passkey confirms, never past the device's own expiry. */
+export async function unlock_device(home, device_id, site, { challenge_id, assertion }) {
+  return check_assertion(home, device_id, site, { challenge_id, assertion }, 'unlock', null, (device, registry, now) => {
+    device.unlocked_until = Math.min(now + UNLOCK_MS, device.expires_at);
+    audit(home, { event: 'device.unlocked', device: device_id, until: device.unlocked_until });
+    return { unlocked_until: device.unlocked_until };
   });
 }
 
@@ -336,6 +319,7 @@ export async function renew_device(home, device_id, site, { challenge_id, assert
   return check_assertion(home, device_id, site, { challenge_id, assertion }, 'renew', null, device => {
     if (device.temporary) throw new Error('这台设备不能续期，请重新配对');
     device.expires_at = Date.now() + DEVICE_DAYS * DAY_MS;
+    device.unlocked_until = Date.now() + UNLOCK_MS;
     audit(home, { event: 'device.renewed', device: device_id });
     return { expires_at: device.expires_at };
   });
@@ -350,10 +334,9 @@ export async function device_command(home, { site, machine_id, device_id, on_cha
     const body = action === 'device-pair' ? pair_device(home, machine_id, site, payload)
       : action === 'device-list' ? list_devices(home, device_id)
       : action === 'device-revoke' ? revoke_device(home, String(payload.device_id || ''))
-      : action === 'write-revoke' ? revoke_write(home, String(payload.device_id || device_id), String(payload.room_id || ''))
       : action === 'passkey-challenge' ? passkey_options(home, device_id, site, payload)
       : action === 'device-renew' ? await renew_device(home, device_id, site, payload)
-      : action === 'write-grant' ? await grant_write(home, device_id, site, payload)
+      : action === 'device-unlock' ? await unlock_device(home, device_id, site, payload)
       : null;
     if (!body) return { status: 404, body: { error: '未知的设备操作' } };
     // The website accepts a device only from this computer's signed list, so a change is sent at once.

package/runner/discussion_launch.mjs

@@ -12,7 +12,7 @@ import { parseArgs } from 'node:util';
 import { atomic_json } from './files.mjs';
 import { read_project_files } from './project_files.mjs';
 import { guard_remote_request, list_remote_directories } from './remote_policy.mjs';
-import { list_devices, machine_fingerprint, revoke_device, revoke_write, start_pairing, write_allowed, write_needed } from './device_auth.mjs';
+import { list_devices, machine_fingerprint, revoke_device, start_pairing } from './device_auth.mjs';
 import { setup_sidecar } from './adapters/antigravity_app.mjs';
 import { adapter_of, adoption_adapter, BRANCHABLE_ADAPTERS, branch_session, session_settings, software_defaults, software_effort, software_models } from './adapters/index.mjs';
 import { ADAPTER_IDS, ADAPTER_PROFILES, adapter_profile, platform_adapters, same_session_family } from './adapters/profiles.mjs';
@@ -100,7 +100,7 @@ stt 按序接收录音片段（upload_id、index、base64 PCM 16 kHz 单声道
 pick-directory 在本机弹出系统目录选择窗口，返回所选路径；取消时不返回路径。
 browse-directory 列出常用项目及其中的子文件夹（只含文件夹名，分页），供其他设备选择目录；path 为空时列出常用项目。
 device-pairing 在本机生成 12 位设备配对码（2 分钟有效，可选 temporary 临时设备、site 指定已绑定的网站），扫码链接带本机密钥指纹；只能在这台电脑上执行，新设备只能在电脑前添加。
-devices 列出已配对设备；提供 revoke（设备 id）撤销设备，或 revoke_write（device_id、room_id）撤销远程可写授权。
+devices 列出已配对设备；提供 revoke（设备 id）撤销设备。
 projects 读取本机已配置的项目（名称与绝对路径）；提供 JSON（projects 列表）时整体替换保存。
 presets 读取本机的专家预设（含未删除的内置预设）与各平台默认描述；提供 JSON（presets 列表、description_templates 和/或 hidden_builtins 已删除的内置预设名）时替换对应部分。
 machine-link 返回本机连接指定 site 的电脑编号、名称与凭据，供已登录管理员的网页完成配对；不存在时创建。
@@ -1541,42 +1541,6 @@ function room_config_by_id(home, room_id) {
   return paths.length === 1 ? configuration_snapshot(paths[0]).config : null;
 }
 
-/** Whether a member may change files here: its own level, else the room's, or any tool approved for it. */
-const member_writes = (config, profile) => WRITING_ACCESS.has(profile?.project_access || config?.project_access) || profile?.allowed_tools?.length > 0;
-
-/**
- * The room in which a relayed command would put a member with write access to work, judged from what this computer
- * keeps rather than from the request text; null when it would not. Such a command needs the device's write grant.
- */
-export function remote_write_room(home, command, input) {
-  if (!input || typeof input !== 'object') return null;
-  // Approving a tool widens what a member can do, whatever its level: it always needs the grant.
-  if (command === 'room-member-allow') return input.room_id || null;
-  if (command === 'room-member') {
-    const config = room_config_by_id(home, input.room_id);
-    return config && member_writes(config, config.participants?.[input.name]) ? input.room_id : null;
-  }
-  if (command === 'room-fork') {
-    const config = room_config_by_id(home, input.source_room_id);
-    return config && Object.values(config.participants || {}).some(profile => member_writes(config, profile)) ? input.source_room_id : null;
-  }
-  if (command === 'room-workflow') {
-    if (input.action === 'host') throw new Error('“允许主持人自建工作流”只能在电脑上开启');
-    if (input.action === 'enable') {
-      const cards = JSON.stringify(get_workflow(home, input.workflow?.id));
-      return /"(project_access|requested_access)":"(write|auto|full)"/.test(cards) ? input.room_id : null;
-    }
-    if (input.action === 'back') {
-      const config = room_config_by_id(home, input.room_id);
-      return config && Object.values(config.participants || {}).some(profile => member_writes(config, profile)) ? input.room_id : null;
-    }
-  }
-  if (command === 'start' && input.workflow?.id && /"(project_access|requested_access)":"(write|auto|full)"/.test(JSON.stringify(get_workflow(home, input.workflow.id)))) {
-    throw new Error('其他设备新建房间时成员须为只读；建好后在房间里开启可写（需通行密钥确认）');
-  }
-  return null;
-}
-
 /** Fill program locations another device left out with the ones saved here, so saving defaults cannot drop them. */
 function keep_saved_locations(home, participants) {
   const saved = launch_settings(home).participants;
@@ -1608,14 +1572,11 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
   assert_shared_home(home);
   // Another device's request may only use what this computer granted; the flag is set by the relay, never by the request.
   if (values.remote) {
-    const allowed = room => Boolean(values.device) && write_allowed(home, values.device, room);
-    guard_remote_request(positionals[0], input, { projects: launch_projects(home).projects, participants: launch_settings(home).participants, home,
-      write_allowed: allowed, write_needed });
-    const room = remote_write_room(home, positionals[0], input);
-    if (room && !allowed(room)) throw write_needed(room);
+    guard_remote_request(positionals[0], input, { projects: launch_projects(home).projects, participants: launch_settings(home).participants, home });
+    if (positionals[0] === 'room-workflow' && input?.action === 'host') throw new Error('“允许主持人自建工作流”只能在电脑上开启');
     // Another device repeats the saved program locations it cannot see; keep them rather than dropping them.
     if (positionals[0] === 'settings' && input?.participants) input.participants = keep_saved_locations(home, input.participants);
-    // A room created from another device starts read-only, so its members do not take the tool approvals saved here.
+    // Tool approvals saved here stay this computer's decision; a room created from another device does not take them.
     if (positionals[0] === 'start' && input) input.without_saved_tools = true;
   }
   let result;
@@ -1658,13 +1619,14 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
     result = start_pairing(home, { site, fingerprint: machine_fingerprint(link), temporary: input?.temporary === true });
   }
   else if (positionals[0] === 'devices' && !values.remote) {
-    result = input?.revoke ? revoke_device(home, String(input.revoke))
-      : input?.revoke_write ? revoke_write(home, String(input.revoke_write.device_id), String(input.revoke_write.room_id)) : list_devices(home);
+    result = input?.revoke ? revoke_device(home, String(input.revoke)) : list_devices(home);
     // The website takes devices only from the list this computer signs, so a revocation is sent at once.
     if (input?.revoke) await (await import('./remote_launch.mjs')).sync_remote_launches(home).catch(() => {});
   }
   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] === '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);
   process.stdout.write(`${JSON.stringify(result)}\n`);

package/runner/relay_channel.mjs

@@ -14,7 +14,7 @@ import { acquire_lock } from './discussion_runner.mjs';
 import { local_settings } from './discussion_setup.mjs';
 import { machine_links, relay_cipher, save_machine_links, relayed_command, ROOM_ACTIONS, run_launch_command, sync_remote_launches, unseal } from './remote_launch.mjs';
 import { claim_relayed_command } from './remote_policy.mjs';
-import { audit, DEVICE_ACTIONS, device_command, open_signed_request, write_allowed, write_needed } from './device_auth.mjs';
+import { audit, DEVICE_ACTIONS, device_command, open_signed_request } from './device_auth.mjs';
 
 const RELAY_PROTOCOL = 'codiscuss-relay';
 const BRIDGE_TOKEN_BYTES = 32;
@@ -31,9 +31,6 @@ const HEARTBEAT_LATE_MS = 2 * PING_MS + 5000;
 // A WebSocket frame on the website is at most 1 MiB; leave room for the envelope around the ciphertext.
 const RESPONSE_MAX_BYTES = 700 * 1024;
 const ROOM_API_PATH = /^\/api\/(rooms|folders|revisions)(\/[A-Za-z0-9_.~-]+)*(\?[A-Za-z0-9_.~%=&,:+-]*)?$/;
-const WRITE_ROOM_PATH = /^\/api\/rooms\/([A-Za-z0-9_.~-]+)\//;
-// Members with these levels can change files or run commands on this computer.
-const WRITING_ACCESS = new Set(['write', 'auto', 'full', 'own']);
 // Attachment uploads arrive in parts and are sent to the local website whole, as one browser upload would be.
 const UPLOAD_PATH = /^\/api\/rooms\/[A-Za-z0-9_-]+\/attachments(\/[A-Za-z0-9_-]+\/import)?(\?[A-Za-z0-9_.~%=&,:+-]*)?$/;
 const UPLOAD_MAX_BYTES = 20 * 1024 * 1024;
@@ -81,12 +78,6 @@ export async function room_api(home, site, payload, { fetcher = fetch, device }
       || !Number.isSafeInteger(offset) || offset < 0) {
     return { status: 400, body: { error: '中转请求地址无效' } };
   }
-  // Writing to a room whose members may change files here needs this device's passkey-confirmed grant; stopping does not.
-  const room = method === 'POST' ? path.match(WRITE_ROOM_PATH)?.[1] : null;
-  if (device !== undefined && room && !/\/(interrupt|stop)(\?|$)/.test(path) && room_writes(home, room) && !write_allowed(home, device, room)) {
-    const needed = write_needed(room);
-    return { status: 403, body: { error: needed.message, need: needed.need, room_id: room } };
-  }
   const headers = bridge_headers(home, site);
   if (typeof token === 'string' && token) headers['X-Discussion-Token'] = token;
   if (body !== undefined) headers['Content-Type'] = 'application/json';
@@ -100,22 +91,6 @@ export async function room_api(home, site, payload, { fetcher = fetch, device }
     body_base64: bytes.subarray(offset, offset + RESPONSE_MAX_BYTES).toString('base64') };
 }
 
-/** Whether a room this computer runs has a member allowed to change files or run commands. */
-function room_writes(home, room_id) {
-  const path = join(home, 'rooms.json');
-  const configs = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')).configs ?? [] : [];
-  for (const config_path of configs) {
-    try {
-      const config = JSON.parse(readFileSync(config_path, 'utf8'));
-      // A member without its own level takes the room's, as the runner does when it starts the member.
-      // Approved tools count too: a shell approved for a read-only member still changes files.
-      if (config.room === room_id) return Object.values(config.participants || {}).some(profile =>
-        WRITING_ACCESS.has(profile?.project_access || config.project_access) || profile?.allowed_tools?.length > 0);
-    } catch { /* A broken configuration starts nothing. */ }
-  }
-  return false;
-}
-
 /** The local website this computer runs. */
 function local_origin(home) {
   return `http://127.0.0.1:${local_settings(home).port || 8765}`;

package/runner/remote_policy.mjs

@@ -77,31 +77,23 @@ function walk(value, visit) {
 
 /**
  * Refuse a relayed request that would reach past what this computer granted: a folder outside the saved projects,
- * a program location not already saved here, full access, or write access to a room without this device's
- * passkey-confirmed grant (`write_allowed(room_id)`).
+ * a program location not already saved here, or 全放开 saved as a default. A device reaches this point only unlocked
+ * by its passkey that day, so a room may be given any level.
  */
-export function guard_remote_request(command, input, { projects, participants, home, write_allowed = () => false, write_needed }) {
+export function guard_remote_request(command, input, { projects, participants, home }) {
   if (LOCAL_ONLY_ACTIONS.has(command)) throw new Error('此操作只能在这台电脑上执行');
   if (!input || typeof input !== 'object') return;
   const roots = remote_roots(projects);
   const saved = Object.values(participants || {});
   const known = Object.fromEntries(SOFTWARE_FIELDS.map(field => [field, new Set(saved.map(profile => profile[field]).filter(Boolean))]));
-  let writes = false;
   walk(input, (key, value) => {
     if (key === 'cwd' && value) remote_directory(value, { roots, home });
     else if (SOFTWARE_FIELDS.includes(key) && value && !known[key].has(value)) throw new Error(`其他设备不能更改软件位置（${key}），请在电脑上设置`);
-    else if (key === 'project_access' && value === 'full') throw new Error('“全放开”只能在电脑上设置');
+    // 全放开 may be given to a room's member; it never becomes a saved default from afar.
+    else if (key === 'project_access' && value === 'full' && !WRITE_COMMANDS.has(command)) throw new Error('“全放开”不能从其他设备存为默认设置');
     // `own` comes only from taking over a session on this computer; it may write, so another device cannot claim it.
     else if (key === 'project_access' && value === 'own') throw new Error('沿用原会话权限（own）只能在电脑上接管会话时产生');
-    else if (key === 'project_access' && ['write', 'auto'].includes(value)) writes = true;
-    // An approved tool such as a shell can change files whatever the member's level says.
-    else if (key === 'allowed_tools' && Array.isArray(value) && value.length) writes = true;
   });
-  // Saved presets and workflow cards only describe access; it takes effect in a room, which is checked here.
-  if (writes && WRITE_COMMANDS.has(command)) {
-    if (command === 'start' || typeof input.room_id !== 'string') throw new Error('其他设备新建房间时成员须为只读；建好后在房间里开启可写（需通行密钥确认）');
-    if (!write_allowed(input.room_id)) throw write_needed(input.room_id);
-  }
   // A saved project only widens what other devices reach, so a new or moved one must already lie inside the old ones.
   if (command === 'projects' && Array.isArray(input.projects)) {
     const existing = new Map((projects || []).map(project => [project.id, project.path]));

package/web/app.js

@@ -53,7 +53,7 @@ const RELAY_PING_MS = 25000;
 const ROOM_RELAY_PATH = /^\/api\/(rooms|folders|revisions)(\/|\?|$)/;
 // One part of a file sent to the computer stays well inside the relay's 1 MiB frame once encoded and encrypted.
 const RELAY_UPLOAD_PART_BYTES = 384 * 1024;
-const COMPUTER_UNREACHABLE = "电脑未连接：请登录管理员，并确认电脑开机且运行 codiscuss";
+const COMPUTER_UNREACHABLE = "电脑未连接：请先与电脑配对，并确认电脑开机且运行 codiscuss";
 let local_connection = null;
 let computer_connecting = false;
 let relay_machine = null;
@@ -2115,6 +2115,8 @@ function restore_local_connection() {
 async function local_launch_request(action, payload) {
   // A website without rooms of its own reaches the computer only through the relay; pairing itself still needs the local bridge.
   if (relay_machine && (!local_connection || computer_rooms_only() && action !== "machine-link")) return relay_command(action, payload);
+  // Only the computer's own page has a local service at this address; elsewhere the computer is reached through the relay alone.
+  if (!local_connection && !["127.0.0.1", "localhost"].includes(location.hostname)) throw Object.assign(new Error(COMPUTER_UNREACHABLE), { preflight: true });
   const headers = { "Content-Type": "application/json", "X-CoDiscuss-Local": "1" };
   if (local_connection) headers["X-CoDiscuss-Connection"] = local_connection.token;
   let response;
@@ -2248,7 +2250,6 @@ async function device_request(action, payload = {}) {
   if (relay_machine && !state.admin.local) return relay_command(action, payload);
   if (action === "device-list") return local_launch_request("devices", {});
   if (action === "device-revoke") return local_launch_request("devices", { revoke: payload.device_id });
-  if (action === "write-revoke") return local_launch_request("devices", { revoke_write: payload });
   throw new Error("请在已配对的设备上操作");
 }
 
@@ -2347,16 +2348,17 @@ async function invite_device(temporary) {
   return local_launch_request("device-pairing", { temporary });
 }
 
-/** Confirm remote writing in one room with this device's passkey; the computer grants twelve hours. */
-async function confirm_write_grant(room_id) {
-  const options = await relay_command("passkey-challenge", { purpose: "write", room_id });
-  return passkey_prompt({ title: "确认远程可写", description: "这个房间的成员可以改动电脑上的文件或运行命令。确认后，这台设备 12 小时内可以在本房间远程操作；可随时在 设置 → 账号 中撤销。",
-    confirm_label: "用通行密钥确认",
-    run: async () => {
-      const result = await relay_command("write-grant", { challenge_id: options.challenge_id, assertion: await passkey_assertion(options), room_id });
-      notify("info", "已开启远程可写，12 小时内有效");
-      return result;
-    } });
+// Requests made together while the device is locked share one confirmation.
+let unlocking = null;
+
+/** Unlock this device for a day with its passkey; the computer asks once a day, on the first request. */
+function unlock_this_device() {
+  unlocking ||= (async () => {
+    const options = await relay_command("passkey-challenge", { purpose: "unlock" });
+    return passkey_prompt({ title: "确认是你", description: "用面容、指纹或设备密码确认后，这台设备 24 小时内可以操作电脑上的房间。", confirm_label: "确认",
+      run: async () => relay_command("device-unlock", { challenge_id: options.challenge_id, assertion: await passkey_assertion(options) }) });
+  })().finally(() => { unlocking = null; });
+  return unlocking;
 }
 
 /** Extend this device's trust by thirty days with its passkey. */
@@ -2371,12 +2373,12 @@ async function renew_this_device() {
 }
 
 /**
- * React to what the computer asked for: pair or renew this device (shown in settings), or confirm writing in a room
- * and run the request once more. Returns true when the request should be retried.
+ * React to what the computer asked for: pair or renew this device (shown in settings), or unlock it for the day and
+ * run the request once more. Returns true when the request should be retried.
  */
 async function meet_device_need(error) {
-  if (error.need === "write-grant" && error.room_id) {
-    await confirm_write_grant(error.room_id);
+  if (error.need === "unlock") {
+    await unlock_this_device();
     return true;
   }
   if (error.need === "pairing" && state.admin.devices) forget_pairing();
@@ -2781,7 +2783,6 @@ async function load_launch_settings() {
   state.launch.connect_command = local ? "codiscuss local open" : `codiscuss local connect "${location.origin}"`;
   try {
     local_connection = null;
-    relay_machine = null;
     take_pairing_code();
     local_connection = restore_local_connection();
     state.launch.remote = Boolean(local_connection);
@@ -2790,8 +2791,9 @@ async function load_launch_settings() {
       // Pair first, so the computer this page runs on can then be reached through the relay like any other device.
       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.
-      if (!state.launch.relay?.online || !state.launch.relay.public_key) return;
-      relay_machine = state.launch.relay;
+      // 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;
+      if (!relay_machine) return;
       state.launch.remote = true;
     }
     const settings = await local_launch_request("settings");
@@ -4700,7 +4702,7 @@ window.discuss_view = { snapshot: view_snapshot, write_field: write_view_field,
   admin: { register: register_admin, login: login_admin, logout: logout_admin,
     update_profile: update_admin_profile, avatar_from_file: admin_avatar_from_file, validate: validate_admin_form,
     sessions: admin_sessions, revoke: revoke_admin_sessions, change_password: change_admin_password },
-  device: { request: device_request, pair: pair_this_device, take_scanned: take_scanned_pairing, invite: invite_device, renew: renew_this_device, confirm_write: confirm_write_grant, forget: forget_pairing,
+  device: { request: device_request, pair: pair_this_device, take_scanned: take_scanned_pairing, invite: invite_device, renew: renew_this_device, forget: forget_pairing,
     label: device_label, prompt_confirm: () => state.device.prompt?.run(), prompt_cancel: () => state.device.prompt?.cancel() },
   request: request_json, rewind_plan, identities: IDENTITIES, display_name, mention_handles, mentioned_members, render_room_markdown, sources: SOURCE_LABELS,
   set_member_access, set_member_model, allow_denials, set_member_adapter, reload_room_models, read_room_files, limits_label, stop_reason_label, participant_model, participant_files, participant_session_hint, participant_access,