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

package/dist/src/app-server-tasks.mjs

@@ -1,358 +0,0 @@
-import crypto from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import fs from 'node:fs';
-import path from 'node:path';
-import events from '../shared/app-server-events.cjs';
-
-const STORE_SCHEMA_VERSION = 1;
-
-export class AppServerTaskStore {
-  constructor(filePath) {
-    this.filePath = path.resolve(filePath);
-    this.records = new Map();
-    this.loadError = null;
-    this.load();
-  }
-
-  load() {
-    if (!fs.existsSync(this.filePath)) return;
-    try {
-      const value = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
-      if (value?.schemaVersion !== STORE_SCHEMA_VERSION || !Array.isArray(value.tasks)) {
-        throw new Error('任务归属文件格式不受支持。');
-      }
-      for (const task of value.tasks) {
-        if (!validTaskRecord(task)) continue;
-        this.records.set(task.id, { ...task, transport: 'app-server' });
-      }
-    } catch (error) {
-      this.loadError = error instanceof Error ? error : new Error(String(error));
-    }
-  }
-
-  ensureUsable() {
-    if (this.loadError) {
-      throw new Error(`无法读取 app-server 任务归属：${this.loadError.message}`);
-    }
-  }
-
-  has(threadId) {
-    return this.records.has(threadId);
-  }
-
-  get(threadId) {
-    return this.records.get(threadId) || null;
-  }
-
-  list() {
-    return [...this.records.values()].sort((left, right) => taskRecency(right) - taskRecency(left));
-  }
-
-  upsert(task) {
-    this.ensureUsable();
-    if (!validTaskRecord(task)) throw new Error('app-server 任务归属记录无效。');
-    const record = { ...task, transport: 'app-server' };
-    const existing = this.records.get(record.id);
-    if (existing && JSON.stringify(existing) === JSON.stringify(record)) return existing;
-    this.records.set(record.id, record);
-    this.save();
-    return record;
-  }
-
-  remove(threadId) {
-    this.ensureUsable();
-    if (!this.records.delete(threadId)) return false;
-    this.save();
-    return true;
-  }
-
-  save() {
-    this.ensureUsable();
-    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-    const temporaryPath = `${this.filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
-    const payload = `${JSON.stringify({
-      schemaVersion: STORE_SCHEMA_VERSION,
-      tasks: this.list(),
-    }, null, 2)}\n`;
-    try {
-      fs.writeFileSync(temporaryPath, payload, { encoding: 'utf8', flag: 'wx' });
-      fs.renameSync(temporaryPath, this.filePath);
-    } catch (error) {
-      try { fs.unlinkSync(temporaryPath); } catch {}
-      throw error;
-    }
-  }
-}
-
-export class AppServerTaskTransport extends EventEmitter {
-  constructor({ client, store }) {
-    super();
-    this.client = client;
-    this.store = store;
-    this.hydratedGeneration = 0;
-    this.loadedGenerations = new Map();
-    this.client.on('notification', record => this.handleNotification(record));
-    this.client.on('server-request', request => {
-      const threadId = request.params?.threadId || request.params?.conversationId || '';
-      if (threadId && this.owns(threadId)) this.emit('thread-event', { threadId, record: request });
-    });
-  }
-
-  owns(threadId) {
-    return this.store.has(threadId);
-  }
-
-  record(threadId) {
-    const record = this.store.get(threadId);
-    if (!record) throw new Error('该任务不属于独立 app-server 通道。');
-    return record;
-  }
-
-  async createTask({ cwd, projectId, title, input, model, effort }) {
-    if (!path.isAbsolute(cwd)) throw new Error('app-server 任务 cwd 必须是绝对路径。');
-    if (!Array.isArray(input) || !input.length) throw new Error('app-server 任务输入不能为空。');
-    this.store.ensureUsable();
-    await this.client.start();
-    const startParams = { cwd, ephemeral: false, projectId: projectId || null };
-    if (!projectId) startParams.runtimeWorkspaceRoots = [];
-    if (model) startParams.model = model;
-    const started = await this.client.request('thread/start', startParams, 60_000);
-    this.loadedGenerations.set(started.thread.id, this.client.generation);
-    const now = Math.floor(Date.now() / 1000);
-    const record = this.store.upsert({
-      id: started.thread.id,
-      title: title || started.thread.name || '新对话',
-      cwd,
-      projectId: projectId || null,
-      createdAt: Number(started.thread.createdAt) || now,
-      updatedAt: Number(started.thread.updatedAt) || now,
-      recencyAt: Number(started.thread.recencyAt) || Number(started.thread.updatedAt) || now,
-      status: threadStatus(started.thread.status),
-      activeFlags: threadActiveFlags(started.thread.status),
-      model: model || started.model || started.thread.model || '',
-      effort: effort || started.reasoningEffort || started.thread.reasoningEffort || '',
-      transport: 'app-server',
-    });
-    if (title) try {
-      await this.client.request('thread/name/set', { threadId: record.id, name: title }, 15_000);
-    } catch {
-      // The persisted local title still keeps the task identifiable.
-    }
-
-    const turnParams = { threadId: record.id, input };
-    if (model) turnParams.model = model;
-    if (effort) turnParams.effort = effort;
-    const turn = await this.client.request('turn/start', turnParams, 60_000);
-    this.store.upsert({ ...record, status: 'active', activeFlags: [] });
-    return { thread: started.thread, turn: turn.turn, record: this.store.get(record.id) };
-  }
-
-  async listTasks() {
-    const records = this.store.list();
-    if (!records.length) return [];
-    await this.client.start();
-    if (this.hydratedGeneration === this.client.generation) {
-      return records.map(record => summaryFromRecord(record));
-    }
-    const results = await Promise.allSettled(records.map(record => this.readTask(record.id, { includeTurns: false })));
-    const summaries = results.map((result, index) => {
-      const record = records[index];
-      if (result.status === 'rejected') return summaryFromRecord(record, 'unknown');
-      const thread = result.value;
-      const updated = this.store.upsert({
-        ...record,
-        title: thread.name || record.title,
-        cwd: thread.cwd || record.cwd,
-        updatedAt: Number(thread.updatedAt) || record.updatedAt,
-        recencyAt: Number(thread.recencyAt) || record.recencyAt || record.updatedAt,
-        status: threadStatus(thread.status),
-        activeFlags: threadActiveFlags(thread.status),
-        model: thread.model || record.model,
-        effort: thread.reasoningEffort || record.effort,
-      });
-      return summaryFromThread(thread, updated);
-    });
-    if (results.every(result => result.status === 'fulfilled')) {
-      this.hydratedGeneration = this.client.generation;
-    }
-    return summaries;
-  }
-
-  async readTask(threadId, { includeTurns = true, turnLimit = 10 } = {}) {
-    this.record(threadId);
-    await this.client.start();
-    if (!includeTurns) return (await this.readInitializedThread({ threadId, includeTurns: false })).thread;
-    const [threadResult, turnsResult] = await Promise.all([
-      this.readInitializedThread({ threadId, includeTurns: false }),
-      this.client.request('thread/turns/list', {
-        threadId,
-        limit: turnLimit,
-        sortDirection: 'desc',
-        itemsView: 'full',
-      }, 30_000),
-    ]);
-    return { ...threadResult.thread, turns: [...(turnsResult.data || [])].reverse().map(events.compactTurn) };
-  }
-
-  async readInitializedThread(params) {
-    for (let attempt = 0; ; attempt += 1) {
-      try {
-        return await this.client.request('thread/read', params, 30_000);
-      } catch (error) {
-        const initializing = error instanceof AppServerRpcError
-          && error.method === 'thread/read'
-          && /rollout at .* is empty/i.test(error.message);
-        if (!initializing || attempt >= 3) throw error;
-        await delay(100 * (attempt + 1));
-      }
-    }
-  }
-
-  async startTurn(threadId, { input, model, effort }) {
-    const record = this.record(threadId);
-    await this.client.start();
-    await this.ensureResumed(threadId);
-    const params = { threadId, input };
-    if (model) params.model = model;
-    if (effort) params.effort = effort;
-    const result = await this.client.request('turn/start', params, 60_000);
-    this.store.upsert({
-      ...record,
-      status: 'active',
-      activeFlags: [],
-      model: model || record.model,
-      effort: effort || record.effort,
-    });
-    return result;
-  }
-
-  async adoptTask(thread) {
-    this.store.ensureUsable();
-    await this.client.start();
-    let result;
-    try {
-      result = await this.client.request('thread/resume', { threadId: thread.id }, 60000);
-    } catch (error) {
-      if (error instanceof AppServerRpcError && /already has an active writer/.test(error.message)) {
-        throw new Error('Desktop 仍持有此聊天的写入权限，空闲不代表已释放。当前无法直接接管；此聊天仍由 Desktop 执行。');
-      }
-      throw error;
-    }
-    if (result.thread.id !== thread.id) throw new Error('恢复后的聊天 ID 不一致。');
-    const record = this.store.upsert({
-      id: thread.id, title: thread.title || result.thread.name || thread.id,
-      cwd: result.thread.cwd, projectId: thread.projectId || null,
-      createdAt: Number(result.thread.createdAt) || Number(thread.createdAt) || 0,
-      updatedAt: Number(result.thread.updatedAt) || Number(thread.updatedAt) || 0,
-      recencyAt: Number(result.thread.recencyAt) || Number(thread.recencyAt)
-        || Number(result.thread.updatedAt) || Number(thread.updatedAt) || 0,
-      status: threadStatus(result.thread.status), activeFlags: threadActiveFlags(result.thread.status),
-      origin: 'desktop', transport: 'app-server',
-    });
-    this.loadedGenerations.set(thread.id, this.client.generation);
-    return summaryFromRecord(record);
-  }
-
-  async ensureResumed(threadId) {
-    if (this.loadedGenerations.get(threadId) === this.client.generation) return;
-    await this.client.request('thread/resume', { threadId }, 60000);
-    this.loadedGenerations.set(threadId, this.client.generation);
-  }
-
-  async steerTurn(threadId, expectedTurnId, input) {
-    this.record(threadId);
-    await this.client.start();
-    return this.client.request('turn/steer', { threadId, expectedTurnId, input }, 60_000);
-  }
-
-  async interruptTurn(threadId, turnId) {
-    this.record(threadId);
-    await this.client.start();
-    return this.client.request('turn/interrupt', { threadId, turnId }, 60_000);
-  }
-
-  async deleteTask(threadId) {
-    this.record(threadId);
-    if (this.record(threadId).origin === 'desktop') throw new Error('接管的 Desktop 历史不允许通过此接口删除。');
-    await this.client.start();
-    await this.client.request('thread/delete', { threadId }, 30_000);
-    this.store.remove(threadId);
-  }
-
-  handleNotification(record) {
-    const threadId = notificationThreadId(record);
-    if (!threadId || !this.owns(threadId)) return;
-    const current = this.store.get(threadId);
-    if (current && ['thread/status/changed', 'turn/started', 'turn/completed', 'thread/name/updated'].includes(record.method)) {
-      const next = { ...current };
-      if (record.method === 'thread/status/changed') {
-        next.status = threadStatus(record.params?.status);
-        next.activeFlags = threadActiveFlags(record.params?.status);
-      }
-      if (record.method === 'turn/started') { next.status = 'active'; next.activeFlags = []; }
-      if (record.method === 'turn/completed') { next.status = 'idle'; next.activeFlags = []; }
-      if (record.method === 'thread/name/updated' && record.params?.threadName) next.title = record.params.threadName;
-      this.store.upsert(next);
-      this.hydratedGeneration = 0;
-    }
-    this.emit('thread-event', { threadId, record });
-  }
-}
-
-export function summaryFromRecord(record, status = record.status || 'unknown') {
-  return {
-    id: record.id,
-    kind: 'codex',
-    hostId: 'app-server',
-    title: record.title,
-    cwd: record.cwd,
-    projectId: record.projectId,
-    updatedAt: record.updatedAt,
-    recencyAt: record.recencyAt ?? record.updatedAt,
-    status,
-    activeFlags: Array.isArray(record.activeFlags) ? record.activeFlags : [],
-    transport: 'app-server',
-  };
-}
-
-function summaryFromThread(thread, record) {
-  return {
-    ...summaryFromRecord(record, threadStatus(thread.status)),
-    activeFlags: threadActiveFlags(thread.status),
-    title: thread.name || record.title || thread.preview || thread.id,
-    cwd: thread.cwd || record.cwd,
-    updatedAt: Number(thread.updatedAt) || record.updatedAt,
-    recencyAt: Number(thread.recencyAt) || record.recencyAt || record.updatedAt,
-  };
-}
-
-function validTaskRecord(task) {
-  return task && typeof task.id === 'string' && task.id.length > 10
-    && typeof task.title === 'string' && typeof task.cwd === 'string' && path.isAbsolute(task.cwd)
-    && Number.isFinite(Number(task.createdAt)) && Number.isFinite(Number(task.updatedAt));
-}
-
-function taskRecency(task) {
-  return Number(task?.recencyAt ?? task?.updatedAt) || 0;
-}
-
-function delay(milliseconds) {
-  return new Promise(resolve => setTimeout(resolve, milliseconds));
-}
-
-function threadStatus(value) {
-  if (typeof value === 'string') return value;
-  if (value && typeof value === 'object') return value.type || value.status || 'unknown';
-  return 'unknown';
-}
-
-function threadActiveFlags(value) {
-  return value && typeof value === 'object' && Array.isArray(value.activeFlags)
-    ? value.activeFlags.filter(flag => typeof flag === 'string')
-    : [];
-}
-
-function notificationThreadId(record) {
-  const params = record?.params || {};
-  return params.threadId || params.conversationId || params.thread?.id || '';
-}

package/dist/src/platform/windows/desktop-monitor.mjs

@@ -1,34 +0,0 @@
-import { findDesktopPipe } from './desktop-tools.mjs';
-
-// Optional Desktop presentation data never blocks the shared execution service.
-export class DesktopMonitor {
-  constructor({ discover = () => findDesktopPipe({ allowMissing: true }), read, report = console.error }) {
-    this.discover = discover; this.read = read; this.report = report;
-    this.pipe = null; this.snapshot = null; this.stopped = true;
-  }
-  start() { this.stopped = false; void this.tick(); }
-  stop() { this.stopped = true; clearTimeout(this.timer); }
-  async refresh() {
-    try {
-      const pipe = await this.discover();
-      if (this.stopped) return;
-      this.pipe = pipe;
-      if (!pipe) { this.snapshot = null; return; }
-      const [listing, projects] = await Promise.all([
-        this.read('list_threads', { limit: 50 }, pipe), this.read('list_projects', {}, pipe),
-      ]);
-      if (this.stopped) return;
-      if (!listing.success || !projects.success) throw new Error('Desktop 列表读取失败');
-      this.snapshot = { listing: listing.data, projects: projects.data.projects || [] };
-      this.error = null;
-    } catch (error) {
-      this.pipe = null; this.snapshot = null;
-      if (this.error !== error.message) this.report(`Desktop 排序暂不可用：${error.message}`);
-      this.error = error.message;
-    }
-  }
-  async tick() {
-    await this.refresh();
-    if (!this.stopped) { this.timer = setTimeout(() => this.tick(), this.pipe ? 10000 : 2000); this.timer.unref(); }
-  }
-}

package/dist/src/platform/windows/desktop-tools.mjs

@@ -1,48 +0,0 @@
-import net from 'node:net';
-import fs from 'node:fs';
-import { setTimeout as delay } from 'node:timers/promises';
-
-async function isToolsPipe(pipe, timeout) {
-  return new Promise(resolve => {
-    const socket = net.createConnection(pipe);
-    let data = Buffer.alloc(0);
-    const finish = value => { clearTimeout(timer); socket.destroy(); resolve(value); };
-    const timer = setTimeout(() => finish(false), timeout);
-    socket.on('error', () => finish(false));
-    socket.on('end', () => finish(false));
-    socket.on('connect', () => {
-      const body = Buffer.from(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: { threadStartKind: 'all' } }));
-      const header = Buffer.alloc(4); header.writeUInt32LE(body.length);
-      socket.write(Buffer.concat([header, body]));
-    });
-    socket.on('data', chunk => {
-      data = Buffer.concat([data, chunk]);
-      if (data.length < 4) return;
-      const length = data.readUInt32LE(0);
-      if (length > 8 * 1024 * 1024) return finish(false);
-      if (data.length < length + 4) return;
-      try {
-        const response = JSON.parse(data.subarray(4, length + 4));
-        finish(response.id === 1 && response.result?.tools?.some(tool => tool.namespace === 'codex_app' && tool.name === 'send_message_to_thread'));
-      } catch { finish(false); }
-    });
-  });
-}
-
-
-// The Desktop WebSocket may connect before its tools router is ready.
-export async function findDesktopPipe({ timeout = 0, allowMissing = false, wait = delay, now = Date.now,
-  enumerate = () => fs.readdirSync('\\\\.\\pipe\\').filter(name => name.startsWith('codex-browser-use-')).map(name => `\\\\.\\pipe\\${name}`),
-  ready = isToolsPipe } = {}) {
-  const deadline = now() + timeout;
-  do {
-    const matches = (await Promise.all(enumerate().map(async pipe =>
-      await ready(pipe, Math.max(1, Math.min(2000, timeout ? deadline - now() : 2000))) ? pipe : null))).filter(Boolean);
-    if (matches.length === 1) return matches[0];
-    if (matches.length > 1) throw new Error(`检测到 ${matches.length} 个桌面工具管道，无法确定 Bridge 应连接的 Desktop。`);
-    if (now() >= deadline) break;
-    await wait(Math.min(250, deadline - now()));
-  } while (true);
-  if (allowMissing) return null;
-  throw new Error('Desktop 工具接口尚未就绪。请等待 Desktop 首页加载完成后重试；未启动 Bridge，也未结束 Desktop。');
-}

package/dist/src/thread-catalog.mjs

@@ -1,47 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import path from 'node:path';
-
-function normalizedPath(value) {
-  return String(value || '').replace(/^\\\\\?\\/, '').replaceAll('\\', '/').replace(/\/+$/, '').toLowerCase();
-}
-
-export function supplementThreadCatalog(data, projects, codexRoot, limit) {
-  const db = new DatabaseSync(path.join(codexRoot, 'state_5.sqlite'), { readOnly: true });
-  try {
-    const rows = db.prepare(`SELECT id, name, title, cwd, project_id, archived,
-      COALESCE(updated_at_ms, updated_at * 1000) AS updated_ms,
-      MAX(recency_at_ms, recency_at * 1000, COALESCE(updated_at_ms, updated_at * 1000)) AS sort_ms
-      FROM threads WHERE source IN ('vscode', 'cli') ORDER BY sort_ms DESC`).all();
-    const indexed = new Map(rows.map(row => [row.id, row]));
-    const localProjects = projects.filter(project => project.hostId === 'local' && project.path)
-      .sort((a, b) => normalizedPath(b.path).length - normalizedPath(a.path).length);
-    const assignProject = thread => {
-      if (thread.projectId || thread.hostId !== 'local') return thread;
-      const cwd = normalizedPath(thread.cwd);
-      const project = localProjects.find(project => cwd === normalizedPath(project.path) || cwd.startsWith(normalizedPath(project.path) + '/'));
-      return { ...thread, projectId: project?.projectId || null };
-    };
-    const normalizeRecency = thread => {
-      const assigned = assignProject(thread);
-      const row = assigned.hostId === 'local' ? indexed.get(assigned.id) : null;
-      return row ? { ...assigned, updatedAt: row.updated_ms / 1000, recencyAt: row.sort_ms / 1000 }
-        : { ...assigned, recencyAt: assigned.recencyAt ?? assigned.updatedAt };
-    };
-    const visible = thread => thread.kind === 'codex'
-      && (thread.hostId !== 'local' || !indexed.get(thread.id)?.archived);
-    const listed = [...(data.pinnedThreads || []), ...(data.threads || [])];
-    const threads = new Map(listed.filter(visible).map(thread => [thread.id, normalizeRecency(thread)]));
-    for (const row of rows) {
-      if (row.archived || threads.has(row.id)) continue;
-      threads.set(row.id, normalizeRecency({ id: row.id, kind: 'codex', hostId: 'local',
-        title: row.name || row.title, cwd: row.cwd, projectId: row.project_id,
-        updatedAt: row.updated_ms / 1000, recencyAt: row.sort_ms / 1000, status: 'unknown' }));
-    }
-    const recency = thread => thread.hostId === 'local' && indexed.has(thread.id)
-      ? indexed.get(thread.id).sort_ms : Number(thread.updatedAt || 0) * 1000;
-    return { ...data, pinnedThreads: [], threads: [...threads.values()]
-      .sort((a, b) => recency(b) - recency(a)).slice(0, limit) };
-  } finally {
-    db.close();
-  }
-}

package/dist/tools/find-desktop-pipe.mjs

@@ -1,10 +0,0 @@
-import { findDesktopPipe } from '../src/platform/windows/desktop-tools.mjs';
-
-try {
-  const args = process.argv.slice(2);
-  if (args.length && (args.length !== 1 || args[0] !== '--wait')) throw new Error('Invalid pipe discovery arguments');
-  console.log(await findDesktopPipe({ timeout: args.length ? 120000 : 0 }));
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/dist/web/community-view.js

@@ -1,20 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createCommunityView = factory;
-})(globalThis, function createCommunityView({ button, page, onOpen, onClose }) {
-  function open() {
-    page.hidden = false;
-    button.setAttribute('aria-current', 'page');
-    onOpen?.();
-  }
-
-  function close() {
-    if (page.hidden) return;
-    page.hidden = true;
-    button.removeAttribute('aria-current');
-    onClose?.();
-  }
-
-  button.addEventListener('click', open);
-  return { open, close, isOpen: () => !page.hidden };
-});