@walkhi/code-relax 0.1.0-beta.3 → 0.1.0-beta.31

package/dist/src/dots-task-files.mjs

@@ -0,0 +1,52 @@
+import { randomUUID } from 'node:crypto';
+import { readMessageUploads } from './message-upload-files.mjs';
+
+// Desktop 26.1007.9446.0 Dll/Uhn/pA: reserve, upload bytes, confirm,
+// then include an Uploaded file sediment pointer in the user message.
+export async function uploadTaskFiles(files, { uploadsRoot, client, current, fetchImpl = fetch }) {
+  const uploads = await readMessageUploads({ files }, uploadsRoot);
+  const references = [];
+  for (const file of uploads) {
+    current();
+    const reserved = await client.request('/files', { method: 'POST', body: {
+      file_name: file.name, file_size: file.bytes.length, mime_type: file.mimeType,
+      use_case: 'codex', store_in_library: false, timezone_offset_min: new Date().getTimezoneOffset(), reset_rate_limits: false,
+    } });
+    current();
+    if (reserved?.status === 'error' || !/^[A-Za-z0-9_-]{1,256}$/.test(reserved?.file_id || '')
+      || typeof reserved.upload_url !== 'string') throw new Error('云端文件上传地址未确认。');
+    const url = new URL(reserved.upload_url, 'https://chatgpt.com');
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || url.hash) throw new Error('云端文件上传地址无效。');
+    if (url.origin === 'https://chatgpt.com' && url.pathname === '/backend-api/estuary/upload_content_bytes') {
+      const uploadUrl = url.searchParams.get('upload_url');
+      if (!uploadUrl) throw new Error('云端文件上传地址缺少参数。');
+      const boundary = `relax-${randomUUID()}`;
+      const name = file.name.replaceAll('"', '%22').replaceAll('\\', '%5C');
+      const body = Buffer.concat([Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${name}"\r\nContent-Type: ${file.mimeType}\r\n\r\n`),
+        file.bytes, Buffer.from(`\r\n--${boundary}\r\nContent-Disposition: form-data; name="upload_url"\r\n\r\n${uploadUrl}\r\n--${boundary}--\r\n`)]);
+      await client.request(url.pathname.slice('/backend-api'.length) + url.search, {
+        method: 'POST', body, contentType: `multipart/form-data; boundary=${boundary}`, rawResponse: true,
+      });
+    } else {
+      if (!['.oaiusercontent.com', '.blob.core.windows.net', '.amazonaws.com'].some(suffix => url.hostname.endsWith(suffix))) {
+        throw new Error('云端文件上传地址不属于文件服务。');
+      }
+      const aws = [...url.searchParams.keys()].some(key => key.toLowerCase() === 'x-amz-algorithm');
+      const response = await fetchImpl(url, { method: 'PUT', body: file.bytes, redirect: 'error', signal: AbortSignal.timeout(60000),
+        headers: { 'Content-Type': file.mimeType, ...aws ? {} : { 'x-ms-blob-type': 'BlockBlob',
+          'x-ms-version': '2020-04-08', 'x-ms-blob-content-type': file.mimeType } } });
+      await response.body?.cancel();
+      if (!response.ok) throw new Error(`云端文件上传失败（${response.status}）。`);
+    }
+    current();
+    await client.request(`/files/${encodeURIComponent(reserved.file_id)}/uploaded`, { method: 'POST', body: {} });
+    current();
+    references.push({ pointer: `sediment://${reserved.file_id}`, fileName: file.name });
+  }
+  return references;
+}
+
+export function taskFilePrompt(text, references) {
+  if (!references.length) return text;
+  return `# Files mentioned by the user:\n${references.map(file => `\nUploaded file: ${JSON.stringify(file).replaceAll('#', '\\u0023')}\n`).join('')}\n## My request:\n${text || '请查看上述文件。'}`;
+}

package/dist/src/file-transfer-range.mjs

@@ -0,0 +1,22 @@
+export const FILE_READ_LIMIT = 20 * 1024 * 1024;
+export const FILE_PART_BYTES = 256 * 1024;
+export class FileRangeError extends Error {
+  constructor(statusCode, message) { super(message); this.statusCode = statusCode; }
+}
+
+export function fileRange(query, size, revision) {
+  const offset = Number(query.get('offset') || 0);
+  const length = Number(query.get('length') || FILE_PART_BYTES);
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset >= size ||
+      !Number.isSafeInteger(length) || length < 1 || length > FILE_PART_BYTES) {
+    throw new FileRangeError(400, '无效的文件读取范围。');
+  }
+  if ((offset && !query.get('revision')) || (query.has('revision') && query.get('revision') !== revision)) {
+    throw new FileRangeError(409, '文件已变化，请重新打开。');
+  }
+  return { offset, length: Math.min(length, size - offset) };
+}
+
+export function fileRevision(stat) {
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+}

