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

package/dist/src/shared-thread-stream.mjs

@@ -1,164 +1,164 @@
-// Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
-import timelineSync from '../shared/timeline-sync.cjs';
-export const threadListNotificationMethods = new Set([
-  'thread/started', 'thread/status/changed', 'thread/name/updated',
-  'thread/archived', 'thread/unarchived', 'thread/deleted',
-  'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
-]);
-export async function streamSharedThread(response, threadId, client, normalize, requestedSync) {
-  response.startEvents();
-  let closed = false, timer, subscription, releaseActivity, streamReady = false, flushing = false;
-  let tracePending = false, pendingReset;
-  const pending = new Map(), sentTurns = new Map();
-  let fromSeq, toSeq, syncId = requestedSync?.id, epoch = requestedSync?.epoch;
-  let finish;
-  const done = new Promise(resolve => { finish = resolve; });
-  const emit = (name, value) => { if (!closed) return response.event(name, value); };
-  let historySync;
-  const publishHistorySync = () => {
-    if (typeof client.isHistorySyncing !== 'function') return;
-    const active = client.isHistorySyncing(threadId);
-    // End the notice only after the recovered body has been delivered, not
-    // when the upstream read finishes while its update is still being flushed.
-    if (!active && (!streamReady || flushing || pendingReset || pending.size)) return;
-    if (historySync === active) return;
-    historySync = active;
-    emit('history-sync', { threadId, active });
-  };
-  const flush = async () => {
-    clearTimeout(timer); timer = null;
-    const record = client.threads.get(threadId);
-    if (closed || flushing || !streamReady || !record || (!pendingReset && !pending.size)) return;
-    flushing = true;
-    try {
-      if (pendingReset) {
-        const snapshot = pendingReset;
-        pendingReset = undefined;
-        for (const [id, change] of pending) if (change.sequence <= snapshot.sync.seq) pending.delete(id);
-        fromSeq = pending.size ? Math.max(fromSeq, snapshot.sync.seq + 1) : undefined;
-        if (!pending.size) toSeq = undefined;
-        tracePending = [...pending.values()].some(change => change.immediate);
-        const normalized = await normalize(snapshot);
-        if (closed) return;
-        await emit('update', normalized);
-        syncId = normalized.sync.id; epoch = normalized.sync.epoch;
-        sentTurns.clear();
-        for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
-        client.traceSync?.('stream-reset-sent', threadId, { seq: normalized.sync.seq,
-          turnOrder: normalized.turns.map(turn => turn.id) });
-        return;
-      }
-      const batch = structuredClone([...pending.values()].map(change => change.turn));
-      const thread = { ...record.thread, turns: [] }, sync = { id: syncId, epoch, fromSeq, toSeq };
-      const turnOrder = record.thread.turns.map(turn => turn.id), retained = new Set(turnOrder);
-      const trace = tracePending;
-      pending.clear(); fromSeq = toSeq = undefined; tracePending = false;
-      const base = await normalize({ thread, sync });
-      const turns = [], turnPatches = [];
-      const normalizedTurns = [];
-      for (const turn of batch) {
-        if (turn.cacheStub) continue;
-        const normalized = (await normalize({ thread: { ...thread, turns: [turn] } })).turns[0];
-        const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
-        if (patch) turnPatches.push(patch); else turns.push(normalized);
-        normalizedTurns.push(normalized);
-      }
-      if (closed) return;
-      await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
-      for (const turn of normalizedTurns) sentTurns.set(turn.id, turn);
-      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
-      if (trace || turns.length || (base.sync.fromSeq <= record.recoverAfter && record.recoverAfter <= base.sync.toSeq)) {
-        client.traceSync?.('stream-update-sent', threadId, { closed, fromSeq: base.sync?.fromSeq, toSeq: base.sync?.toSeq, turnOrder,
-        messages: turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])),
-        patches: turnPatches.map(patch => ({ turnId: patch.id, entries: (patch.entries || []).map(entry => entry.id), appended: (patch.appended || []).map(entry => entry.id) })) });
-      }
-    } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
-    finally {
-      flushing = false;
-      publishHistorySync();
-      if (!closed && (pendingReset || pending.size) && !timer) timer = setTimeout(flush, 0);
-    }
-  };
-  const onTurn = ({ thread, turn, sequence, immediate }) => {
-    if (thread.id !== threadId) return;
-    if (!fromSeq) fromSeq = sequence;
-    toSeq = sequence;
-    pending.set(turn.id, { turn, sequence, immediate: immediate || pending.get(turn.id)?.immediate });
-    if (immediate) tracePending = true;
-    if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
-  };
-  const onReset = snapshot => {
-    if (snapshot.thread.id !== threadId) return;
-    pendingReset = structuredClone(snapshot);
-    pendingReset.sync.reset = true;
-    flush();
-  };
-  const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
-  const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
-  const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
-  const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
-  const onInvalidated = id => { if (id === threadId) emit('history-invalidated', {}); };
-  const onHistorySync = id => { if (id === threadId) publishHistorySync(); };
-  const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
-  response.once('close', () => { closed = true; finish(); });
-  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
-  client.on('timeline-reset', onReset);
-  client.on('queue-changed', onQueue);
-  client.on('requests-changed', onRequests);
-  client.on('history-invalidated', onInvalidated);
-  client.on('history-sync', onHistorySync);
-  client.on('chat-error', onChatError);
-  publishHistorySync();
-  try {
-    const started = performance.now();
-    client.traceSync?.('stream-open', threadId, { requestedSeq: requestedSync?.after });
-    subscription = await client.acquire(threadId, requestedSync);
-    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
-    if (!closed) {
-      const initial = structuredClone(subscription.record), catchup = subscription.catchup && structuredClone(subscription.catchup);
-      if (pendingReset?.sync.seq <= initial.sync.seq) pendingReset = undefined;
-      // Only discard notifications certified by the acquired snapshot/catchup.
-      for (const [id, change] of pending) if (change.sequence <= initial.sync.seq) pending.delete(id);
-      fromSeq = pending.size ? Math.max(fromSeq, initial.sync.seq + 1) : undefined;
-      if (!pending.size) toSeq = undefined;
-      tracePending = [...pending.values()].some(change => change.immediate);
-      const normalized = await normalize(subscription.confirmed ? { ...initial, thread: { ...initial.thread, turns: [] } } : initial);
-      const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
-      const sent = Boolean(delivered) && !closed;
-      if (sent) await emit('update', delivered);
-      // A timestamp-confirmed cache only needs the new subscription boundary,
-      // never an empty replacement window or a repeated body snapshot.
-      if (subscription.confirmed && !closed) await emit('sync-ready', {
-        thread: normalized.thread, sync: normalized.sync,
-      });
-      client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
-        snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,
-        deliveredSync: sent ? delivered.sync : undefined,
-        messages: sent ? delivered.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) : [],
-        windowMessages: normalized.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) });
-      for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
-      emit('queue-changed', {});
-      onRequests(threadId);
-      streamReady = true;
-      publishHistorySync();
-      if (!closed && typeof client.acquireActivity === 'function') {
-        releaseActivity = client.acquireActivity(threadId, value => emit('dots-activity', value));
-      }
-      flush();
-    }
-    await done;
-  } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
-  finally {
-    client.traceSync?.('stream-close', threadId, { ready: streamReady });
-    clearTimeout(timer);
-    releaseActivity?.();
-    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
-    client.off('timeline-reset', onReset);
-    client.off('queue-changed', onQueue);
-    client.off('requests-changed', onRequests);
-    client.off('history-invalidated', onInvalidated);
-    client.off('history-sync', onHistorySync);
-    client.off('chat-error', onChatError);
-    if (subscription) await subscription.release();
-  }
-}
+// Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
+import timelineSync from '../shared/timeline-sync.cjs';
+export const threadListNotificationMethods = new Set([
+  'thread/started', 'thread/status/changed', 'thread/name/updated',
+  'thread/archived', 'thread/unarchived', 'thread/deleted',
+  'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
+]);
+export async function streamSharedThread(response, threadId, client, normalize, requestedSync) {
+  response.startEvents();
+  let closed = false, timer, subscription, releaseActivity, streamReady = false, flushing = false;
+  let tracePending = false, pendingReset;
+  const pending = new Map(), sentTurns = new Map();
+  let fromSeq, toSeq, syncId = requestedSync?.id, epoch = requestedSync?.epoch;
+  let finish;
+  const done = new Promise(resolve => { finish = resolve; });
+  const emit = (name, value) => { if (!closed) return response.event(name, value); };
+  let historySync;
+  const publishHistorySync = () => {
+    if (typeof client.isHistorySyncing !== 'function') return;
+    const active = client.isHistorySyncing(threadId);
+    // End the notice only after the recovered body has been delivered, not
+    // when the upstream read finishes while its update is still being flushed.
+    if (!active && (!streamReady || flushing || pendingReset || pending.size)) return;
+    if (historySync === active) return;
+    historySync = active;
+    emit('history-sync', { threadId, active });
+  };
+  const flush = async () => {
+    clearTimeout(timer); timer = null;
+    const record = client.threads.get(threadId);
+    if (closed || flushing || !streamReady || !record || (!pendingReset && !pending.size)) return;
+    flushing = true;
+    try {
+      if (pendingReset) {
+        const snapshot = pendingReset;
+        pendingReset = undefined;
+        for (const [id, change] of pending) if (change.sequence <= snapshot.sync.seq) pending.delete(id);
+        fromSeq = pending.size ? Math.max(fromSeq, snapshot.sync.seq + 1) : undefined;
+        if (!pending.size) toSeq = undefined;
+        tracePending = [...pending.values()].some(change => change.immediate);
+        const normalized = await normalize(snapshot);
+        if (closed) return;
+        await emit('update', normalized);
+        syncId = normalized.sync.id; epoch = normalized.sync.epoch;
+        sentTurns.clear();
+        for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
+        client.traceSync?.('stream-reset-sent', threadId, { seq: normalized.sync.seq,
+          turnOrder: normalized.turns.map(turn => turn.id) });
+        return;
+      }
+      const batch = structuredClone([...pending.values()].map(change => change.turn));
+      const thread = { ...record.thread, turns: [] }, sync = { id: syncId, epoch, fromSeq, toSeq };
+      const turnOrder = record.thread.turns.map(turn => turn.id), retained = new Set(turnOrder);
+      const trace = tracePending;
+      pending.clear(); fromSeq = toSeq = undefined; tracePending = false;
+      const base = await normalize({ thread, sync });
+      const turns = [], turnPatches = [];
+      const normalizedTurns = [];
+      for (const turn of batch) {
+        if (turn.cacheStub) continue;
+        const normalized = (await normalize({ thread: { ...thread, turns: [turn] } })).turns[0];
+        const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
+        if (patch) turnPatches.push(patch); else turns.push(normalized);
+        normalizedTurns.push(normalized);
+      }
+      if (closed) return;
+      await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
+      for (const turn of normalizedTurns) sentTurns.set(turn.id, turn);
+      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
+      if (trace || turns.length || (base.sync.fromSeq <= record.recoverAfter && record.recoverAfter <= base.sync.toSeq)) {
+        client.traceSync?.('stream-update-sent', threadId, { closed, fromSeq: base.sync?.fromSeq, toSeq: base.sync?.toSeq, turnOrder,
+        messages: turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])),
+        patches: turnPatches.map(patch => ({ turnId: patch.id, entries: (patch.entries || []).map(entry => entry.id), appended: (patch.appended || []).map(entry => entry.id) })) });
+      }
+    } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
+    finally {
+      flushing = false;
+      publishHistorySync();
+      if (!closed && (pendingReset || pending.size) && !timer) timer = setTimeout(flush, 0);
+    }
+  };
+  const onTurn = ({ thread, turn, sequence, immediate }) => {
+    if (thread.id !== threadId) return;
+    if (!fromSeq) fromSeq = sequence;
+    toSeq = sequence;
+    pending.set(turn.id, { turn, sequence, immediate: immediate || pending.get(turn.id)?.immediate });
+    if (immediate) tracePending = true;
+    if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
+  };
+  const onReset = snapshot => {
+    if (snapshot.thread.id !== threadId) return;
+    pendingReset = structuredClone(snapshot);
+    pendingReset.sync.reset = true;
+    flush();
+  };
+  const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
+  const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
+  const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
+  const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
+  const onInvalidated = id => { if (id === threadId) emit('history-invalidated', {}); };
+  const onHistorySync = id => { if (id === threadId) publishHistorySync(); };
+  const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
+  response.once('close', () => { closed = true; finish(); });
+  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
+  client.on('timeline-reset', onReset);
+  client.on('queue-changed', onQueue);
+  client.on('requests-changed', onRequests);
+  client.on('history-invalidated', onInvalidated);
+  client.on('history-sync', onHistorySync);
+  client.on('chat-error', onChatError);
+  publishHistorySync();
+  try {
+    const started = performance.now();
+    client.traceSync?.('stream-open', threadId, { requestedSeq: requestedSync?.after });
+    subscription = await client.acquire(threadId, requestedSync);
+    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
+    if (!closed) {
+      const initial = structuredClone(subscription.record), catchup = subscription.catchup && structuredClone(subscription.catchup);
+      if (pendingReset?.sync.seq <= initial.sync.seq) pendingReset = undefined;
+      // Only discard notifications certified by the acquired snapshot/catchup.
+      for (const [id, change] of pending) if (change.sequence <= initial.sync.seq) pending.delete(id);
+      fromSeq = pending.size ? Math.max(fromSeq, initial.sync.seq + 1) : undefined;
+      if (!pending.size) toSeq = undefined;
+      tracePending = [...pending.values()].some(change => change.immediate);
+      const normalized = await normalize(subscription.confirmed ? { ...initial, thread: { ...initial.thread, turns: [] } } : initial);
+      const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
+      const sent = Boolean(delivered) && !closed;
+      if (sent) await emit('update', delivered);
+      // A timestamp-confirmed cache only needs the new subscription boundary,
+      // never an empty replacement window or a repeated body snapshot.
+      if (subscription.confirmed && !closed) await emit('sync-ready', {
+        thread: normalized.thread, sync: normalized.sync,
+      });
+      client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
+        snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,
+        deliveredSync: sent ? delivered.sync : undefined,
+        messages: sent ? delivered.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) : [],
+        windowMessages: normalized.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) });
+      for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
+      emit('queue-changed', {});
+      onRequests(threadId);
+      streamReady = true;
+      publishHistorySync();
+      if (!closed && typeof client.acquireActivity === 'function') {
+        releaseActivity = client.acquireActivity(threadId, value => emit('dots-activity', value));
+      }
+      flush();
+    }
+    await done;
+  } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
+  finally {
+    client.traceSync?.('stream-close', threadId, { ready: streamReady });
+    clearTimeout(timer);
+    releaseActivity?.();
+    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
+    client.off('timeline-reset', onReset);
+    client.off('queue-changed', onQueue);
+    client.off('requests-changed', onRequests);
+    client.off('history-invalidated', onInvalidated);
+    client.off('history-sync', onHistorySync);
+    client.off('chat-error', onChatError);
+    if (subscription) await subscription.release();
+  }
+}

