@walkhi/code-relax 0.1.0-beta.29 → 0.1.0-beta.30

package/dist/src/self-relay/admin-server.mjs

@@ -1,74 +1,74 @@
-import http from 'node:http';
-import fs from 'node:fs';
-import { adminPage } from './admin-page.mjs';
-import { startAdminCloud } from './admin-cloud.mjs';
-import { MAX_ADMIN_REQUEST_BYTES } from './admin-state.mjs';
-
-function reply(response, status, body, type = 'application/json; charset=utf-8') {
-  const bytes = typeof body === 'string' ? body : JSON.stringify(body);
-  response.writeHead(status, { 'Content-Type': type, 'Content-Length': Buffer.byteLength(bytes),
-    'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff',
-    'Referrer-Policy': 'no-referrer', 'X-Robots-Tag': 'noindex, nofollow', 'X-Frame-Options': 'DENY' });
-  response.end(bytes);
-}
-
-export async function startAdminServer({ port = 45851, relayUrl = 'http://127.0.0.1:45850', accessFile = '/etc/codex-relay/admin-access.json' } = {}) {
-  const { key } = JSON.parse(fs.readFileSync(accessFile, 'utf8'));
-  if (!/^[A-Za-z0-9_-]{43}$/.test(key)) throw new Error('Invalid admin access key');
-  const basePath = '/admin/' + key;
-  const cloud = startAdminCloud();
-  const relayOrigin = new URL(relayUrl);
-  if (relayOrigin.hostname !== '127.0.0.1' || relayOrigin.protocol !== 'http:' || relayOrigin.pathname !== '/') {
-    cloud.close(); throw new Error('Admin relay endpoint must be loopback HTTP');
-  }
-  const server = http.createServer(async (request, response) => {
-    const target = new URL(request.url || '/', 'http://localhost');
-    if (request.method === 'GET' && target.pathname === '/admin/health') { reply(response, 200, { ok: true }); return; }
-    if (request.headers['sec-fetch-site'] === 'cross-site' && request.method !== 'GET') { reply(response, 403, { error: 'Cross-site request rejected' }); return; }
-    if (target.pathname !== basePath && !target.pathname.startsWith(basePath + '/')) { reply(response, 404, { error: 'Not found' }); return; }
-    target.pathname = '/admin' + target.pathname.slice(basePath.length);
-    if (request.method === 'GET' && ['/admin', '/admin/'].includes(target.pathname)) {
-      reply(response, 200, adminPage(basePath), 'text/html; charset=utf-8'); return;
-    }
-    if (request.method === 'GET' && target.pathname === '/admin/usage') {
-      response.writeHead(302, { Location: basePath + '#usage', 'Cache-Control': 'no-store' }); response.end(); return;
-    }
-    if (request.method === 'GET' && ['/admin/api/status', '/admin/api/session', '/admin/api/usage', '/admin/api/usage-diagnostics'].includes(target.pathname)) {
-      try {
-        const upstream = await fetch(new URL(target.pathname + target.search, relayOrigin), {
-          signal: AbortSignal.timeout(3000), headers: { 'X-Code-Relax-Admin-Key': key } });
-        const state = await upstream.json();
-        if (!upstream.ok) { reply(response, upstream.status, state); return; }
-        reply(response, 200, target.pathname === '/admin/api/status'
-          ? { ...state, relayAvailable: true, cloud: cloud.read() } : state);
-      } catch {
-        reply(response, 503, { error: '中继服务暂不可用' });
-      }
-      return;
-    }
-    if (!target.pathname.startsWith('/admin/api/') || !['PUT', 'DELETE', 'POST'].includes(request.method || '')) {
-      reply(response, 404, { error: 'Not found' }); return;
-    }
-    try {
-      const chunks = [];
-      let size = 0;
-      for await (const chunk of request) {
-        size += chunk.length;
-        if (size > MAX_ADMIN_REQUEST_BYTES) { reply(response, 413, { error: 'Admin request too large' }); return; }
-        chunks.push(chunk);
-      }
-      const upstream = await fetch(new URL(target.pathname + target.search, relayOrigin), {
-        method: request.method, signal: AbortSignal.timeout(3000),
-        headers: { 'Content-Type': request.headers['content-type'] || '',
-          'X-Code-Relax-Admin': request.headers['x-code-relax-admin'] || '',
-          'X-Code-Relax-Admin-Key': key },
-        body: Buffer.concat(chunks),
-      });
-      reply(response, upstream.status, await upstream.text());
-    } catch { reply(response, 503, { error: '中继服务暂不可用' }); }
-  });
-  try {
-    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
-  } catch (error) { cloud.close(); throw error; }
-  return { port: server.address().port, async close() { cloud.close(); await new Promise(resolve => server.close(resolve)); } };
-}
+import http from 'node:http';
+import fs from 'node:fs';
+import { adminPage } from './admin-page.mjs';
+import { startAdminCloud } from './admin-cloud.mjs';
+import { MAX_ADMIN_REQUEST_BYTES } from './admin-state.mjs';
+
+function reply(response, status, body, type = 'application/json; charset=utf-8') {
+  const bytes = typeof body === 'string' ? body : JSON.stringify(body);
+  response.writeHead(status, { 'Content-Type': type, 'Content-Length': Buffer.byteLength(bytes),
+    'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff',
+    'Referrer-Policy': 'no-referrer', 'X-Robots-Tag': 'noindex, nofollow', 'X-Frame-Options': 'DENY' });
+  response.end(bytes);
+}
+
+export async function startAdminServer({ port = 45851, relayUrl = 'http://127.0.0.1:45850', accessFile = '/etc/codex-relay/admin-access.json' } = {}) {
+  const { key } = JSON.parse(fs.readFileSync(accessFile, 'utf8'));
+  if (!/^[A-Za-z0-9_-]{43}$/.test(key)) throw new Error('Invalid admin access key');
+  const basePath = '/admin/' + key;
+  const cloud = startAdminCloud();
+  const relayOrigin = new URL(relayUrl);
+  if (relayOrigin.hostname !== '127.0.0.1' || relayOrigin.protocol !== 'http:' || relayOrigin.pathname !== '/') {
+    cloud.close(); throw new Error('Admin relay endpoint must be loopback HTTP');
+  }
+  const server = http.createServer(async (request, response) => {
+    const target = new URL(request.url || '/', 'http://localhost');
+    if (request.method === 'GET' && target.pathname === '/admin/health') { reply(response, 200, { ok: true }); return; }
+    if (request.headers['sec-fetch-site'] === 'cross-site' && request.method !== 'GET') { reply(response, 403, { error: 'Cross-site request rejected' }); return; }
+    if (target.pathname !== basePath && !target.pathname.startsWith(basePath + '/')) { reply(response, 404, { error: 'Not found' }); return; }
+    target.pathname = '/admin' + target.pathname.slice(basePath.length);
+    if (request.method === 'GET' && ['/admin', '/admin/'].includes(target.pathname)) {
+      reply(response, 200, adminPage(basePath), 'text/html; charset=utf-8'); return;
+    }
+    if (request.method === 'GET' && target.pathname === '/admin/usage') {
+      response.writeHead(302, { Location: basePath + '#usage', 'Cache-Control': 'no-store' }); response.end(); return;
+    }
+    if (request.method === 'GET' && ['/admin/api/status', '/admin/api/session', '/admin/api/usage', '/admin/api/usage-diagnostics'].includes(target.pathname)) {
+      try {
+        const upstream = await fetch(new URL(target.pathname + target.search, relayOrigin), {
+          signal: AbortSignal.timeout(3000), headers: { 'X-Code-Relax-Admin-Key': key } });
+        const state = await upstream.json();
+        if (!upstream.ok) { reply(response, upstream.status, state); return; }
+        reply(response, 200, target.pathname === '/admin/api/status'
+          ? { ...state, relayAvailable: true, cloud: cloud.read() } : state);
+      } catch {
+        reply(response, 503, { error: '中继服务暂不可用' });
+      }
+      return;
+    }
+    if (!target.pathname.startsWith('/admin/api/') || !['PUT', 'DELETE', 'POST'].includes(request.method || '')) {
+      reply(response, 404, { error: 'Not found' }); return;
+    }
+    try {
+      const chunks = [];
+      let size = 0;
+      for await (const chunk of request) {
+        size += chunk.length;
+        if (size > MAX_ADMIN_REQUEST_BYTES) { reply(response, 413, { error: 'Admin request too large' }); return; }
+        chunks.push(chunk);
+      }
+      const upstream = await fetch(new URL(target.pathname + target.search, relayOrigin), {
+        method: request.method, signal: AbortSignal.timeout(3000),
+        headers: { 'Content-Type': request.headers['content-type'] || '',
+          'X-Code-Relax-Admin': request.headers['x-code-relax-admin'] || '',
+          'X-Code-Relax-Admin-Key': key },
+        body: Buffer.concat(chunks),
+      });
+      reply(response, upstream.status, await upstream.text());
+    } catch { reply(response, 503, { error: '中继服务暂不可用' }); }
+  });
+  try {
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
+  } catch (error) { cloud.close(); throw error; }
+  return { port: server.address().port, async close() { cloud.close(); await new Promise(resolve => server.close(resolve)); } };
+}

