@walkhi/code-relax 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/shared/p2p-ice-policy.cjs

@@ -0,0 +1,22 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxIcePolicy = factory();
+})(globalThis, () => {
+  const directType = type => ['host', 'srflx', 'prflx'].includes(type);
+  const candidate = value => {
+    if (typeof value !== 'string' || value.length > 2048 || /[\r\n]/.test(value)) return false;
+    const fields = value.trim().split(/\s+/);
+    return /^(?:a=)?candidate:/.test(fields[0]) && fields[6] === 'typ' && directType(fields[7]);
+  };
+  return {
+    directType, candidate,
+    servers: values => Array.isArray(values) && values.length <= 4 && values.every(value => {
+      if (typeof value !== 'string' || !/^stun:[a-zA-Z0-9.-]+:[0-9]{1,5}$/.test(value)) return false;
+      const port = Number(value.split(':').at(-1));
+      return port > 0 && port <= 65535;
+    }),
+    sdp: value => typeof value === 'string' && value.length <= 65536 &&
+      value.split(/\r?\n/).filter(line => line.startsWith('a=candidate:')).every(candidate),
+    pair: (localType, remoteType) => directType(localType) && directType(remoteType),
+  };
+});

package/dist/shared/plan-pricing.cjs

@@ -0,0 +1,32 @@
+(function (root, factory) {
+  const pricing = factory();
+  if (typeof module === 'object' && module.exports) module.exports = pricing;
+  else root.CodeRelaxPlanPricing = pricing;
+})(globalThis, function () {
+  // Desktop 26.1007.2314.0: usage plan row reads checkout prices, not invoices.
+  async function read(accountId, get) {
+    const response = await get('/accounts/check/v4-2023-04-27');
+    const account = response?.accounts?.[accountId];
+    if (!account || account.account?.is_deactivated || account.can_access_with_session === false) return null;
+    const plan = account.account?.plan_type;
+    if (!['free', 'go', 'plus', 'prolite', 'pro', 'promax'].includes(plan)) return null;
+    const trial = account.last_active_subscription?.purchase_origin_platform === 'chatgpt_no_payment_trial';
+    const billingCurrency = trial ? null : account.entitlement?.billing_currency;
+    const selector = billingCurrency || 'US';
+    if (!/^[A-Za-z]{2,3}$/.test(selector)) return null;
+    const config = (await get(`/checkout_pricing_config/configs/${encodeURIComponent(selector)}`))?.currency_config;
+    const amount = config?.[plan]?.month?.amount;
+    const currency = config?.symbol_code;
+    if (typeof amount !== 'number' || !Number.isFinite(amount) || amount < 0 || !/^[A-Z]{3}$/.test(currency || '')) return null;
+    if (billingCurrency && currency !== billingCurrency.toUpperCase()) return null;
+    return { accountId, plan, amount, currency, minorUnitExponent: config.minor_unit_exponent ?? null };
+  }
+  function format(value) {
+    if (!value) return '';
+    const digits = Number.isInteger(value.minorUnitExponent) && value.minorUnitExponent >= 0 && value.minorUnitExponent <= 4
+      ? value.minorUnitExponent : undefined;
+    return new Intl.NumberFormat('zh-CN', { style: 'currency', currency: value.currency, currencyDisplay: 'code',
+      minimumFractionDigits: 0, maximumFractionDigits: digits }).format(value.amount);
+  }
+  return { read, format };
+});

package/dist/shared/question-attention.cjs