package/dist/src/skill-install.mjs

@@ -1,51 +1,51 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { createHash } from 'node:crypto';
-import { readRecord, writeRecord } from './service-lifecycle.mjs';
-
-const owner = '@walkhi/code-relax';
-const markerName = '.code-relax-install.json';
-const digest = value => createHash('sha256').update(value).digest('hex');
-export const skillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/code-relax');
-
-// Refuse junctions/symlinks along managed paths before writing or removing files.
-export function assertPlainPath(target) {
-  for (let item = path.resolve(target); ; item = path.dirname(item)) {
-    try { if (fs.lstatSync(item).isSymbolicLink()) throw new Error(`不自动修改链接路径：${item}`); }
-    catch (error) { if (error.code !== 'ENOENT') throw error; }
-    if (path.dirname(item) === item) break;
-  }
-}
-
-export function inspectSkill(target = skillDirectory()) {
-  assertPlainPath(target);
-  if (!fs.existsSync(target)) return { installed: false, managed: false, target };
-  const markerPath = path.join(target, markerName), file = path.join(target, 'SKILL.md');
-  assertPlainPath(markerPath); assertPlainPath(file);
-  const marker = readRecord(markerPath);
-  const managed = marker?.owner === owner && fs.existsSync(file)
-    && marker.sha256 === digest(fs.readFileSync(file))
-    && fs.readdirSync(target).every(name => ['SKILL.md', markerName].includes(name));
-  return { installed: true, managed, target };
-}
-
-export function installSkill(source, target = skillDirectory()) {
-  const state = inspectSkill(target);
-  if (state.installed && !state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，请保留并手动处理：${target}`);
-  const content = fs.readFileSync(source);
-  fs.mkdirSync(target, { recursive: true });
-  fs.writeFileSync(path.join(target, 'SKILL.md'), content);
-  writeRecord(path.join(target, markerName), { owner, sha256: digest(content) });
-  return { installed: true, target, message: 'Skill 已安装/更新；若 Codex 尚未显示，请重新打开 Codex。' };
-}
-
-export function removeSkill(target = skillDirectory()) {
-  const state = inspectSkill(target);
-  if (!state.installed) return { removed: false, target, message: 'Skill 未安装。' };
-  if (!state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，未删除：${target}`);
-  fs.unlinkSync(path.join(target, 'SKILL.md'));
-  fs.unlinkSync(path.join(target, markerName));
-  fs.rmdirSync(target);
-  return { removed: true, target, message: '已移除本包安装的 Skill。' };
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createHash } from 'node:crypto';
+import { readRecord, writeRecord } from './service-lifecycle.mjs';
+
+const owner = '@walkhi/code-relax';
+const markerName = '.code-relax-install.json';
+const digest = value => createHash('sha256').update(value).digest('hex');
+export const skillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/code-relax');
+
+// Refuse junctions/symlinks along managed paths before writing or removing files.
+export function assertPlainPath(target) {
+  for (let item = path.resolve(target); ; item = path.dirname(item)) {
+    try { if (fs.lstatSync(item).isSymbolicLink()) throw new Error(`不自动修改链接路径：${item}`); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (path.dirname(item) === item) break;
+  }
+}
+
+export function inspectSkill(target = skillDirectory()) {
+  assertPlainPath(target);
+  if (!fs.existsSync(target)) return { installed: false, managed: false, target };
+  const markerPath = path.join(target, markerName), file = path.join(target, 'SKILL.md');
+  assertPlainPath(markerPath); assertPlainPath(file);
+  const marker = readRecord(markerPath);
+  const managed = marker?.owner === owner && fs.existsSync(file)
+    && marker.sha256 === digest(fs.readFileSync(file))
+    && fs.readdirSync(target).every(name => ['SKILL.md', markerName].includes(name));
+  return { installed: true, managed, target };
+}
+
+export function installSkill(source, target = skillDirectory()) {
+  const state = inspectSkill(target);
+  if (state.installed && !state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，请保留并手动处理：${target}`);
+  const content = fs.readFileSync(source);
+  fs.mkdirSync(target, { recursive: true });
+  fs.writeFileSync(path.join(target, 'SKILL.md'), content);
+  writeRecord(path.join(target, markerName), { owner, sha256: digest(content) });
+  return { installed: true, target, message: 'Skill 已安装/更新；若 Codex 尚未显示，请重新打开 Codex。' };
+}
+
+export function removeSkill(target = skillDirectory()) {
+  const state = inspectSkill(target);
+  if (!state.installed) return { removed: false, target, message: 'Skill 未安装。' };
+  if (!state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，未删除：${target}`);
+  fs.unlinkSync(path.join(target, 'SKILL.md'));
+  fs.unlinkSync(path.join(target, markerName));
+  fs.rmdirSync(target);
+  return { removed: true, target, message: '已移除本包安装的 Skill。' };
+}