package/dist/src/self-relay/admin-state.mjs

@@ -1,127 +1,127 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-// 80 title + 2000 body UTF-16 units fit even when every unit uses a six-byte JSON escape.
-export const MAX_ADMIN_REQUEST_BYTES = 16 * 1024;
-
-export function relayAdminState(file, initialMaxRelaySessions, { initial, persist } = {}) {
-  let value = initial ? validate(initial) : { version: 3, maxRelaySessions: initialMaxRelaySessions, announcement: null, announcements: [] };
-  if (file && fs.existsSync(file)) value = validate(JSON.parse(fs.readFileSync(file, 'utf8')));
-
-  async function save(next) {
-    const validated = validate(next);
-    if (persist) await persist(validated);
-    if (!file) { value = validated; return value; }
-    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    let descriptor;
-    try {
-      descriptor = fs.openSync(temporary, 'wx', 0o600);
-      fs.writeFileSync(descriptor, JSON.stringify(validated));
-      fs.fsyncSync(descriptor); fs.closeSync(descriptor); descriptor = undefined;
-      fs.renameSync(temporary, file);
-      if (process.platform !== 'win32') {
-        const directory = fs.openSync(path.dirname(file), 'r');
-        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
-      }
-    } finally {
-      if (descriptor !== undefined) fs.closeSync(descriptor);
-      fs.rmSync(temporary, { force: true });
-    }
-    value = validated;
-    return value;
-  }
-
-  return {
-    read: () => structuredClone(value),
-    setMaxRelaySessions(maxRelaySessions) { return save({ ...value, maxRelaySessions }); },
-    createAnnouncement(title, message, publish = false) {
-      const now = new Date().toISOString();
-      const record = { id: randomUUID(), title: clean(title, 80), message: clean(message, 2000),
-        createdAt: now, updatedAt: now, publishedAt: publish ? now : null, status: publish ? 'active' : 'draft' };
-      const announcements = value.announcements.map(item => publish && item.status === 'active'
-        ? { ...item, status: 'withdrawn', updatedAt: now } : item);
-      return save({ ...value, announcement: publish ? publicAnnouncement(record) : value.announcement,
-        announcements: [record, ...announcements] });
-    },
-    updateDraft(id, title, message) {
-      const existing = value.announcements.find(item => item.id === id);
-      if (!existing || existing.status !== 'draft') throw new Error('Only drafts can be edited');
-      return save({ ...value, announcements: value.announcements.map(item => item.id === id
-        ? { ...item, title: clean(title, 80), message: clean(message, 2000), updatedAt: new Date().toISOString() } : item) });
-    },
-    publishDraft(id, title, message) {
-      const existing = value.announcements.find(item => item.id === id);
-      if (!existing || existing.status !== 'draft') throw new Error('Only drafts can be published');
-      const now = new Date().toISOString();
-      const published = { ...existing, title: title === undefined ? existing.title : clean(title, 80),
-        message: message === undefined ? existing.message : clean(message, 2000),
-        publishedAt: now, updatedAt: now, status: 'active' };
-      return save({ ...value, announcement: publicAnnouncement(published),
-        announcements: value.announcements.map(item => item.id === id ? published : item.status === 'active'
-          ? { ...item, status: 'withdrawn', updatedAt: now } : item) });
-    },
-    withdraw(id) {
-      if (!value.announcement || value.announcement.id !== id) throw new Error('Announcement is no longer active');
-      const now = new Date().toISOString();
-      return save({ ...value, announcement: null, announcements: value.announcements.map(item => item.status === 'active'
-        ? { ...item, status: 'withdrawn', updatedAt: now } : item) });
-    },
-    deleteAnnouncement(id) {
-      if (typeof id !== 'string' || !value.announcements.some(item => item.id === id)) throw new Error('Announcement not found');
-      if (value.announcement?.id === id) throw new Error('Withdraw the current announcement before deleting it');
-      return save({ ...value, announcements: value.announcements.filter(item => item.id !== id) });
-    },
-  };
-}
-
-function validate(source) {
-  if (!source || ![1, 2, 3].includes(source.version) || !Number.isSafeInteger(source.maxRelaySessions) ||
-      source.maxRelaySessions < 1 || source.maxRelaySessions > 256) throw new Error('Invalid relay admin state');
-  const announcement = source.announcement == null ? null : validateAnnouncement(source.announcement);
-  const announcements = source.version === 1 ? (announcement ? [announcement] : []) : source.announcements;
-  if (!Array.isArray(announcements)) throw new Error('Invalid relay announcement history');
-  const validated = source.version === 3 ? announcements.map(validateRecord) : announcements.map(item => {
-    const old = validateAnnouncement(item);
-    return { ...old, createdAt: old.publishedAt, updatedAt: old.publishedAt,
-      status: old.id === announcement?.id ? 'active' : 'withdrawn' };
-  });
-  const active = validated.filter(item => item.status === 'active');
-  if (new Set(validated.map(item => item.id)).size !== validated.length || active.length > 1 ||
-      (active.length === 0) !== (announcement === null) ||
-      (announcement && !active.some(item => item.id === announcement.id &&
-        item.title === announcement.title && item.message === announcement.message && item.publishedAt === announcement.publishedAt))) {
-    throw new Error('Invalid relay announcement history');
-  }
-  return { version: 3, maxRelaySessions: source.maxRelaySessions, announcement, announcements: validated };
-}
-
-function validateAnnouncement(item) {
-  if (!item || !/^[\w-]{16,128}$/.test(item.id) || typeof item.publishedAt !== 'string' ||
-      !Number.isFinite(Date.parse(item.publishedAt))) throw new Error('Invalid relay announcement');
-  return { id: item.id, title: clean(item.title, 80), message: clean(item.message, 2000), publishedAt: item.publishedAt };
-}
-
-function validateRecord(item) {
-  if (!item || !/^[\w-]{16,128}$/.test(item.id) || !['draft', 'active', 'withdrawn'].includes(item.status) ||
-      typeof item.createdAt !== 'string' || !Number.isFinite(Date.parse(item.createdAt)) ||
-      typeof item.updatedAt !== 'string' || !Number.isFinite(Date.parse(item.updatedAt)) ||
-      (item.status === 'draft' ? item.publishedAt !== null :
-        typeof item.publishedAt !== 'string' || !Number.isFinite(Date.parse(item.publishedAt)))) {
-    throw new Error('Invalid relay announcement record');
-  }
-  return { id: item.id, title: clean(item.title, 80), message: clean(item.message, 2000),
-    createdAt: item.createdAt, updatedAt: item.updatedAt, publishedAt: item.publishedAt, status: item.status };
-}
-
-function publicAnnouncement(record) {
-  return { id: record.id, title: record.title, message: record.message, publishedAt: record.publishedAt };
-}
-
-function clean(value, limit) {
-  if (typeof value !== 'string' || !value.trim() || value.trim().length > limit || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)) {
-    throw new Error('Invalid announcement text');
-  }
-  return value.trim();
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+// 80 title + 2000 body UTF-16 units fit even when every unit uses a six-byte JSON escape.
+export const MAX_ADMIN_REQUEST_BYTES = 16 * 1024;
+
+export function relayAdminState(file, initialMaxRelaySessions, { initial, persist } = {}) {
+  let value = initial ? validate(initial) : { version: 3, maxRelaySessions: initialMaxRelaySessions, announcement: null, announcements: [] };
+  if (file && fs.existsSync(file)) value = validate(JSON.parse(fs.readFileSync(file, 'utf8')));
+
+  async function save(next) {
+    const validated = validate(next);
+    if (persist) await persist(validated);
+    if (!file) { value = validated; return value; }
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    let descriptor;
+    try {
+      descriptor = fs.openSync(temporary, 'wx', 0o600);
+      fs.writeFileSync(descriptor, JSON.stringify(validated));
+      fs.fsyncSync(descriptor); fs.closeSync(descriptor); descriptor = undefined;
+      fs.renameSync(temporary, file);
+      if (process.platform !== 'win32') {
+        const directory = fs.openSync(path.dirname(file), 'r');
+        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
+      }
+    } finally {
+      if (descriptor !== undefined) fs.closeSync(descriptor);
+      fs.rmSync(temporary, { force: true });
+    }
+    value = validated;
+    return value;
+  }
+
+  return {
+    read: () => structuredClone(value),
+    setMaxRelaySessions(maxRelaySessions) { return save({ ...value, maxRelaySessions }); },
+    createAnnouncement(title, message, publish = false) {
+      const now = new Date().toISOString();
+      const record = { id: randomUUID(), title: clean(title, 80), message: clean(message, 2000),
+        createdAt: now, updatedAt: now, publishedAt: publish ? now : null, status: publish ? 'active' : 'draft' };
+      const announcements = value.announcements.map(item => publish && item.status === 'active'
+        ? { ...item, status: 'withdrawn', updatedAt: now } : item);
+      return save({ ...value, announcement: publish ? publicAnnouncement(record) : value.announcement,
+        announcements: [record, ...announcements] });
+    },
+    updateDraft(id, title, message) {
+      const existing = value.announcements.find(item => item.id === id);
+      if (!existing || existing.status !== 'draft') throw new Error('Only drafts can be edited');
+      return save({ ...value, announcements: value.announcements.map(item => item.id === id
+        ? { ...item, title: clean(title, 80), message: clean(message, 2000), updatedAt: new Date().toISOString() } : item) });
+    },
+    publishDraft(id, title, message) {
+      const existing = value.announcements.find(item => item.id === id);
+      if (!existing || existing.status !== 'draft') throw new Error('Only drafts can be published');
+      const now = new Date().toISOString();
+      const published = { ...existing, title: title === undefined ? existing.title : clean(title, 80),
+        message: message === undefined ? existing.message : clean(message, 2000),
+        publishedAt: now, updatedAt: now, status: 'active' };
+      return save({ ...value, announcement: publicAnnouncement(published),
+        announcements: value.announcements.map(item => item.id === id ? published : item.status === 'active'
+          ? { ...item, status: 'withdrawn', updatedAt: now } : item) });
+    },
+    withdraw(id) {
+      if (!value.announcement || value.announcement.id !== id) throw new Error('Announcement is no longer active');
+      const now = new Date().toISOString();
+      return save({ ...value, announcement: null, announcements: value.announcements.map(item => item.status === 'active'
+        ? { ...item, status: 'withdrawn', updatedAt: now } : item) });
+    },
+    deleteAnnouncement(id) {
+      if (typeof id !== 'string' || !value.announcements.some(item => item.id === id)) throw new Error('Announcement not found');
+      if (value.announcement?.id === id) throw new Error('Withdraw the current announcement before deleting it');
+      return save({ ...value, announcements: value.announcements.filter(item => item.id !== id) });
+    },
+  };
+}
+
+function validate(source) {
+  if (!source || ![1, 2, 3].includes(source.version) || !Number.isSafeInteger(source.maxRelaySessions) ||
+      source.maxRelaySessions < 1 || source.maxRelaySessions > 256) throw new Error('Invalid relay admin state');
+  const announcement = source.announcement == null ? null : validateAnnouncement(source.announcement);
+  const announcements = source.version === 1 ? (announcement ? [announcement] : []) : source.announcements;
+  if (!Array.isArray(announcements)) throw new Error('Invalid relay announcement history');
+  const validated = source.version === 3 ? announcements.map(validateRecord) : announcements.map(item => {
+    const old = validateAnnouncement(item);
+    return { ...old, createdAt: old.publishedAt, updatedAt: old.publishedAt,
+      status: old.id === announcement?.id ? 'active' : 'withdrawn' };
+  });
+  const active = validated.filter(item => item.status === 'active');
+  if (new Set(validated.map(item => item.id)).size !== validated.length || active.length > 1 ||
+      (active.length === 0) !== (announcement === null) ||
+      (announcement && !active.some(item => item.id === announcement.id &&
+        item.title === announcement.title && item.message === announcement.message && item.publishedAt === announcement.publishedAt))) {
+    throw new Error('Invalid relay announcement history');
+  }
+  return { version: 3, maxRelaySessions: source.maxRelaySessions, announcement, announcements: validated };
+}
+
+function validateAnnouncement(item) {
+  if (!item || !/^[\w-]{16,128}$/.test(item.id) || typeof item.publishedAt !== 'string' ||
+      !Number.isFinite(Date.parse(item.publishedAt))) throw new Error('Invalid relay announcement');
+  return { id: item.id, title: clean(item.title, 80), message: clean(item.message, 2000), publishedAt: item.publishedAt };
+}
+
+function validateRecord(item) {
+  if (!item || !/^[\w-]{16,128}$/.test(item.id) || !['draft', 'active', 'withdrawn'].includes(item.status) ||
+      typeof item.createdAt !== 'string' || !Number.isFinite(Date.parse(item.createdAt)) ||
+      typeof item.updatedAt !== 'string' || !Number.isFinite(Date.parse(item.updatedAt)) ||
+      (item.status === 'draft' ? item.publishedAt !== null :
+        typeof item.publishedAt !== 'string' || !Number.isFinite(Date.parse(item.publishedAt)))) {
+    throw new Error('Invalid relay announcement record');
+  }
+  return { id: item.id, title: clean(item.title, 80), message: clean(item.message, 2000),
+    createdAt: item.createdAt, updatedAt: item.updatedAt, publishedAt: item.publishedAt, status: item.status };
+}
+
+function publicAnnouncement(record) {
+  return { id: record.id, title: record.title, message: record.message, publishedAt: record.publishedAt };
+}
+
+function clean(value, limit) {
+  if (typeof value !== 'string' || !value.trim() || value.trim().length > limit || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)) {
+    throw new Error('Invalid announcement text');
+  }
+  return value.trim();
+}