@@ -0,0 +1,100 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexQuestionAttention = factory();
+})(globalThis, function () {
+  function parseQuestionReply(text) {
+    const match = /^\s*<send_user_message_question_reply>\s*([\s\S]*?)\s*<\/send_user_message_question_reply>\s*$/.exec(text);
+    if (!match) return null;
+    let replies;
+    try { replies = JSON.parse(match[1]); } catch { return null; }
+    if (!Array.isArray(replies) || !replies.length || !replies.every(reply =>
+      reply && typeof reply.question === 'string' && typeof reply.answer === 'string')) return null;
+    return replies;
+  }
+
+  function questionIds(item) {
+    if (!item?.id || item.delivery !== 'async') return [];
+    return item.questions?.length
+      ? item.questions.map((_, index) => JSON.stringify(['request_user_input_async', item.id, index])) : [item.id];
+  }
+
+  // Only identities cross the catalog event channel, never question/answer bodies.
+  function fromNotification(method, params) {
+    const turnId = params.turnId || params.turn?.id;
+    if (!params.threadId || !turnId) return null;
+    if (method === 'turn/completed') return { turnId, completed: true };
+    if (method !== 'item/completed') return null;
+    const item = params.item;
+    if (item?.type === 'agentMessage') {
+      const questions = questionIds(item);
+      return questions.length ? { turnId, questions } : null;
+    }
+    if (item?.type === 'userMessage') {
+      const text = (item.content || []).filter(part => part.type === 'text').map(part => part.text).join('\n');
+      const answered = (parseQuestionReply(text) || []).map(reply => reply.questionItemId).filter(id => typeof id === 'string');
+      return answered.length ? { turnId, answered } : null;
+    }
+    return null;
+  }
+  // A successful submission can precede model consumption. Keep its answer for
+  // display across page recreation, never as a replayable send request.
+  function createAnswerStore({ storage, scope, onError }) {
+    const records = new Map();
+    const previews = new Map();
+    const key = thread => 'codexRemoteAnsweredQuestions:' + JSON.stringify([
+      scope(), thread.hostId || 'local', thread.id,
+    ]);
+    function read(owner) {
+      if (!records.has(owner)) {
+        try {
+          const ids = JSON.parse(storage.getItem(owner) || '[]');
+          records.set(owner, new Set(Array.isArray(ids) ? ids.filter(id => typeof id === 'string') : []));
+        } catch (error) { records.set(owner, new Set()); onError?.(error); }
+      }
+      return records.get(owner);
+    }
+    function remember(owner, ids) {
+      const answered = read(owner);
+      let changed = false;
+      for (const id of ids) if (typeof id === 'string' && !answered.has(id)) {
+        answered.add(id); changed = true;
+      }
+      if (changed) {
+        try { storage.setItem(owner, JSON.stringify([...answered])); }
+        catch (error) { onError?.(error); }
+      }
+    }
+    function readPreviews(owner) {
+      if (!previews.has(owner)) {
+        try {
+          const values = JSON.parse(storage.getItem(owner + ':replies') || '[]');
+          previews.set(owner, new Map(Array.isArray(values) ? values.filter(value =>
+            Array.isArray(value) && typeof value[0] === 'string' && typeof value[1] === 'string') : []));
+        } catch (error) { previews.set(owner, new Map()); onError?.(error); }
+      }
+      return previews.get(owner);
+    }
+    function savePreviews(owner) {
+      try {
+        const values = [...readPreviews(owner)];
+        if (values.length) storage.setItem(owner + ':replies', JSON.stringify(values));
+        else storage.removeItem(owner + ':replies');
+      } catch (error) { onError?.(error); }
+    }
+    function submitted(owner, replies) {
+      const values = readPreviews(owner);
+      for (const reply of replies) values.set(reply.questionItemId, reply.answer);
+      savePreviews(owner);
+      remember(owner, replies.map(reply => reply.questionItemId));
+    }
+    function reconcile(thread, ids) {
+      const owner = key(thread), values = readPreviews(owner);
+      let changed = false;
+      for (const id of ids) if (values.delete(id)) changed = true;
+      if (changed) savePreviews(owner);
+    }
+    return { key, has: (thread, id) => read(key(thread)).has(id), remember, submitted, reconcile,
+      answer: (thread, id) => readPreviews(key(thread)).get(id) };
+  }
+  return { parseQuestionReply, questionIds, fromNotification, createAnswerStore };
+});

package/dist/shared/release-version.cjs

