@walkhi/code-relax 0.1.0-beta.1 → 0.1.0-beta.100

package/dist/shared/p2p-file-channel.cjs

@@ -0,0 +1,87 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxFileChannel = factory();
+})(globalThis, function () {
+  const PART = 16 * 1024, MAX = 256 * 1024, LIMIT = 1024 * 1024;
+  // Socket-shaped adapter; one ordered RTC stream owns one file transaction.
+  return class FileChannel {
+    constructor(io) {
+      this.io = io; this.readyState = 0; this.listeners = new Map();
+      this.outbound = []; this.queued = 0; this.partial = null; this.timer = null;
+    }
+    get bufferedAmount() { return this.queued + this.io.buffered(); }
+    addEventListener(type, callback, options = {}) {
+      const list = this.listeners.get(type) || []; list.push({ callback, once: options.once }); this.listeners.set(type, list);
+    }
+    removeEventListener(type, callback) { this.listeners.set(type, (this.listeners.get(type) || []).filter(item => item.callback !== callback)); }
+    emit(type, details = {}) {
+      const event = { type, ...details };
+      this['on' + type]?.(event);
+      for (const item of [...(this.listeners.get(type) || [])]) {
+        if (item.once) this.removeEventListener(type, item.callback);
+        item.callback(event);
+      }
+    }
+    opened() { if (this.readyState !== 0) return; this.readyState = 1; this.emit('open'); this.pump(); }
+    send(value) {
+      if (this.readyState !== 1) throw new Error('文件直连已断开');
+      const binary = typeof value !== 'string';
+      const data = binary ? (value instanceof Uint8Array ? value : new Uint8Array(value)) : value;
+      const size = binary ? data.byteLength : new TextEncoder().encode(data).length;
+      if (!size || size > (binary ? MAX : PART) || this.bufferedAmount + size > LIMIT) throw new Error('文件直连分片或队列超限');
+      const negotiated = this.io.maxMessageSize?.();
+      const frameBytes = Number.isFinite(negotiated) && negotiated > 0 ? Math.min(PART, Math.max(1, Math.floor(negotiated))) : PART;
+      const frames = binary ? [JSON.stringify({ type: 'rtc-file-bytes', length: size })] : [];
+      if (binary) for (let i = 0; i < size; i += frameBytes) frames.push(data.slice(i, i + frameBytes));
+      else frames.push(data);
+      const sizes = frames.map(frame => typeof frame === 'string' ? new TextEncoder().encode(frame).length : frame.byteLength);
+      if (sizes.some(length => length > frameBytes)) throw new Error('文件传输消息超过协商上限');
+      const framedSize = sizes.reduce((total, length) => total + length, 0);
+      if (this.bufferedAmount + framedSize > LIMIT) throw new Error('文件直连队列超限');
+      this.outbound.push({ frames, sizes, index: 0 }); this.queued += framedSize; this.pump();
+    }
+    pump() {
+      if (this.readyState !== 1) return;
+      try {
+        while (this.outbound.length && this.io.buffered() < MAX) {
+          const item = this.outbound[0];
+          // libdatachannel returns false when it accepted the frame into its buffer.
+          // Only an exception rejects a send; replaying a buffered frame duplicates bytes.
+          this.io.send(item.frames[item.index]);
+          this.queued -= item.sizes[item.index];
+          if (++item.index === item.frames.length) this.outbound.shift();
+        }
+      } catch (error) { this.close(1011, `send-failed:${String(error?.name || 'Error').slice(0, 40)}`); }
+    }
+    waitForPartial() {
+      clearTimeout(this.timer);
+      this.timer = setTimeout(() => this.close(1008, 'partial-idle-timeout'), 30000);
+    }
+    receive(value) {
+      if (this.readyState !== 1) return;
+      try {
+        if (typeof value === 'string') {
+          if (this.partial || new TextEncoder().encode(value).length > PART) throw new Error();
+          const frame = JSON.parse(value);
+          if (frame.type !== 'rtc-file-bytes') { this.io.received?.(); this.emit('message', { data: value }); return; }
+          if (!Number.isSafeInteger(frame.length) || frame.length < 1 || frame.length > MAX) throw new Error();
+          this.io.received?.(); this.partial = { data: new Uint8Array(frame.length), offset: 0 };
+          this.waitForPartial(); return;
+        }
+        const bytes = value instanceof Uint8Array ? value : new Uint8Array(value), part = this.partial;
+        if (!part || bytes.length < 1 || bytes.length > Math.min(PART, part.data.length - part.offset)) throw new Error();
+        this.waitForPartial(); this.io.received?.(); part.data.set(bytes, part.offset); part.offset += bytes.length;
+        if (part.offset === part.data.length) {
+          this.partial = null; clearTimeout(this.timer); this.timer = null;
+          this.emit('message', { data: part.data.buffer });
+        }
+      } catch { this.close(1008, 'invalid-frame'); }
+    }
+    close(code = 1000, reason = '') {
+      if (this.readyState === 3) return;
+      this.readyState = 3; clearTimeout(this.timer); this.timer = null;
+      this.partial = null; this.outbound = []; this.queued = 0;
+      this.io.close(); this.emit('close', { code, reason });
+    }
+  };
+});

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 };
+});