package/dist/src/self-relay/android-releases.mjs

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+
+const prefix = '/code-relax/android/';
+const webOrigin = 'https://www.coderelax.cn';
+
+export function readAndroidCatalog(file) {
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!Array.isArray(data.releases) || !data.releases.length) throw new Error('No Android releases');
+  const versions = new Set();
+  for (const item of data.releases) {
+    if (!Number.isSafeInteger(item.versionCode) || item.versionCode < 1 || item.versionCode > 2100000000
+      || versions.has(item.versionCode) || typeof item.versionName !== 'string' || !/^\d+\.\d+\.\d+\.\d+$/.test(item.versionName)
+      || !item.versionName.endsWith('.' + item.versionCode)
+      || !Number.isSafeInteger(item.size) || item.size <= 0 || !/^[a-f0-9]{64}$/.test(item.sha256)
+      || typeof item.objectKey !== 'string' || !/^code-relax\/android\/\d+\/[A-Za-z0-9._-]+\.apk$/.test(item.objectKey)
+      || typeof item.notes !== 'string' || item.notes.length > 10000) throw new Error('Invalid Android release catalog');
+    versions.add(item.versionCode);
+  }
+  if (!versions.has(data.latestVersionCode)) throw new Error('Latest Android release is missing');
+  return data;
+}
+
+export function createAndroidReleaseHandler({ catalogFile, signDownload, log = () => {} }) {
+  return async function handle(request, response, target) {
+    if (!target.pathname.startsWith(prefix)) return false;
+    const headers = { 'Cache-Control': 'no-store', 'Content-Type': 'application/json; charset=utf-8',
+      'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer',
+      'Access-Control-Allow-Origin': webOrigin, Vary: 'Origin' };
+    const reply = (code, data) => { response.writeHead(code, headers); response.end(JSON.stringify(data)); };
+    if (request.method !== 'GET') { reply(405, { error: 'Method not allowed' }); return true; }
+    if (![prefix + 'latest.json', prefix + 'download'].includes(target.pathname)) {
+      reply(404, { error: 'Not found' }); return true;
+    }
+    try {
+      if (!catalogFile || !signDownload) { reply(503, { error: 'Android release is not available' }); return true; }
+      const catalog = readAndroidCatalog(catalogFile);
+      const requested = target.searchParams.get('versionCode');
+      if (requested !== null && !/^[1-9]\d{0,9}$/.test(requested)) { reply(400, { error: 'Invalid version' }); return true; }
+      const code = target.pathname.endsWith('/latest.json') || requested === null ? catalog.latestVersionCode : Number(requested);
+      const release = catalog.releases.find(item => item.versionCode === code);
+      if (!release) { reply(404, { error: 'Release unavailable; check for updates again' }); return true; }
+      const { versionCode, versionName, size, sha256, notes } = release;
+      if (target.pathname.endsWith('/latest.json')) {
+        reply(200, { versionCode, versionName, size, sha256, notes }); return true;
+      }
+      // Sign only an explicitly published object, never a caller-supplied key or URL.
+      const ticket = await signDownload(release);
+      if (!ticket || new URL(ticket.url).protocol !== 'https:' || !Number.isSafeInteger(ticket.expiresAt) || ticket.expiresAt <= Date.now()) {
+        throw new Error('Invalid download ticket');
+      }
+      if (target.searchParams.get('redirect') === '1') {
+        response.writeHead(302, { ...headers, Location: ticket.url }); response.end();
+      } else reply(200, { versionCode, url: ticket.url, expiresAt: ticket.expiresAt });
+    } catch (error) {
+      // Provider errors may contain signed URLs or credentials. Never return or log them.
+      log({ event: 'android-release-error', type: error?.code === 'ENOENT' ? 'not-published' : 'configuration-or-storage' });
+      reply(503, { error: 'Android release is temporarily unavailable' });
+    }
+    return true;
+  };
+}