@@ -0,0 +1,31 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  else root.CodeRelaxReleaseVersion = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  function parse(value) {
+    if (typeof value !== 'string') return null;
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(value);
+    if (!match) return null;
+    const core = match.slice(1, 4).map(Number), pre = match[4]?.split('.') || [];
+    if (core.some(part => !Number.isSafeInteger(part)) || pre.some(part => /^\d+$/.test(part) && (part.length > 1 && part[0] === '0' || !Number.isSafeInteger(Number(part))))) return null;
+    return { core, pre };
+  }
+  function compare(a, b) {
+    const left = parse(a), right = parse(b);
+    if (!left || !right) return null;
+    for (let i = 0; i < 3; i++) if (left.core[i] !== right.core[i]) return left.core[i] > right.core[i] ? 1 : -1;
+    if (!left.pre.length || !right.pre.length) return left.pre.length === right.pre.length ? 0 : left.pre.length ? -1 : 1;
+    for (let i = 0; i < Math.max(left.pre.length, right.pre.length); i++) {
+      const x = left.pre[i], y = right.pre[i];
+      if (x === y) continue;
+      if (x === undefined || y === undefined) return x === undefined ? -1 : 1;
+      const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
+      if (nx && ny) return Number(x) > Number(y) ? 1 : -1;
+      if (nx !== ny) return nx ? -1 : 1;
+      return x > y ? 1 : -1;
+    }
+    return 0;
+  }
+  return { compare };
+});

package/dist/shared/server-requests.cjs

