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

package/dist/src/shared-recovery.mjs

@@ -8,6 +8,7 @@ import { startBackground } from './background-process.mjs';
 import { desktopHost } from './platform/windows/desktop-host.mjs';
 import * as serviceHost from './platform/windows/service-host.mjs';
 import { launchDesktop, portAvailable } from './desktop-launcher.mjs';
+import { configureManagedEnvironment } from './platform/windows/user-environment.mjs';
 
 const script = fileURLToPath(import.meta.url);
 const recordPath = root => path.join(root, 'shared-recovery.json');
@@ -17,9 +18,9 @@ const active = value => value && ['scheduled', 'running'].includes(value.status)
 const recoverySteps = () => [
   ['checking', '检查启动条件'], ['stopping-desktop', '关闭当前 Codex'],
   ['starting-app-server', '确认 Codex 内核'], ['starting-desktop', '重新打开 Codex'],
-  ['checking-execution', '确认手机控制就绪'],
+  ['checking-execution', '确认移动端控制就绪'],
 ].map(([id, label]) => ({ id, label, status: 'pending' }));
-export const recoveryWarning = 'Codex Desktop 需要重新打开，才能接入同一个 Codex 内核。手机完整控制和 Codex 内核会保持运行；旧 Desktop 实例中的任务可能中断，未发送内容请先保存。切换不会清空项目、对话历史、设置或设备授权。';
+export const recoveryWarning = 'Codex Desktop 需要重新打开，才能接入同一个 Codex 内核。移动端连接和 Codex 内核会保持运行；旧 Desktop 实例中的任务可能中断，未发送内容请先保存。切换不会清空项目、对话历史、设置或设备授权。';
 
 export async function recoveryStatus(stateRoot, host = desktopHost) {
   const record = readRecord(recordPath(stateRoot));
@@ -40,11 +41,11 @@ export async function recoveryStatus(stateRoot, host = desktopHost) {
 export async function planRecovery(stateRoot, host, available = portAvailable) {
   const info = await host.inspect();
   const action = await host.sharedServiceUrl() ? 'restart' : 'switch';
-  if (!info.desktop || !info.cli) throw new Error('未找到 Codex Desktop 或执行程序，请先在电脑完成安装和登录。');
-  const record = readRecord(path.join(stateRoot, 'managed-app-server.json')) || readRecord(path.join(stateRoot, 'shared-desktop.json'));
+  if (!info.desktop) throw new Error('未找到 Codex Desktop；CLI 用户无需执行 Desktop 接入。');
+  const record = readRecord(path.join(stateRoot, 'managed-app-server.json'));
   const actual = record ? await host.process(record.pid) : null;
   if (actual && (!sameProcess(record, actual) || !actual.command?.includes('app-server') || !actual.command.includes('ws://127.0.0.1:45839'))) {
-    throw new Error('完整控制进程身份与记录不符，未结束任何进程。');
+    throw new Error('Codex 内核进程身份与记录不符，未结束任何进程。');
   }
   if (!actual && !await available()) throw new Error('45839 被未识别进程占用，未关闭 Desktop 或结束任何进程。');
   return { desktop: info.desktop, action };
@@ -63,7 +64,7 @@ export async function requestRecovery(stateRoot, { confirmed, operationId = rand
   catch (error) { if (error.code === 'EEXIST') throw new Error('已有恢复操作，请先查看恢复状态。'); throw error; }
   fs.writeFileSync(lock, JSON.stringify({ operationId })); fs.closeSync(lock);
   const record = { operationId, status: 'scheduled', stage: 'prepared', startedAt: new Date().toISOString(),
-    message: '完整控制请求已接受，电脑管理连接保持运行。', steps: recoverySteps(), ...planned };
+    message: 'Codex 连接请求已接受，电脑管理连接保持运行。', steps: recoverySteps(), ...planned };
   try {
     writeRecord(recordPath(stateRoot), record);
     const log = path.join(stateRoot, 'shared-recovery.log');
@@ -83,7 +84,7 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
   const host = dependencies.host || desktopHost;
   const service = dependencies.service || lifecycle({ stateRoot, host: serviceHost });
   const available = dependencies.available || portAvailable;
-  const start = dependencies.launch || (options => launchDesktop('shared', options));
+  const start = dependencies.launch || launchDesktop;
   let record = readRecord(recordPath(stateRoot));
   if (record?.operationId !== operationId || readRecord(lockPath(stateRoot))?.operationId !== operationId) throw new Error('恢复实例已失效。');
   record.steps ||= recoverySteps();
@@ -99,6 +100,7 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
   try {
     stage('checking');
     const planned = await planRecovery(stateRoot, host, available);
+    await configureManagedEnvironment(stateRoot);
     record = { ...record, ...planned };
     if (fs.existsSync(path.join(stateRoot, 'desktop-launch.lock'))) throw new Error('Desktop 正在启动，未与启动操作并行恢复。');
     stage('stopping-desktop'); await host.closeDesktop(record.desktop);
@@ -109,9 +111,9 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
     await waitFor(async () => {
       const health = await service.status();
       return health.running && health.mode === 'lan-shared' && health.execution?.ready === true;
-    }, '完整控制未就绪；Bridge 和中继管理连接仍保留。');
+    }, 'Codex 内核未就绪；Bridge 和中继管理连接仍保留。');
     record = { ...record, status: 'completed', stage: 'ready', steps: record.steps.map(step => ({ ...step, status: 'completed' })),
-      message: 'Codex Desktop 已接入 Codex 内核；手机完整控制保持就绪，原任务未自动重发。' };
+      message: 'Codex Desktop 已接入 Codex 内核；移动端控制保持就绪，原任务未自动重发。' };
   } catch (error) { record = { ...record, status: 'failed', error: error.message,
     steps: record.steps.map(step => ({ ...step, status: step.status === 'running' ? 'failed' : step.status })),
     message: 'Codex Desktop 未完成接入，已停止后续步骤。' }; }

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

@@ -43,7 +43,7 @@ export async function streamSharedThread(response, threadId, client, normalize,
     if (!threadListNotificationMethods.has(method)) return;
     emit('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '' });
   };
-  const onDisconnected = () => { emit('bridge-error', { error: '完整控制已断开，请重新连接。' }); response.end(); finish(); };
+  const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
   response.once('close', () => { closed = true; finish(); });
   client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
   client.on('queue-changed', onQueue);

package/dist/src/skill-install.mjs

@@ -6,11 +6,8 @@ import { readRecord, writeRecord } from './service-lifecycle.mjs';
 
 const owner = '@walkhi/code-relax';
 const markerName = '.code-relax-install.json';
-const legacyOwner = '@closedhi/codex-remote';
-const legacyMarkerName = '.codex-remote-install.json';
 const digest = value => createHash('sha256').update(value).digest('hex');
 export const skillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/code-relax');
-const legacySkillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/codex-remote');
 
 // Refuse junctions/symlinks along managed paths before writing or removing files.
 export function assertPlainPath(target) {
@@ -33,15 +30,6 @@ export function inspectSkill(target = skillDirectory()) {
   return { installed: true, managed, target };
 }
 
-export function removeLegacyManagedSkill(target = legacySkillDirectory()) {
-  const marker = readRecord(path.join(target, legacyMarkerName));
-  const file = path.join(target, 'SKILL.md');
-  if (marker?.owner !== legacyOwner || !fs.existsSync(file) || marker.sha256 !== digest(fs.readFileSync(file))
-    || !fs.readdirSync(target).every(name => ['SKILL.md', legacyMarkerName].includes(name))) return false;
-  fs.unlinkSync(file); fs.unlinkSync(path.join(target, legacyMarkerName)); fs.rmdirSync(target);
-  return true;
-}
-
 export function installSkill(source, target = skillDirectory()) {
   const state = inspectSkill(target);
   if (state.installed && !state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，请保留并手动处理：${target}`);
@@ -49,7 +37,6 @@ export function installSkill(source, target = skillDirectory()) {
   fs.mkdirSync(target, { recursive: true });
   fs.writeFileSync(path.join(target, 'SKILL.md'), content);
   writeRecord(path.join(target, markerName), { owner, sha256: digest(content) });
-  if (path.resolve(target) === path.resolve(skillDirectory())) removeLegacyManagedSkill();
   return { installed: true, target, message: 'Skill 已安装/更新；若 Codex 尚未显示，请重新打开 Codex。' };
 }
 

package/package.json

@@ -1,14 +1,12 @@
 {
-  "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.1",
-  "license": "UNLICENSED",
+  "name": "@walkhi/code-relax",
+  "version": "0.1.0-beta.11",
+  "license": "UNLICENSED",
   "type": "module",
   "scripts": {
     "postinstall": "node ./tools/postinstall.mjs",
     "relay:demo": "node ./bin/self-relay-demo.mjs",
     "relay:check": "node ./bin/self-relay-demo.mjs --check",
-    "probe:app-server": "node ./tools/probe-app-server.mjs",
-    "probe:app-server-tasks": "node ./tools/probe-app-server-tasks.mjs",
     "build": "node ./tools/build-package.mjs",
     "prepack": "npm run build"
   },
@@ -18,10 +16,10 @@
     "sharp": "0.35.4",
     "ws": "8.21.3"
   },
-  "bin": {
-    "relax": "dist/bin/codex-remote.mjs",
-    "code-relax": "dist/bin/codex-remote.mjs"
-  },
+  "bin": {
+    "relax": "dist/bin/codex-remote.mjs",
+    "code-relax": "dist/bin/codex-remote.mjs"
+  },
   "description": "Windows Code Relax LAN Bridge and CLI",
   "engines": {
     "node": ">=22.12.0"
@@ -36,15 +34,15 @@
     "dist/",
     "tools/postinstall.mjs"
   ],
-  "bundleDependencies": [
+  "bundleDependencies": [
     "node-datachannel",
     "qrcode",
     "sharp",
-    "ws"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org",
-    "tag": "beta"
-  }
-}
+    "ws"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "tag": "beta"
+  }
+}

package/tools/postinstall.mjs

@@ -1,9 +1,146 @@
 import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-if (process.env.npm_config_global === 'true') {
+const serviceRoot = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'),
+  'Programs', 'CodexRemote', 'service');
+const stateRoot = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'CodexRemote');
+const installLog = path.join(stateRoot, 'install.log');
+
+function sanitizeLog(value) {
+  let result = String(value).replace(/npm_[A-Za-z0-9]+/gu, '[redacted npm token]')
+    .replace(/([?&]token=)[^&\s"']+/giu, '$1[redacted]');
+  const paths = [['LOCALAPPDATA', process.env.LOCALAPPDATA], ['APPDATA', process.env.APPDATA],
+    ['USERPROFILE', process.env.USERPROFILE], ['TEMP', process.env.TEMP], ['TMP', process.env.TMP]]
+    .filter(([, item]) => item).sort((left, right) => right[1].length - left[1].length);
+  for (const [name, item] of paths) {
+    const pattern = item.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    result = result.replace(new RegExp(pattern, 'giu'), `%${name}%`);
+  }
+  return result;
+}
+
+function appendLog(message) {
+  fs.mkdirSync(stateRoot, { recursive: true });
+  fs.appendFileSync(installLog, `${new Date().toISOString()} ${sanitizeLog(message)}\n`, 'utf8');
+}
+
+function systemSummary() {
+  const npm = String(process.env.npm_config_user_agent || 'unknown').replace(/[\r\n]/gu, ' ');
+  return `platform=${process.platform} osRelease=${os.release()} osVersion=${os.version()} `
+    + `osArch=${os.arch()} processArch=${process.arch} node=${process.version} npmUserAgent=${npm}`;
+}
+
+function runStage(entry, stage, args, formatOutput = value => value) {
+  appendLog(`[${stage}] start`);
+  try {
+    const output = execFileSync(process.execPath, [entry, ...args], { encoding: 'utf8', windowsHide: true,
+      stdio: ['inherit', 'pipe', 'pipe'] });
+    if (output) { process.stdout.write(formatOutput(output)); appendLog(`[${stage}] stdout\n${output.trimEnd()}`); }
+    appendLog(`[${stage}] success`);
+  } catch (error) {
+    if (error?.stdout) { process.stdout.write(error.stdout); appendLog(`[${stage}] stdout\n${String(error.stdout).trimEnd()}`); }
+    if (error?.stderr) { process.stderr.write(error.stderr); appendLog(`[${stage}] stderr\n${String(error.stderr).trimEnd()}`); }
+    appendLog(`[${stage}] failed: ${error?.stack || error?.message || String(error)}`);
+    throw error;
+  }
+}
+
+export function formatSetupOutput(output, previous = {}) {
+  try {
+    const result = JSON.parse(output);
+    const migration = result.managedAppServerMigration || {};
+    const pid = migration.currentPid || result.managedAppServer?.pid || '未知';
+    const appServer = migration.restarted
+      ? `已重启（旧启动链迁移，PID ${migration.previousPid || '未知'} → ${pid}）`
+      : previous.valid
+        ? `未重启（PID ${pid}，启动代次 ${migration.launcherRevision ?? '未知'} 已是最新）`
+        : `已启动（PID ${pid}，启动代次 ${migration.launcherRevision ?? '未知'}）`;
+    return `Code Relax ${result.version || '未知版本'} 安装成功。\n`
+      + `受管 app-server：${appServer}\n`
+      + `Bridge：${result.restarted ? '已恢复并健康' : '已启动并健康'}\n`
+      + `${result.desktopRestarted ? `Codex Desktop：已干净重启并重新接入（${result.desktopRestartReason === 'attach-managed-server' ? '接入受管内核' : 'app-server 迁移'}）\n` : ''}`
+      + `${result.desktopRestartRecommended ? 'Codex Desktop：建议完全退出后重新打开。\n' : ''}`;
+  } catch { return output; }
+}
+
+export function formatSkillOutput(output) {
+  try {
+    const result = JSON.parse(output);
+    return `Code Relax Skill：${result.message || (result.installed ? '已安装' : '已检查')}\n`;
+  } catch { return output; }
+}
+
+function installationSnapshot() {
+  const recordPath = path.join(serviceRoot, 'installation.json');
+  if (!fs.existsSync(serviceRoot)) return { exists: false, valid: false };
+  try {
+    const record = JSON.parse(fs.readFileSync(recordPath, 'utf8').replace(/^\uFEFF/u, ''));
+    return { exists: true, valid: Boolean(record?.installedAt && record?.version),
+      version: record?.version, installedAt: record?.installedAt };
+  } catch {
+    return { exists: true, valid: false };
+  }
+}
+
+function sameInstallation(left, right) {
+  return left.valid && right.valid && left.version === right.version && left.installedAt === right.installedAt;
+}
+
+function setupFailureGuidance(previous, current) {
+  if (previous.valid && sameInstallation(previous, current)) {
+    return `检测到旧安装 ${previous.version}；新版本部署未完成，旧安装记录仍保留。\n`
+      + '请先执行 relax doctor；修复报错原因后重新运行 npm 安装命令，无需卸载旧版本。';
+  }
+  if (previous.valid && current.valid) {
+    return `检测到旧安装 ${previous.version}；服务文件已更新为 ${current.version}，但 setup 后续步骤失败。\n`
+      + '请执行 relax doctor 确认当前状态，修复后执行 relax setup；无需先卸载。';
+  }
+  if (previous.exists && current.valid) {
+    return `检测到既有服务目录，但无法确认有效的旧安装记录；服务文件现已写入 ${current.version}，setup 后续步骤仍失败。\n`
+      + '请执行 relax doctor 确认当前状态，修复后执行 relax setup；不要直接删除配置目录。';
+  }
+  if (previous.exists) {
+    return '检测到既有服务目录，但无法确认有效的旧安装记录；本次部署未完成。\n'
+      + '请执行 relax doctor，根据检查结果修复后重新运行 npm 安装命令，不要直接删除配置目录。';
+  }
+  if (current.valid) {
+    return `这是首次安装；服务文件 ${current.version} 已写入，但 setup 后续步骤失败。\n`
+      + '如果 relax 命令仍可用，请执行 relax doctor，再执行 relax setup；否则修复原因后重新运行 npm 安装命令。';
+  }
+  return '这是首次安装，尚未形成可确认的固定服务。\n修复上方错误后重新运行 npm 安装命令；无需执行卸载。';
+}
+
+function skillFailureGuidance(previous, current) {
+  const service = current.valid
+    ? `${previous.valid ? `服务已从 ${previous.version} 更新到` : '固定服务已安装为'} ${current.version}`
+    : 'setup 已返回成功，但当前固定服务记录无法确认';
+  return `${service}；Codex Skill 安装失败。\n请执行 relax skill-install，再执行 relax doctor；无需重新卸载服务。`;
+}
+
+const invokedDirectly = process.argv[1]
+  && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
+if (invokedDirectly && process.env.npm_config_global === 'true') {
   const entry = fileURLToPath(new URL('../dist/bin/codex-remote.mjs', import.meta.url));
-  for (const command of ['setup', 'skill-install']) {
-    execFileSync(process.execPath, [entry, command, '--json'], { stdio: 'inherit', windowsHide: true });
+  const previous = installationSnapshot();
+  let stage = 'setup';
+  appendLog(`[postinstall] start package=${process.env.npm_package_version || 'unknown'} ${systemSummary()}`);
+  try {
+    runStage(entry, stage, ['setup', '--json'], output => formatSetupOutput(output, previous));
+    stage = 'skill-install';
+    runStage(entry, stage, ['skill-install', '--json'], formatSkillOutput);
+    console.log(`安装日志：${installLog}`);
+    appendLog('[postinstall] success');
+  } catch (error) {
+    const current = installationSnapshot();
+    console.error(`\nCode Relax 安装未完全完成：\n${stage === 'setup'
+      ? setupFailureGuidance(previous, current)
+      : skillFailureGuidance(previous, current)}`);
+    if (error?.code && error.code !== 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') console.error(`启动安装步骤失败：${error.message}`);
+    console.error(`安装日志：${installLog}`);
+    appendLog(`[postinstall] failed stage=${stage}`);
+    process.exitCode = Number.isInteger(error?.status) && error.status > 0 ? error.status : 1;
   }
 }