package/dist/src/self-relay/client.mjs

@@ -1,61 +1,61 @@
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
-import { decode, relayAddress, send } from './wire.mjs';
-
-// Headless mobile-side adapter for the local validation. No OpenAI credentials.
-export function connectRelayClient({ relayUrl, room, code, credential, clientId, accountToken, observe = false }) {
-  relayAddress(relayUrl);
-  const events = new EventEmitter(), pending = new Map();
-  const socket = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: true });
-  let serial = 0, connected = false, pairedCredential = credential, pairedClientId = clientId;
-  const ready = new Promise((resolve, reject) => {
-    const timer = setTimeout(() => { reject(new Error('Relay connection timeout')); socket.terminate(); }, 7000);
-    socket.on('open', () => send(socket, observe ? { type: 'observe', room, credential, clientId, accountToken }
-      : code ? { type: 'pair', room, code, credential, clientId, accountToken } : { type: 'resume', room, credential, clientId, accountToken }));
-    socket.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
-    socket.on('close', () => {
-      clearTimeout(timer); connected = false; reject(new Error('Relay connection closed'));
-      for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('连接断开，操作结果未确认，不自动重发')); }
-      pending.clear(); events.emit('disconnected');
-    });
-    socket.on('message', (bytes, binary) => {
-      try {
-        const message = decode(bytes, binary);
-        if (message.type === 'paired') { if (message.credential) pairedCredential = message.credential; if (message.clientId) pairedClientId = message.clientId; }
-        else if (message.type === 'observing') { clearTimeout(timer); connected = true; events.emit('observing', message); resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
-        else if (message.type === 'computer-info') events.emit('computer-info', { hostName: message.hostName });
-        else if (message.type === 'lan-candidates') events.emit('lan-candidates', message.candidates);
-        else if (message.type === 'official-computer') events.emit('official-computer', message.computer);
-        else if (message.type === 'official-computer-saved') events.emit('official-computer-saved', message.computer);
-        else if (message.type === 'announcement') events.emit('announcement', message.announcement);
-        else if (message.type === 'ready') { clearTimeout(timer); connected = true; resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
-        else if (message.type === 'data') {
-          const body = decode(message.payload, false), request = pending.get(body.id);
-          if (body.type === 'response' && request) { clearTimeout(request.timer); pending.delete(body.id); request.resolve(body); }
-          else events.emit('message', body);
-        } else throw new Error('Invalid relay message');
-      } catch (error) { reject(error); events.emit('diagnostic', error.message); socket.close(1008, 'Invalid response'); }
-    });
-  });
-  return {
-    ready, events,
-    request(path, { method = 'GET', body, timeoutMs = 5000 } = {}) {
-      if (!connected) return Promise.reject(new Error('Relay not ready'));
-      const id = ++serial;
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { pending.delete(id); reject(new Error('请求超时，结果未确认，不自动重发')); }, timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        if (!send(socket, { type: 'data', payload: JSON.stringify({ type: 'request', id, path, method, ...(body ? { body } : {}) }) })) {
-          clearTimeout(timer); pending.delete(id); reject(new Error('Relay not connected'));
-        }
-      });
-    },
-    send(message) { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'data', payload: JSON.stringify(message) }); },
-    routeDirect() { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'p2p-route', direct: 1 }); },
-    recordOfficialComputer(computer) {
-      if (!connected || !observe) throw new Error('Metadata channel not ready');
-      return send(socket, { type: 'official-computer', ...computer });
-    },
-    close() { socket.terminate(); },
-  };
-}
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import { decode, relayAddress, send } from './wire.mjs';
+
+// Headless mobile-side adapter for the local validation. No OpenAI credentials.
+export function connectRelayClient({ relayUrl, room, code, credential, clientId, accountToken, observe = false }) {
+  relayAddress(relayUrl);
+  const events = new EventEmitter(), pending = new Map();
+  const socket = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: true });
+  let serial = 0, connected = false, pairedCredential = credential, pairedClientId = clientId;
+  const ready = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { reject(new Error('Relay connection timeout')); socket.terminate(); }, 7000);
+    socket.on('open', () => send(socket, observe ? { type: 'observe', room, credential, clientId, accountToken }
+      : code ? { type: 'pair', room, code, credential, clientId, accountToken } : { type: 'resume', room, credential, clientId, accountToken }));
+    socket.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
+    socket.on('close', () => {
+      clearTimeout(timer); connected = false; reject(new Error('Relay connection closed'));
+      for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('连接断开，操作结果未确认，不自动重发')); }
+      pending.clear(); events.emit('disconnected');
+    });
+    socket.on('message', (bytes, binary) => {
+      try {
+        const message = decode(bytes, binary);
+        if (message.type === 'paired') { if (message.credential) pairedCredential = message.credential; if (message.clientId) pairedClientId = message.clientId; }
+        else if (message.type === 'observing') { clearTimeout(timer); connected = true; events.emit('observing', message); resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
+        else if (message.type === 'computer-info') events.emit('computer-info', { hostName: message.hostName });
+        else if (message.type === 'lan-candidates') events.emit('lan-candidates', message.candidates);
+        else if (message.type === 'official-computer') events.emit('official-computer', message.computer);
+        else if (message.type === 'official-computer-saved') events.emit('official-computer-saved', message.computer);
+        else if (message.type === 'announcement') events.emit('announcement', message.announcement);
+        else if (message.type === 'ready') { clearTimeout(timer); connected = true; resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
+        else if (message.type === 'data') {
+          const body = decode(message.payload, false), request = pending.get(body.id);
+          if (body.type === 'response' && request) { clearTimeout(request.timer); pending.delete(body.id); request.resolve(body); }
+          else events.emit('message', body);
+        } else throw new Error('Invalid relay message');
+      } catch (error) { reject(error); events.emit('diagnostic', error.message); socket.close(1008, 'Invalid response'); }
+    });
+  });
+  return {
+    ready, events,
+    request(path, { method = 'GET', body, timeoutMs = 5000 } = {}) {
+      if (!connected) return Promise.reject(new Error('Relay not ready'));
+      const id = ++serial;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { pending.delete(id); reject(new Error('请求超时，结果未确认，不自动重发')); }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        if (!send(socket, { type: 'data', payload: JSON.stringify({ type: 'request', id, path, method, ...(body ? { body } : {}) }) })) {
+          clearTimeout(timer); pending.delete(id); reject(new Error('Relay not connected'));
+        }
+      });
+    },
+    send(message) { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'data', payload: JSON.stringify(message) }); },
+    routeDirect() { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'p2p-route', direct: 1 }); },
+    recordOfficialComputer(computer) {
+      if (!connected || !observe) throw new Error('Metadata channel not ready');
+      return send(socket, { type: 'official-computer', ...computer });
+    },
+    close() { socket.terminate(); },
+  };
+}