@@ -1,67 +1,347 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory();
-  else root.CodexServerRequests = factory();
-})(globalThis, function () {
-  const command = 'item/commandExecution/requestApproval';
-  const file = 'item/fileChange/requestApproval';
-  const input = 'item/tool/requestUserInput';
-  const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-  function decisions(request) {
-    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
-    if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
-    return [];
-  }
-  function validate(request, result) {
-    if ([command, file].includes(request.method)) {
-      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
-      return;
-    }
-    if (request.method === input) {
-      const questions = request.params.questions || [];
-      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
-        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
-      return;
-    }
-    throw new Error('此类请求需在工作站处理');
-  }
-  class Store {
-    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
-    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
-    receive(message) {
-      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
-      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
-      this.requests.set(message.id, request); this.changed(request.params.threadId);
-    }
-    notification(method, params) {
-      if (method === 'serverRequest/resolved') {
-        const request = this.requests.get(params.requestId);
-        if (request?.params.threadId === params.threadId) { this.requests.delete(params.requestId); this.changed(params.threadId); }
-      } else if (method === 'turn/completed' || method === 'thread/closed') {
-        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) this.requests.delete(id);
-        this.changed(params.threadId);
-      }
-    }
-    forget(threadId) {
-      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
-      this.changed(threadId);
-    }
-    reset(epoch) {
-      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
-      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
-    }
-    async respond(threadId, { id, epoch, result }, send) {
-      const request = this.requests.get(id);
-      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
-      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
-      validate(request, result);
-      request.status = 'submitted'; this.changed(threadId);
-      try { await send({ id: request.id, result }); }
-      catch (error) {
-        if (this.requests.get(id) === request) { request.status = 'unknown'; this.changed(threadId); }
-        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
-      }
-      return { submitted: true };
-    }
-  }
-  return { Store, decisions, validate, command, file, input };
-});
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexServerRequests = factory();
+})(globalThis, function () {
+  const command = 'item/commandExecution/requestApproval';
+  const file = 'item/fileChange/requestApproval';
+  const input = 'item/tool/requestUserInput';
+  const elicitation = 'mcpServer/elicitation/request';
+  const permissions = 'item/permissions/requestApproval';
+  const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const approvalId = request => 'approval:' + (request.params.turnId || '') + ':' + typeof request.id + ':' + request.id;
+  function confirmation(request) {
+    const p = request.params || {}, value = p._meta?.['openai/confirmation'], schema = p.requestedSchema;
+    if (request.method !== elicitation || p.mode !== 'form' || value?.version !== 1
+      || typeof value.field !== 'string' || schema?.type !== 'object'
+      || Object.keys(schema.properties || {}).length !== 1 || schema.properties[value.field]?.type !== 'boolean'
+      || schema.required?.length !== 1 || schema.required[0] !== value.field) return null;
+    return value;
+  }
+  function confirmationResult(request, decision) {
+    return { action: decision, content: decision === 'accept' ? { [confirmation(request).field]: true } : null, _meta: null };
+  }
+  function browserAccess(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.tool_name !== 'access_browser_origin'
+      || meta.codex_approval_kind !== 'mcp_tool_call' || meta.codex_request_type !== 'approval_request'
+      || meta.codex_sensitive_action !== true || p.requestedSchema?.type !== 'object'
+      || Object.keys(p.requestedSchema.properties || {}).length) return null;
+    try {
+      const origin = new URL(meta.origin);
+      if (!['http:', 'https:'].includes(origin.protocol) || origin.origin !== meta.origin) return null;
+      return { origin: meta.origin, persistent: meta.persist === 'always' };
+    } catch { return null; }
+  }
+  function browserAction(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (browserAccess(request) || request.method !== elicitation || p.mode !== 'form'
+      || p.requestedSchema?.type !== 'object' || Object.keys(p.requestedSchema.properties || {}).length
+      || p.requestedSchema.required?.length || typeof p.message !== 'string' || !p.message.trim()) return null;
+    const tool = meta.codex_approval_kind === 'mcp_tool_call' && meta.connector_id === 'browser-use';
+    if (!tool && !['browser', 'browser-use'].includes(p.serverName)) return null;
+    if (meta.codex_approval_kind && meta.codex_approval_kind !== 'mcp_tool_call') return null;
+    const modes = meta.persist == null ? [] : Array.isArray(meta.persist) ? meta.persist : [meta.persist];
+    if (modes.some(mode => !['session', 'always'].includes(mode))) return null;
+    if (!tool && !modes.length) return null;
+    try {
+      const origin = new URL(meta.origin);
+      if (!['http:', 'https:'].includes(origin.protocol) || origin.origin !== meta.origin) return null;
+      return { origin: meta.origin, session: modes.includes('session'), persistent: modes.includes('always') };
+    } catch { return null; }
+  }
+  function browserActionResult(decision) {
+    return { action: decision === 'cancel' ? 'cancel' : 'accept', content: decision === 'cancel' ? null : {},
+      _meta: decision === 'allowAlways' ? { persist: 'always' }
+        : decision === 'allowSession' ? { persist: 'session' } : null };
+  }
+  function computerAppAccess(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind !== 'mcp_tool_call'
+      || (meta.codex_request_type != null && meta.codex_request_type !== 'approval_request')
+      || typeof meta.connector_id !== 'string' || p.requestedSchema?.type !== 'object'
+      || Object.keys(p.requestedSchema.properties || {}).length || p.requestedSchema.required?.length) return null;
+    const connector = meta.connector_id.trim().toLowerCase().split(/[^a-z0-9]+/g).filter(Boolean).join('-');
+    if (connector !== 'computer-use' && !connector.startsWith('computer-use-')) return null;
+    const modes = Array.isArray(meta.persist) ? meta.persist : [meta.persist];
+    if (!modes.length || modes.some(mode => !['session', 'always'].includes(mode))) return null;
+    const display = Array.isArray(meta.tool_params_display) ? meta.tool_params_display.find(entry => entry?.name === 'app')?.value : null;
+    const app = typeof display === 'string' && display.trim() ? display : meta.tool_params?.app;
+    if (typeof app !== 'string' || !app.trim()) return null;
+    return { app: app.trim(), session: modes.includes('session'), persistent: modes.includes('always'),
+      subtitle: typeof meta.subtitle === 'string' ? meta.subtitle : '', highRisk: meta.riskLevel === 'high' };
+  }
+  function computerAppResult(request, decision) {
+    const app = computerAppAccess(request);
+    return { action: decision === 'decline' ? 'decline' : 'accept', content: decision === 'decline' ? null : {},
+      _meta: decision === 'allowAlways' ? { persist: 'always' }
+        : decision === 'allowConversation' && app?.session ? { persist: 'session' } : null };
+  }
+  function mcpToolApproval(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind !== 'mcp_tool_call'
+      || (meta.codex_request_type != null && meta.codex_request_type !== 'approval_request')
+      || p.requestedSchema?.type !== 'object' || Object.keys(p.requestedSchema.properties || {}).length
+      || p.requestedSchema.required?.length || typeof p.message !== 'string' || !p.message.trim()
+      || typeof meta.connector_id !== 'string' || !meta.connector_id.trim()
+      || !meta.tool_params || typeof meta.tool_params !== 'object' || Array.isArray(meta.tool_params)) return null;
+    const connector = meta.connector_id.trim().toLowerCase().split(/[^a-z0-9]+/g).filter(Boolean).join('-');
+    // These requests have dedicated approval semantics in Desktop.
+    if (connector === 'browser-use' || connector === 'computer-use' || connector.startsWith('computer-use-')
+      || meta.tool_name === 'access_browser_origin' || meta.tool_name === 'access_browser_origin_with_raw_cdp'
+      || meta.connector_id === 'connector_20205bf7d4e99a89d7154bb849718324') return null;
+    const modes = meta.persist === undefined ? [] : Array.isArray(meta.persist) ? meta.persist : [meta.persist];
+    if ((Array.isArray(meta.persist) && (!modes.length || modes.length > 2))
+      || modes.some(mode => !['session', 'always'].includes(mode))) return null;
+    return { session: modes.includes('session'), persistent: modes.includes('always') };
+  }
+  function mcpToolResult(decision) {
+    return { action: decision === 'decline' ? 'decline' : 'accept', content: decision === 'decline' ? null : {},
+      _meta: decision === 'allowAlways' ? { persist: 'always' }
+        : decision === 'allowSession' ? { persist: 'session' } : null };
+  }
+  function externalAction(request) {
+    const p = request.params || {};
+    if (request.method !== elicitation || p.mode !== 'url') return null;
+    try {
+      const url = new URL(p.url);
+      if (url.protocol !== 'https:' || url.username || url.password) return null;
+      if (p.serverName !== 'codex_apps') return { url: url.href, connector: null };
+      const connector = p._meta?._codex_apps?.connector_auth_failure;
+      const trusted = host => ['chatgpt.com', 'chatgpt-staging.com'].some(domain => host === domain || host.endsWith('.' + domain));
+      if (!trusted(url.hostname) || connector?.is_auth_failure !== true
+        || typeof connector.connector_id !== 'string' || typeof connector.connector_name !== 'string'
+        || typeof connector.install_url !== 'string' || connector.connection_consent != null) return null;
+      return { url: url.href, connector };
+    } catch { return null; }
+  }
+  function elicitationResult(action, content = null) { return { action, content: action === 'accept' ? content : null, _meta: null }; }
+  function browserAuth(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind !== 'browser_auth'
+      || p.requestedSchema?.type !== 'object' || !p.requestedSchema.properties || Object.keys(p.requestedSchema.properties).length
+      || !/^[A-Za-z0-9_-]{32,128}$/.test(meta.browser_auth_challenge_id || '')
+      || !Array.isArray(meta.fields) || !meta.fields.length || meta.fields.length > 6
+      || meta.options != null && (!Array.isArray(meta.options) || meta.options.length)
+      || meta.qrCode || meta.qrCodePayload || meta.qrCodeUrl || meta.webauthn != null) return null;
+    try {
+      const origin = new URL(meta.origin);
+      if (!['https:', 'http:'].includes(origin.protocol) || origin.origin !== meta.origin) return null;
+    } catch { return null; }
+    const ids = new Set();
+    for (const field of meta.fields) {
+      if (!field || typeof field.id !== 'string' || !/^[A-Za-z0-9_-]{1,48}$/.test(field.id) || ['__proto__', 'constructor', 'prototype'].includes(field.id)
+        || ids.has(field.id) || typeof field.label !== 'string' || typeof field.required !== 'boolean'
+        || !['email', 'number', 'password', 'search', 'tel', 'text', 'url'].includes(field.type)) return null;
+      ids.add(field.id);
+    }
+    return { origin: meta.origin, challengeId: meta.browser_auth_challenge_id, fields: meta.fields,
+      accountUsername: typeof meta.account_username === 'string' ? meta.account_username : null };
+  }
+  function validateBrowserAuthFields(auth, fields) {
+    if (!auth || !fields || typeof fields !== 'object' || Array.isArray(fields)
+      || !Object.keys(fields).length || Object.keys(fields).some(id => !auth.fields.some(field => field.id === id))) throw new Error('安全登录字段无效');
+    for (const field of auth.fields) {
+      const entry = fields[field.id];
+      if (entry === undefined && !field.required) continue;
+      if (!entry || Object.keys(entry).length !== 1 || typeof entry.value !== 'string'
+        || !entry.value.length) throw new Error('请填写有效的安全登录信息');
+    }
+  }
+  function fieldOptions(field) {
+    const schema = field.type === 'array' ? field.items : field;
+    if (Array.isArray(schema?.enum)) return schema.enum.map((value, index) => ({ value, label: schema.enumNames?.[index] || value }));
+    const options = schema?.oneOf || schema?.anyOf;
+    return Array.isArray(options) ? options.map(option => ({ value: option.const, label: option.title || option.const })) : null;
+  }
+  function formSchema(request) {
+    const p = request.params || {}, meta = p._meta || {}, schema = p.requestedSchema;
+    // Specialized approvals, credentials and OpenAI forms have their own response contracts.
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind
+      || meta['openai/elicitation'] || meta['openai/confirmation'] || schema?.type !== 'object'
+      || ['browser', 'browser-use'].includes(p.serverName)
+      || !schema.properties || typeof schema.properties !== 'object' || Array.isArray(schema.properties)
+      || Object.keys(schema).some(key => !['$schema', 'type', 'properties', 'required'].includes(key))) return null;
+    const known = ['type', 'title', 'description', 'default', 'minLength', 'maxLength', 'format', 'minimum', 'maximum', 'enum', 'enumNames', 'oneOf', 'items', 'minItems', 'maxItems'];
+    for (const field of Object.values(schema.properties)) {
+      if (!field || Object.keys(field).some(key => !known.includes(key))
+        || !['string', 'number', 'integer', 'boolean', 'array'].includes(field.type)) return null;
+      const options = fieldOptions(field);
+      if ((field.type === 'array' || field.enum != null || field.oneOf != null) && !options
+        || options && (!options.length || options.some(option => typeof option.value !== 'string' || typeof option.label !== 'string'))) return null;
+      if (field.format && !['email', 'uri', 'date', 'date-time'].includes(field.format)) return null;
+    }
+    if (schema.required != null && (!Array.isArray(schema.required) || schema.required.some(key => !Object.hasOwn(schema.properties, key)))) return null;
+    return schema;
+  }
+  function validateForm(schema, values) {
+    if (!values || typeof values !== 'object' || Array.isArray(values)
+      || Object.keys(values).some(key => !Object.hasOwn(schema.properties, key))) throw new Error('表单内容无效');
+    for (const [key, field] of Object.entries(schema.properties)) {
+      const value = values[key], label = field.title || key;
+      if (value === undefined) { if (schema.required?.includes(key)) throw new Error(`请填写${label}`); continue; }
+      let valid = field.type === 'array' ? Array.isArray(value) : typeof value === (field.type === 'integer' ? 'number' : field.type);
+      if (typeof value === 'number') valid &&= Number.isFinite(value) && (field.type !== 'integer' || Number.isInteger(value))
+        && (field.minimum == null || value >= field.minimum) && (field.maximum == null || value <= field.maximum);
+      if (typeof value === 'string') {
+        valid &&= (field.minLength == null || [...value].length >= field.minLength) && (field.maxLength == null || [...value].length <= field.maxLength);
+        if (field.format === 'email') valid &&= /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+        if (field.format === 'uri') { try { new URL(value); } catch { valid = false; } }
+        if (field.format === 'date') valid &&= /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(Date.parse(value));
+        if (field.format === 'date-time') valid &&= /^\d{4}-\d{2}-\d{2}T.+(?:Z|[+-]\d{2}:\d{2})$/.test(value) && !Number.isNaN(Date.parse(value));
+      }
+      const options = fieldOptions(field);
+      if (Array.isArray(value)) valid &&= new Set(value).size === value.length && (field.minItems == null || value.length >= field.minItems)
+        && (field.maxItems == null || value.length <= field.maxItems) && value.every(item => options?.some(option => option.value === item));
+      else if (options) valid &&= options.some(option => option.value === value);
+      if (!valid) throw new Error(`${label}的内容不符合请求要求`);
+    }
+  }
+  function permissionResult(request, decision) {
+    return { permissions: decision === 'decline' ? {} : request.params.permissions, scope: decision === 'acceptForSession' ? 'session' : 'turn' };
+  }
+  function blocksComposer(request) {
+    if (externalAction(request)) return false;
+    return request.method === input || Boolean(formSchema(request))
+      || request.method !== elicitation && decisions(request).length > 0
+      || request.method === elicitation && decisions(request).some(value => value !== 'cancel');
+  }
+  function decisions(request) {
+    if (confirmation(request)) return ['decline', 'accept'];
+    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
+    if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
+    if (request.method === permissions && request.params.permissions) return ['accept', 'acceptForSession', 'decline'];
+    if (externalAction(request)) return ['decline', 'accept'];
+    const action = browserAction(request);
+    if (action) return ['allowOnce', ...(action.session ? ['allowSession'] : []), ...(action.persistent ? ['allowAlways'] : []), 'cancel'];
+    const app = computerAppAccess(request);
+    if (app) return ['decline', 'allowConversation', ...(app.persistent ? ['allowAlways'] : [])];
+    const browser = browserAccess(request);
+    if (browser) return browser.persistent ? ['allowOnce', 'allowSite', 'allowAllSites', 'decline'] : ['allowOnce', 'decline'];
+    const tool = mcpToolApproval(request);
+    if (tool) return ['decline', 'allowOnce', ...(tool.session ? ['allowSession'] : []), ...(tool.persistent ? ['allowAlways'] : [])];
+    return request.method === elicitation ? ['cancel'] : [];
+  }
+  function validate(request, result) {
+    if (request.method === elicitation && equal(result, elicitationResult('cancel'))) return;
+    if (browserAuth(request)) {
+      if (!['decline', 'cancel'].some(action => equal(result, { action }))) throw new Error('安全登录必须通过专用输入入口提交');
+      return;
+    }
+    if (externalAction(request)) {
+      if (!['accept', 'decline'].some(action => equal(result, elicitationResult(action)))) throw new Error('外部操作结果无效');
+      return;
+    }
+    const schema = formSchema(request);
+    if (schema) {
+      if (equal(result, elicitationResult('decline'))) return;
+      if (result?.action !== 'accept' || result._meta !== null || Object.keys(result).length !== 3) throw new Error('表单响应格式无效');
+      validateForm(schema, result.content); return;
+    }
+    if (request.method === permissions) {
+      if (!decisions(request).some(decision => equal(result, permissionResult(request, decision)))) throw new Error('权限决定不属于当前请求');
+      return;
+    }
+    if (confirmation(request)) {
+      if (!decisions(request).some(decision => equal(confirmationResult(request, decision), result))) throw new Error('确认结果不属于当前请求');
+      return;
+    }
+    if ([command, file].includes(request.method)) {
+      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
+      return;
+    }
+    if (request.method === input) {
+      const questions = request.params.questions || [];
+      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
+        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
+      return;
+    }
+    if (browserAction(request)) {
+      if (!decisions(request).some(decision => equal(browserActionResult(decision), result))) throw new Error('浏览器操作决定不属于当前请求');
+      return;
+    }
+    if (computerAppAccess(request)) {
+      if (!decisions(request).some(decision => equal(computerAppResult(request, decision), result))) throw new Error('应用访问决定不属于当前请求');
+      return;
+    }
+    const browser = browserAccess(request);
+    if (browser) {
+      const allowed = [
+        { action: 'accept', content: {}, _meta: null },
+        { action: 'decline', content: null, _meta: null },
+      ];
+      if (browser.persistent) allowed.push(
+        { action: 'accept', content: {}, _meta: { persist: 'always' } },
+        { action: 'accept', content: {}, _meta: { persist: 'always', browser_use_persistent_approval_scope: 'all-sites' } },
+      );
+      if (!allowed.some(choice => equal(choice, result))) throw new Error('网站访问决定不属于当前请求');
+      return;
+    }
+    if (mcpToolApproval(request)) {
+      if (!decisions(request).some(decision => equal(mcpToolResult(decision), result))) throw new Error('工具授权决定不属于当前请求');
+      return;
+    }
+    throw new Error('此类请求需在工作站处理');
+  }
+  class Store {
+    constructor(epoch, changed = () => {}) {
+      this.epoch = epoch; this.changed = changed; this.requests = new Map(); this.approvalHistory = new Map();
+    }
+    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    history(threadId) { return [...this.approvalHistory.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    complete(request, status) {
+      const approval = this.approvalHistory.get(approvalId(request));
+      if (approval) { approval.status = status; approval.completedAtMs = Date.now(); }
+    }
+    receive(message) {
+      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
+      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
+      if (request.method !== input) this.approvalHistory.set(approvalId(request), {
+        type: 'approval', id: approvalId(request), requestId: request.id, method: request.method,
+        params: request.params, turnId: request.params.turnId, status: 'pending', receivedAtMs: Date.now(),
+      });
+      this.requests.set(message.id, request); this.changed(request.params.threadId);
+    }
+    notification(method, params) {
+      if (method === 'serverRequest/resolved') {
+        const request = this.requests.get(params.requestId);
+        if (request?.params.threadId === params.threadId) {
+          this.complete(request, 'resolved'); this.requests.delete(params.requestId); this.changed(params.threadId);
+        }
+      } else if (method === 'turn/completed' || method === 'thread/closed') {
+        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) {
+          this.complete(r, 'expired'); this.requests.delete(id);
+        }
+        this.changed(params.threadId);
+      }
+    }
+    forget(threadId) {
+      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
+      for (const [id, approval] of this.approvalHistory) if (approval.params.threadId === threadId) this.approvalHistory.delete(id);
+      this.changed(threadId);
+    }
+    reset(epoch) {
+      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
+      for (const request of this.requests.values()) this.complete(request, 'expired');
+      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
+      this.approvalHistory.clear();
+    }
+    async respond(threadId, { id, epoch, result }, send) {
+      const request = this.requests.get(id);
+      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
+      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
+      validate(request, result);
+      const approval = this.approvalHistory.get(approvalId(request));
+      if (approval) { approval.status = 'submitted'; approval.result = result; }
+      request.status = 'submitted'; this.changed(threadId);
+      try { await send({ id: request.id, result }); }
+      catch (error) {
+        if (this.requests.get(id) === request) {
+          request.status = 'unknown'; if (approval) approval.status = 'unknown'; this.changed(threadId);
+        }
+        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
+      }
+      return { submitted: true };
+    }
+  }
+  return { Store, decisions, validate, command, file, input, elicitation, permissions, externalAction, elicitationResult, formSchema, fieldOptions, validateForm, permissionResult, blocksComposer, browserAccess, browserAction, browserActionResult, browserAuth, validateBrowserAuthFields, computerAppAccess, computerAppResult, mcpToolApproval, mcpToolResult, confirmation, confirmationResult };
+});