package/dist/src/file-upload-session.mjs

@@ -0,0 +1,130 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const MAX_FILE_BYTES = 20 * 1024 * 1024;
+export const MAX_FILE_COUNT = 4;
+export const MAX_TOTAL_BYTES = 40 * 1024 * 1024;
+export const FILE_CHUNK_BYTES = 256 * 1024;
+
+function validName(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 180 &&
+    value !== '.' && value !== '..' && !/[\\/:*?"<>|\x00-\x1f]/.test(value) && !/[. ]$/.test(value) &&
+    !/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(value);
+}
+
+async function uniqueDestination(directory, name, partial) {
+  const dot = name.lastIndexOf('.');
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  const extension = dot > 0 ? name.slice(dot) : '';
+  for (let index = 0; ; index++) {
+    const suffix = index ? ` (${index})` : '';
+    const candidate = index ? `${stem.slice(0, 180 - extension.length - suffix.length)}${suffix}${extension}` : name;
+    if (!candidate || candidate.length > 180) throw new Error('同名文件过多，文件名无法继续编号');
+    const destination = path.join(directory, candidate);
+    try {
+      await fs.link(partial, destination);
+      await fs.unlink(partial);
+      return { name: candidate, path: destination };
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+  }
+}
+
+export function createFileUploadSession(root) {
+  let upload;
+  const completed = new Map();
+  let completedBytes = 0;
+  const directory = path.join(root, 'incoming');
+  const clearActive = async () => {
+    const current = upload;
+    upload = undefined;
+    if (!current) return;
+    await current.handle.close().catch(() => {});
+    await fs.unlink(current.partial).catch(() => {});
+  };
+  const clear = async () => {
+    await clearActive();
+    for (const file of completed.values()) {
+      await fs.unlink(file.path).catch(() => {});
+      if (file.preview) await fs.unlink(file.preview.path).catch(() => {});
+    }
+    completed.clear(); completedBytes = 0;
+  };
+  return {
+    async receive(message) {
+      if (!message || typeof message !== 'object') throw new Error('无效的文件上传请求');
+      if (message.type === 'cancel') { await clear(); return { type: 'cancelled' }; }
+      if (message.type === 'commit') {
+        if (upload) throw new Error('文件尚未上传完成');
+        completed.clear(); completedBytes = 0;
+        return { type: 'committed' };
+      }
+      if (message.type === 'remove') {
+        if (upload) throw new Error('请等待当前文件上传完成');
+        const file = completed.get(message.id);
+        if (!file) throw new Error('文件上传会话已失效');
+        await fs.unlink(file.path);
+        if (file.preview) await fs.unlink(file.preview.path);
+        completed.delete(message.id); completedBytes -= file.size;
+        return { type: 'removed', id: message.id };
+      }
+      if (message.type === 'start') {
+        if (upload) throw new Error('已有文件正在上传');
+        if (!validName(message.name)) throw new Error('文件名无效');
+        if (!Number.isSafeInteger(message.size) || message.size < 1 || message.size > MAX_FILE_BYTES) {
+          throw new Error('单个文件不得超过 20 MiB');
+        }
+        const parent = message.previewOf ? completed.get(message.previewOf) : null;
+        if (message.previewOf && (!parent || parent.preview || message.size > FILE_CHUNK_BYTES)) throw new Error('预览图关联无效或超过 256 KiB');
+        if (!parent && (completed.size >= MAX_FILE_COUNT || completedBytes + message.size > MAX_TOTAL_BYTES)) {
+          throw new Error('每条消息最多 4 个文件，合计不超过 40 MiB');
+        }
+        if (!/^[a-f0-9]{64}$/i.test(message.sha256 || '')) throw new Error('文件校验值无效');
+        const id = crypto.randomUUID();
+        await fs.mkdir(directory, { recursive: true });
+        const partial = path.join(directory, `.upload-${id}`);
+        const handle = await fs.open(partial, 'wx');
+        upload = { id, partial, handle, name: parent ? `${id}.preview.jpg` : message.name, size: message.size, parent,
+          expected: message.sha256.toLowerCase(), hash: crypto.createHash('sha256'), offset: 0 };
+        return { type: 'started', id, offset: 0, chunkBytes: FILE_CHUNK_BYTES };
+      }
+      const current = upload;
+      if (!current || message.id !== current.id) throw new Error('文件上传会话已失效');
+      if (message.type === 'chunk') {
+        if (!Number.isSafeInteger(message.offset) || message.offset !== current.offset) {
+          return { type: 'offset', id: current.id, offset: current.offset };
+        }
+        if (!Buffer.isBuffer(message.data)) {
+          throw new Error('文件分片格式无效');
+        }
+        const bytes = message.data;
+        if (!bytes.length || bytes.length > FILE_CHUNK_BYTES || current.offset + bytes.length > current.size) {
+          throw new Error('文件分片大小无效');
+        }
+        await current.handle.writeFile(bytes);
+        current.hash.update(bytes);
+        current.offset += bytes.length;
+        return { type: 'offset', id: current.id, offset: current.offset };
+      }
+      if (message.type === 'finish') {
+        if (current.offset !== current.size || current.hash.digest('hex') !== current.expected) {
+          await clear(); throw new Error('文件大小或 SHA-256 校验失败');
+        }
+        await current.handle.sync();
+        await current.handle.close();
+        upload = undefined;
+        let saved;
+        try { saved = await uniqueDestination(directory, current.name, current.partial); }
+        catch (error) { await fs.unlink(current.partial).catch(() => {}); throw error; }
+        const result = { type: 'completed', id: current.id, ...saved, size: current.size, sha256: current.expected };
+        if (current.parent) current.parent.preview = result;
+        else { completed.set(current.id, result); completedBytes += current.size; }
+        return result;
+      }
+      throw new Error('不支持的文件上传操作');
+    },
+    close: clear,
+  };
+}

package/dist/src/hosted-history-app-server.mjs

@@ -0,0 +1,103 @@
+import { SharedAppServer } from './shared-app-server.mjs';
+import { historyCacheScope, completedHistory, turnMetadata } from './hosted-history-cache.mjs';
+
+// Hosted history uses a disk range cache; local kernel history retains its own storage.
+export class HostedHistoryAppServer extends SharedAppServer {
+  constructor(url, historyCache) {
+    super(url);
+    this.historyCache = historyCache;
+    this.historyHeadKey = 'latest';
+    this.diskHeads = new Map(); this.invalidatedTurns = new Set(); this.windowSaves = new Map();
+    this.historyVersions = new Map();
+    this.on('disconnected', () => { this.diskHeads.clear(); this.invalidatedTurns.clear(); this.historyVersions.clear(); });
+  }
+
+  historyScope(threadId) { return historyCacheScope(this.historyIdentity, this.historySource, threadId); }
+  historyVersion(threadId) { return `${this.epoch}:${this.historyVersions.get(threadId) || 0}`; }
+
+  async restoreHistoryHead(threadId) {
+    const scope = this.historyScope(threadId);
+    const result = await this.historyCache?.get(scope, this.historyHeadKey);
+    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+    return result;
+  }
+
+  saveHistoryWindow(threadId, immediate = false) {
+    const record = this.threads.get(threadId), scope = this.historyScope(threadId);
+    if (!this.historyCache || !scope || !record || record.hydrating || record.needsReload
+      || record.historyTrimmed || record.metadataOnly || record.readOnly || !completedHistory(record.thread.turns)) return;
+    const value = structuredClone({ updatedAt: record.thread.updatedAt, turns: record.thread.turns,
+      nextCursor: record.nextCursor, revision: record.thread.chatRevision,
+      ...(record.approvalBeforeMs !== undefined ? { approvalBeforeMs: record.approvalBeforeMs } : {}) });
+    const pending = this.windowSaves.get(scope);
+    if (pending) { clearTimeout(pending); this.windowSaves.delete(scope); }
+    const save = () => { this.windowSaves.delete(scope); return this.historyCache.put(scope, this.historyHeadKey, value); };
+    if (immediate) return save();
+    const timer = setTimeout(save, 200); timer.unref(); this.windowSaves.set(scope, timer);
+  }
+
+  invalidateHistory(method, params) {
+    const id = params.threadId || params.thread?.id, scope = this.historyScope(id);
+    if (!scope || !this.historyCache) return;
+    const turnId = params.turnId || params.turn?.id;
+    const whole = ['thread/deleted', 'thread/compacted'].includes(method);
+    if (!whole && (!turnId || !/^(?:item\/|turn\/)/.test(method))) return;
+    this.historyVersions.set(id, (this.historyVersions.get(id) || 0) + 1);
+    clearTimeout(this.windowSaves.get(scope)); this.windowSaves.delete(scope);
+    const key = `${scope}:${turnId}`;
+    if (whole || !this.invalidatedTurns.has(key)) {
+      this.invalidatedTurns.add(key); this.diskHeads.delete(id);
+      void this.historyCache.invalidate(scope, whole ? undefined : turnId);
+    }
+    if (whole) {
+      const record = this.threads.get(id);
+      if (record) record.needsReload = true;
+      this.emit('history-invalidated', id);
+    }
+    if (method === 'turn/completed') this.invalidatedTurns.delete(key);
+  }
+
+  async compactTurn(threadId, turn, cursor = null, apply, limit = 100) {
+    const scope = this.historyScope(threadId), candidate = this.diskHeads.get(threadId);
+    const version = this.historyVersion(threadId);
+    if (cursor && !turn.status && this.historyCache) {
+      const final = await this.historyCache.get(scope, `turn:${turn.id}`);
+      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+      if (final) turn = { ...final.turns[0], ...turn };
+    }
+    const saved = !cursor && candidate?.head?.turns.find(value => value.id === turn.id);
+    if (scope && this.historyCache && saved && candidate.scope === scope && candidate.updatedAt != null
+      && candidate.head.updatedAt === candidate.updatedAt && completedHistory([saved])
+      && turnMetadata(saved) === turnMetadata(turn)) {
+      const result = { ...saved, ...turn, items: saved.items, itemPage: saved.itemPage };
+      apply?.(result); return result;
+    }
+    const result = await super.compactTurn(threadId, turn, cursor, apply, limit);
+    if (this.historyCache && scope === this.historyScope(threadId) && version === this.historyVersion(threadId)
+      && completedHistory([{ ...turn, items: [] }])) {
+      const { items, itemPage, ...metadata } = turn;
+      await this.historyCache.put(scope, `turn:${turn.id}`, { turns: [metadata] });
+    }
+    return result;
+  }
+
+  async history(threadId, cursor, options = {}) {
+    await this.connect();
+    let position;
+    try { position = JSON.parse(cursor); } catch { position = null; }
+    if (position?.threadId !== threadId) return super.history(threadId, cursor, options);
+    const scope = this.historyScope(threadId);
+    const version = this.historyVersion(threadId);
+    const key = JSON.stringify(['history', position.turnId, position.itemCursor, position.turnCursor, options.itemLimit ?? 100]);
+    const cached = await this.historyCache?.get(scope, key);
+    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+    if (cached && version === this.historyVersion(threadId)) return { thread: { id: threadId, turns: cached.turns },
+      nextCursor: cached.position ? JSON.stringify(cached.position) : null };
+    const result = await super.history(threadId, cursor, options);
+    if (scope === this.historyScope(threadId) && version === this.historyVersion(threadId) && completedHistory(result.thread.turns)) {
+      const next = result.nextCursor ? JSON.parse(result.nextCursor) : null;
+      await this.historyCache?.put(scope, key, { turns: result.thread.turns, position: next });
+    }
+    return result;
+  }
+}

package/dist/src/hosted-history-cache.mjs

@@ -0,0 +1,113 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+const threadBudget = 8 * 1024 * 1024;
+const totalBudget = 128 * 1024 * 1024;
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+
+// Store confirmed ranges, not connection tokens, execution context or image bytes.
+export function historyCacheScope(identity, source, threadId) {
+  return identity?.accountId && threadId ? digest([identity.accountId, identity.userId || '', source, threadId]) : null;
+}
+
+export function completedHistory(turns) {
+  if (!turns?.length || turns.some(turn => !['completed', 'failed', 'interrupted'].includes(turn.status)
+    || turn.cacheStub || turn.items?.some(item => item.dotsStreaming
+      || item.type === 'imageGeneration' && !item.savedPath && item.result))) return false;
+  // Signed media addresses and embedded bytes must be reread/refreshed, not replayed from disk.
+  const media = value => value && typeof value === 'object' && Object.entries(value).some(([key, part]) =>
+    typeof part === 'string' && (/^data:/.test(part) || /[?&](?:X-Amz-|X-Goog-|signature=|sig=|token=)/i.test(part))
+    || key === 'imageBytes' || media(part));
+  return !media(turns);
+}
+
+export function turnMetadata(turn) {
+  return digest(Object.entries(turn || {}).filter(([key]) => !['items', 'itemPage', 'cacheStub'].includes(key))
+    .sort(([a], [b]) => a.localeCompare(b)));
+}
+
+export class HostedHistoryCache {
+  constructor(stateRoot, { report = error => console.error(`托管历史缓存失败：${error.message}`), maxThreadBytes = threadBudget, maxTotalBytes = totalBudget } = {}) {
+    this.directory = path.join(stateRoot, 'hosted-history');
+    this.report = report; this.maxThreadBytes = maxThreadBytes; this.maxTotalBytes = maxTotalBytes;
+    this.tail = Promise.resolve();
+  }
+
+  async record(scope) {
+    try {
+      const record = JSON.parse(await fs.readFile(path.join(this.directory, `${scope}.json`), 'utf8'));
+      if (record.version !== 1 || !record.entries || Array.isArray(record.entries) || typeof record.entries !== 'object') {
+        throw new Error('历史缓存结构无效，需重新读取云端历史。');
+      }
+      if (Object.values(record.entries).some(entry => !Number.isFinite(entry.at) || !entry.value
+        || !Array.isArray(entry.value.turns) && !Array.isArray(entry.value.data))) {
+        throw new Error('历史缓存页结构无效，需重新读取云端历史。');
+      }
+      return record;
+    } catch (error) { if (error.code !== 'ENOENT') this.report(error); return { version: 1, entries: {} }; }
+  }
+
+  run(operation, fallback) {
+    const work = this.tail.then(operation).catch(error => { this.report(error); return fallback; });
+    this.tail = work.then(() => {}); return work;
+  }
+
+  get(scope, key) {
+    if (!scope) return Promise.resolve(null);
+    return this.run(async () => (await this.record(scope)).entries?.[key]?.value ?? null, null);
+  }
+
+  put(scope, key, value) {
+    if (!scope) return Promise.resolve();
+    // Freeze before queuing; live events may mutate the source window during disk I/O.
+    const snapshot = structuredClone(value);
+    return this.run(async () => {
+      const record = await this.record(scope);
+      record.entries ||= {};
+      record.entries[key] = { at: Date.now(), value: snapshot };
+      let text = JSON.stringify(record);
+      for (const [oldKey] of Object.entries(record.entries).sort((a, b) => a[1].at - b[1].at)) {
+        if (Buffer.byteLength(text) <= this.maxThreadBytes) break;
+        delete record.entries[oldKey]; text = JSON.stringify(record);
+      }
+      await this.write(scope, text);
+      await this.prune(scope);
+    });
+  }
+
+  invalidate(scope, turnId) {
+    if (!scope) return Promise.resolve();
+    return this.run(async () => {
+      const record = await this.record(scope);
+      for (const [key, entry] of Object.entries(record.entries || {})) {
+        if (!turnId || entry.value.turnIds?.includes(turnId) || entry.value.turns?.some(turn => turn.id === turnId)
+          || entry.value.thread?.turns?.some(turn => turn.id === turnId)) delete record.entries[key];
+      }
+      await this.write(scope, JSON.stringify(record));
+    });
+  }
+
+  async write(scope, text) {
+    if (!/^[a-f0-9]{64}$/.test(scope)) throw new Error('历史缓存身份无效');
+    await fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
+    const file = path.join(this.directory, `${scope}.json`), temporary = `${file}.tmp`;
+    try {
+      await fs.writeFile(temporary, text, { mode: 0o600 });
+      await fs.rename(temporary, file);
+    } finally {
+      try { await fs.unlink(temporary); } catch (error) { if (error.code !== 'ENOENT') this.report(error); }
+    }
+  }
+
+  async prune(current) {
+    const files = await Promise.all((await fs.readdir(this.directory)).filter(name => /^[a-f0-9]{64}\.json$/.test(name))
+      .map(async name => ({ name, ...await fs.stat(path.join(this.directory, name)) })));
+    let bytes = files.reduce((sum, file) => sum + file.size, 0);
+    for (const file of files.sort((a, b) => a.mtimeMs - b.mtimeMs)) {
+      if (bytes <= this.maxTotalBytes) break;
+      if (file.name === `${current}.json`) continue;
+      await fs.unlink(path.join(this.directory, file.name)); bytes -= file.size;
+    }
+  }
+}