package/dist/shared/service-endpoints.cjs

@@ -0,0 +1,21 @@
+// Generated from packages/service-domains.json; run node bridge/tools/generate-service-endpoints.mjs.
+(function(root) {
+  const endpoints = {
+  "profile": "coderelax",
+  "apiOrigin": "https://api.coderelax.cn",
+  "webOrigin": "https://www.coderelax.cn",
+  "adminOrigin": "https://admin.coderelax.cn",
+  "relayUrl": "wss://api.coderelax.cn/relay",
+  "pairingUrl": "https://www.coderelax.cn/pair",
+  "accountBase": "https://api.coderelax.cn/account",
+  "announcementUrl": "https://api.coderelax.cn/announcement",
+  "installUrl": "https://www.coderelax.cn/code-relax/install",
+  "updateManifestUrl": "https://www.coderelax.cn/code-relax/releases/latest/manifest.json5",
+  "adminUrl": "https://admin.coderelax.cn/admin"
+};
+  endpoints.isOfficialRelayUrl = value => ["wss://api.uulife.site/relay","wss://api.coderelax.cn/relay"].includes(value);
+  endpoints.resolveRelayUrl = value => endpoints.isOfficialRelayUrl(value) ? endpoints.relayUrl : value;
+  endpoints.webOrigins = ["https://api.uulife.site","https://www.coderelax.cn"];
+  if (typeof module !== 'undefined' && module.exports) module.exports = Object.freeze(endpoints);
+  else root.CodeRelaxEndpoints = Object.freeze(endpoints);
+})(globalThis);