git fetch origin
git checkout -b feat/m4-backend-launcher-migration origin/feat/m3-web-host-skeleton
git rev-parse --abbrev-ref HEAD   # 应为 feat/m4-backend-launcher-migration

command -v node && node --version           # 预期 22+
command -v bun && bun --version             # 预期可用
command -v curl && curl --version | head -1
command -v grep
# 可选:ripgrep(如果装了就用 rg,后续命令也给了 grep fallback)
command -v rg || echo "rg 不存在,使用 grep 替代"
# 可选:lsof(只在验证 /health 端口时用)
command -v lsof || echo "lsof 不存在,可用 ss 或 netstat 替代"

cd /Users/zhoukai/Documents/github/AionUi
git status -sb > /tmp/m4-baseline-gitstatus.log
cat /tmp/m4-baseline-gitstatus.log

# 当前测试通过数作为回归基线
cd /Users/zhoukai/Documents/github/AionUi
bun test 2>&1 | tail -10 > /tmp/m4-baseline-test.log
cat /tmp/m4-baseline-test.log

cd /Users/zhoukai/Documents/github/AionUi
git fetch origin
git fetch origin feat/m3-web-host-skeleton
git checkout -b feat/m4-backend-launcher-migration origin/feat/m3-web-host-skeleton
git branch --show-current    # 预期 feat/m4-backend-launcher-migration
git merge-base --is-ancestor origin/feat/m3-web-host-skeleton HEAD && echo "base OK"

# 核对 M3 产物的接口签名,本 plan 所有代码都基于这里为准
cat packages/web-host/src/types.ts
cat packages/web-host/src/backend-launcher.ts
cat packages/web-host/src/index.ts

grep -nE "^import" packages/desktop/src/process/backend/lifecycleManager.ts

8:import { type ChildProcess, spawn } from 'node:child_process';
9:import { createServer } from 'node:net';
10:import { app } from 'electron';
11:import { resolveBinaryPath } from './binaryResolver';

/**
 * Lifecycle manager for the aionui-backend subprocess (web-host version).
 *
 * Migrated from packages/desktop/src/process/backend/lifecycleManager.ts in M4.
 * Electron dependency removed: `app.*` replaced with constructor-injected
 * `AppMetadata`, and binary path resolved by injected `BackendBinaryResolver`.
 * Runtime behavior (spawn args, /health timeout, SIGTERM/SIGKILL, crash
 * restart window) is byte-for-byte preserved from the original.
 */

import { type ChildProcess, spawn } from 'node:child_process';
import { createServer } from 'node:net';
import type { AppMetadata, BackendBinaryResolver } from './types.js';

type BackendStatus = 'stopped' | 'starting' | 'running' | 'error';

type SpawnConfig = {
  port: number;
  dbPath: string;
  local: boolean;
  logDir?: string;
  appVersion: string;
  isPackaged: boolean;
};

export type BackendDirConfig = {
  cacheDir: string;
  workDir: string;
  logDir: string;
};

export type BackendLaunchOptions = {
  app: AppMetadata;
  resolveBackend: BackendBinaryResolver;
  port?: number;
  dataDir?: string;
  logDir?: string;
};

export type BackendHandle = {
  port: number;
  stop: () => Promise<void>;
};

export function buildSpawnArgs(config: SpawnConfig): string[] {
  const logLevel = process.env.AIONUI_LOG_LEVEL || (config.isPackaged ? 'info' : 'debug');
  const args = [
    '--port',
    String(config.port),
    '--data-dir',
    config.dbPath,
    '--log-level',
    logLevel,
    '--app-version',
    config.appVersion,
  ];
  if (config.logDir) args.push('--log-dir', config.logDir);
  if (config.local) args.push('--local');
  return args;
}

/**
 * Backend reads AIONUI_{CACHE,WORK,LOG}_DIR env vars to report system dirs
 * (see aionui-backend/crates/aionui-system/src/sysinfo.rs). Inject them so the
 * backend's `/api/system/info` matches what Electron main persists in
 * ProcessEnv('aionui.dir').
 */
export function buildSpawnEnv(dirs: BackendDirConfig): NodeJS.ProcessEnv {
  return {
    ...process.env,
    AIONUI_CACHE_DIR: dirs.cacheDir,
    AIONUI_WORK_DIR: dirs.workDir,
    AIONUI_LOG_DIR: dirs.logDir,
  };
}

export function findAvailablePort(): Promise<number> {
  return new Promise((resolve, reject) => {
    const server = createServer();
    server.listen(0, '127.0.0.1', () => {
      const addr = server.address();
      if (addr && typeof addr !== 'string') {
        const port = addr.port;
        server.close(() => resolve(port));
      } else {
        server.close(() => reject(new Error('Failed to get port')));
      }
    });
    server.on('error', reject);
  });
}

export class BackendLifecycleManager {
  private childProcess: ChildProcess | null = null;
  private _port = 0;
  private _status: BackendStatus = 'stopped';
  private _lastDbPath = '';
  private _lastLogDir?: string;
  private _lastDirs?: BackendDirConfig;
  private restartCount = 0;
  private restartWindowStart = 0;
  private readonly maxRestarts = 3;
  private readonly restartWindowMs = 60_000;

  constructor(
    private readonly appMeta: AppMetadata,
    private readonly resolveBackend: BackendBinaryResolver
  ) {}

  get port(): number {
    return this._port;
  }

  get status(): BackendStatus {
    return this._status;
  }

  async start(dbPath: string, logDir?: string, dirs?: BackendDirConfig): Promise<number> {
    const binaryPath = this.resolveBackend();
    const appVersion = this.appMeta.version;
    this._port = await findAvailablePort();
    this._status = 'starting';
    this._lastDbPath = dbPath;
    this._lastLogDir = logDir;
    this._lastDirs = dirs;

    const args = buildSpawnArgs({
      port: this._port,
      dbPath,
      local: true,
      logDir,
      appVersion,
      isPackaged: this.appMeta.isPackaged,
    });
    console.log(`[aionui-backend] starting: ${binaryPath} ${args.join(' ')}`);

    this.childProcess = spawn(binaryPath, args, {
      stdio: ['pipe', 'pipe', 'pipe'],
      env: dirs ? buildSpawnEnv(dirs) : process.env,
    });

    this.childProcess.stdin?.end();

    const pid = this.childProcess.pid;
    const killOnExit = () => {
      if (pid) {
        try {
          process.kill(pid, 'SIGKILL');
        } catch {
          /* already gone */
        }
      }
    };
    process.on('exit', killOnExit);

    this.childProcess.on('exit', (code) => {
      process.removeListener('exit', killOnExit);
      if (this._status === 'running') this.handleCrash(code);
    });

    this.childProcess.stdout?.on('data', (data: Buffer) => {
      for (const line of data.toString().split('\n')) {
        if (line.trim()) console.log(`[aionui-backend] ${line}`);
      }
    });

    this.childProcess.stderr?.on('data', (data: Buffer) => {
      for (const line of data.toString().split('\n')) {
        if (line.trim()) console.error(`[aionui-backend] ${line}`);
      }
    });

    const ready = await this.waitForHealth(this._port);
    if (!ready) {
      this.childProcess?.kill('SIGKILL');
      this.childProcess = null;
      this._status = 'error';
      throw new Error('aionui-backend failed to start within timeout');
    }

    this._status = 'running';
    this.restartCount = 0;
    console.log(`[aionui-backend] listening on port ${this._port}, data-dir: ${dbPath}`);
    return this._port;
  }

  async stop(): Promise<void> {
    if (!this.childProcess) return;
    this._status = 'stopped';

    this.childProcess.kill('SIGTERM');
    await new Promise<void>((resolve) => {
      const timeout = setTimeout(() => {
        this.childProcess?.kill('SIGKILL');
        resolve();
      }, 5000);
      this.childProcess?.on('exit', () => {
        clearTimeout(timeout);
        resolve();
      });
    });
    this.childProcess = null;
  }

  private async waitForHealth(port: number, timeoutMs = 30_000): Promise<boolean> {
    const start = Date.now();
    while (Date.now() - start < timeoutMs) {
      try {
        const response = await fetch(`http://127.0.0.1:${port}/health`);
        if (response.ok) return true;
      } catch {
        // not ready yet
      }
      await new Promise((r) => setTimeout(r, 200));
    }
    return false;
  }

  private handleCrash(_code: number | null): void {
    const now = Date.now();
    if (now - this.restartWindowStart > this.restartWindowMs) {
      this.restartCount = 0;
      this.restartWindowStart = now;
    }
    this.restartCount++;

    if (this.restartCount > this.maxRestarts) {
      this._status = 'error';
      return;
    }

    const delay = Math.pow(2, this.restartCount - 1) * 1000;
    setTimeout(() => {
      if (this._status === 'stopped') return;
      this._status = 'starting';
      this.start(this._lastDbPath, this._lastLogDir, this._lastDirs).catch(() => {
        this._status = 'error';
      });
    }, delay);
  }
}

/**
 * Functional wrapper for ownBackend usage in startWebHost (M5 will consume).
 * Not used by desktop IPC path in M4 (desktop instantiates BackendLifecycleManager
 * directly to preserve current stop/port getter semantics).
 */
export async function startBackend(opts: BackendLaunchOptions): Promise<BackendHandle> {
  const manager = new BackendLifecycleManager(opts.app, opts.resolveBackend);
  const dataDir = opts.dataDir ?? '';
  if (!dataDir) {
    throw new Error('startBackend: dataDir is required');
  }
  const port = await manager.start(dataDir, opts.logDir);
  return {
    port,
    stop: () => manager.stop(),
  };
}

/**
 * Functional wrapper kept for symmetry; prefers handle.stop() directly.
 */
export async function stopBackend(handle: BackendHandle): Promise<void> {
  await handle.stop();
}

cd /Users/zhoukai/Documents/github/AionUi/packages/web-host
bunx tsc --noEmit

import type { WebHostOptions, WebHostHandle } from './types.js';

export type { AppMetadata, BackendBinaryResolver, WebHostOptions, WebHostHandle, WebUIConfig } from './types.js';
export { resetPassword, changePassword, verifyPassword, loadConfig, saveConfig } from './auth/index.js';

/**
 * Start WebHost (main entry point)
 * M4-M5: implementation will orchestrate backend-launcher + static-server
 */
export async function startWebHost(opts: WebHostOptions): Promise<WebHostHandle> {
  throw new Error('M4: startWebHost not implemented yet');
}

import type { WebHostOptions, WebHostHandle } from './types.js';

export type { AppMetadata, BackendBinaryResolver, WebHostOptions, WebHostHandle, WebUIConfig } from './types.js';
export { resetPassword, changePassword, verifyPassword, loadConfig, saveConfig } from './auth/index.js';

// Backend launcher exports (M4)
export {
  BackendLifecycleManager,
  buildSpawnArgs,
  buildSpawnEnv,
  findAvailablePort,
  startBackend,
  stopBackend,
} from './backend-launcher.js';
export type { BackendDirConfig, BackendLaunchOptions, BackendHandle } from './backend-launcher.js';

/**
 * Start WebHost (main entry point)
 * M5: implementation will orchestrate backend-launcher + static-server + auth
 */
export async function startWebHost(opts: WebHostOptions): Promise<WebHostHandle> {
  throw new Error('M5: startWebHost not implemented yet');
}

cd /Users/zhoukai/Documents/github/AionUi/packages/web-host
bunx tsc --noEmit

cd /Users/zhoukai/Documents/github/AionUi
git add packages/web-host/src/backend-launcher.ts packages/web-host/src/index.ts
git status   # 验证只这两个文件改动
git commit -m "refactor(m4): migrate lifecycleManager to @aionui/web-host backend-launcher

- Port full lifecycle (spawn, health, crash restart, SIGTERM/SIGKILL) from
  packages/desktop/src/process/backend/lifecycleManager.ts.
- Replace 'electron' app.* with constructor-injected AppMetadata and
  BackendBinaryResolver.
- Add functional startBackend/stopBackend wrappers for M5 startWebHost.
- Keep runtime behavior byte-for-byte identical; desktop wiring in follow-up commits."

/**
 * M4 unit tests for backend-launcher.
 * All external I/O mocked: node:child_process.spawn, node:net.createServer, fetch.
 * No real backend is spawned.
 */

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { EventEmitter } from 'node:events';
import type { ChildProcess } from 'node:child_process';

// ---- Module-level mocks ----
vi.mock('node:child_process', () => ({
  spawn: vi.fn(),
}));

vi.mock('node:net', () => ({
  createServer: vi.fn(),
}));

import { spawn } from 'node:child_process';
import { createServer } from 'node:net';
import { buildSpawnArgs, buildSpawnEnv, findAvailablePort, BackendLifecycleManager } from './backend-launcher.js';
import type { AppMetadata } from './types.js';

const APP_META: AppMetadata = {
  version: '1.2.3',
  isPackaged: false,
  resourcesPath: '/mock/resources',
  userDataPath: '/mock/userData',
};

const APP_META_PACKAGED: AppMetadata = { ...APP_META, isPackaged: true };

function makeFakeServer(port = 54321) {
  const server = new EventEmitter() as EventEmitter & {
    listen: (p: number, h: string, cb: () => void) => void;
    address: () => { port: number };
    close: (cb?: () => void) => void;
  };
  server.listen = (_p, _h, cb) => {
    setImmediate(cb);
  };
  server.address = () => ({ port });
  server.close = (cb) => {
    if (cb) setImmediate(cb);
  };
  return server;
}

function makeFakeChild(): ChildProcess {
  const child = new EventEmitter() as EventEmitter & Partial<ChildProcess>;
  child.stdout = new EventEmitter() as ChildProcess['stdout'];
  child.stderr = new EventEmitter() as ChildProcess['stderr'];
  (child.stdin as unknown) = { end: vi.fn() };
  child.kill = vi.fn() as unknown as ChildProcess['kill'];
  child.pid = 99999;
  return child as ChildProcess;
}

beforeEach(() => {
  vi.clearAllMocks();
});

afterEach(() => {
  // Do NOT call restoreAllMocks; it would remove vi.mock() module factories.
});

describe('buildSpawnArgs', () => {
  it('produces all required flags with logDir and local=true', () => {
    const args = buildSpawnArgs({
      port: 12345,
      dbPath: '/data/path',
      local: true,
      logDir: '/log/dir',
      appVersion: '9.9.9',
      isPackaged: true,
    });
    expect(args).toEqual([
      '--port',
      '12345',
      '--data-dir',
      '/data/path',
      '--log-level',
      'info',
      '--app-version',
      '9.9.9',
      '--log-dir',
      '/log/dir',
      '--local',
    ]);
  });

  it('uses debug log level when not packaged', () => {
    const args = buildSpawnArgs({
      port: 1,
      dbPath: '/d',
      local: false,
      appVersion: '0.0.1',
      isPackaged: false,
    });
    expect(args).toContain('debug');
    expect(args).not.toContain('--log-dir');
    expect(args).not.toContain('--local');
  });

  it('respects AIONUI_LOG_LEVEL override', () => {
    const prev = process.env.AIONUI_LOG_LEVEL;
    process.env.AIONUI_LOG_LEVEL = 'trace';
    try {
      const args = buildSpawnArgs({
        port: 1,
        dbPath: '/d',
        local: false,
        appVersion: 'x',
        isPackaged: true,
      });
      expect(args).toContain('trace');
    } finally {
      if (prev === undefined) delete process.env.AIONUI_LOG_LEVEL;
      else process.env.AIONUI_LOG_LEVEL = prev;
    }
  });
});

describe('buildSpawnEnv', () => {
  it('merges process.env with AIONUI_* dir vars', () => {
    const env = buildSpawnEnv({
      cacheDir: '/c',
      workDir: '/w',
      logDir: '/l',
    });
    expect(env.AIONUI_CACHE_DIR).toBe('/c');
    expect(env.AIONUI_WORK_DIR).toBe('/w');
    expect(env.AIONUI_LOG_DIR).toBe('/l');
    expect(env.PATH).toBe(process.env.PATH); // inherits
  });
});

describe('findAvailablePort', () => {
  it('resolves with the port reported by the listening server', async () => {
    vi.mocked(createServer).mockImplementationOnce(
      () => makeFakeServer(40404) as unknown as ReturnType<typeof createServer>
    );
    const port = await findAvailablePort();
    expect(port).toBe(40404);
  });
});

describe('BackendLifecycleManager.start (success path)', () => {
  it('spawns with correct args, waits for /health, reports running', async () => {
    vi.mocked(createServer).mockImplementation(
      () => makeFakeServer(55555) as unknown as ReturnType<typeof createServer>
    );
    const child = makeFakeChild();
    vi.mocked(spawn).mockReturnValue(child as unknown as ChildProcess);

    const fetchSpy = vi
      .spyOn(globalThis, 'fetch')
      .mockResolvedValue(new Response('ok', { status: 200 }) as unknown as Response);

    const resolveBackend = vi.fn(() => '/abs/path/aionui-backend');
    const mgr = new BackendLifecycleManager(APP_META_PACKAGED, resolveBackend);

    const port = await mgr.start('/db/path', '/log/dir', {
      cacheDir: '/c',
      workDir: '/w',
      logDir: '/l',
    });

    expect(port).toBe(55555);
    expect(mgr.port).toBe(55555);
    expect(mgr.status).toBe('running');
    expect(resolveBackend).toHaveBeenCalledTimes(1);
    expect(spawn).toHaveBeenCalledTimes(1);

    const spawnCall = vi.mocked(spawn).mock.calls[0];
    expect(spawnCall[0]).toBe('/abs/path/aionui-backend');
    expect(spawnCall[1]).toEqual([
      '--port',
      '55555',
      '--data-dir',
      '/db/path',
      '--log-level',
      'info',
      '--app-version',
      '1.2.3',
      '--log-dir',
      '/log/dir',
      '--local',
    ]);
    const opts = spawnCall[2] as { env: NodeJS.ProcessEnv };
    expect(opts.env.AIONUI_CACHE_DIR).toBe('/c');
    expect(opts.env.AIONUI_WORK_DIR).toBe('/w');
    expect(opts.env.AIONUI_LOG_DIR).toBe('/l');

    expect(fetchSpy).toHaveBeenCalled();

    fetchSpy.mockRestore();
  });
});

describe('BackendLifecycleManager.start (health timeout)', () => {
  it('kills child and throws when /health never responds OK within timeout', async () => {
    vi.useFakeTimers();
    try {
      vi.mocked(createServer).mockImplementation(
        () => makeFakeServer(33333) as unknown as ReturnType<typeof createServer>
      );
      const child = makeFakeChild();
      vi.mocked(spawn).mockReturnValue(child as unknown as ChildProcess);

      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('ECONNREFUSED'));

      const mgr = new BackendLifecycleManager(APP_META, () => '/x');
      const startPromise = mgr.start('/db');
      // Push past waitForHealth's 30s budget with async timer advance so the
      // awaited 200ms sleeps inside the loop resolve correctly.
      await vi.advanceTimersByTimeAsync(31_000);

      await expect(startPromise).rejects.toThrow(/failed to start within timeout/);
      expect(mgr.status).toBe('error');
      expect(child.kill).toHaveBeenCalledWith('SIGKILL');

      fetchSpy.mockRestore();
    } finally {
      vi.useRealTimers();
    }
  });
});

describe('BackendLifecycleManager.stop', () => {
  it('sends SIGTERM then resolves when child emits exit', async () => {
    vi.mocked(createServer).mockImplementation(
      () => makeFakeServer(22222) as unknown as ReturnType<typeof createServer>
    );
    const child = makeFakeChild();
    vi.mocked(spawn).mockReturnValue(child as unknown as ChildProcess);

    const fetchSpy = vi
      .spyOn(globalThis, 'fetch')
      .mockResolvedValue(new Response('ok', { status: 200 }) as unknown as Response);

    const mgr = new BackendLifecycleManager(APP_META, () => '/x');
    await mgr.start('/db');

    const stopPromise = mgr.stop();
    // Simulate graceful child exit
    (child as unknown as EventEmitter).emit('exit', 0);
    await stopPromise;

    expect(child.kill).toHaveBeenCalledWith('SIGTERM');
    expect(mgr.status).toBe('stopped');

    fetchSpy.mockRestore();
  });

  it('escalates to SIGKILL when SIGTERM times out', async () => {
    vi.useFakeTimers();
    try {
      vi.mocked(createServer).mockImplementation(
        () => makeFakeServer(22223) as unknown as ReturnType<typeof createServer>
      );
      const child = makeFakeChild();
      vi.mocked(spawn).mockReturnValue(child as unknown as ChildProcess);

      const fetchSpy = vi
        .spyOn(globalThis, 'fetch')
        .mockResolvedValue(new Response('ok', { status: 200 }) as unknown as Response);

      const mgr = new BackendLifecycleManager(APP_META, () => '/x');
      await mgr.start('/db');

      const stopPromise = mgr.stop();
      await vi.advanceTimersByTimeAsync(5_100);
      await stopPromise;

      expect(vi.mocked(child.kill).mock.calls).toEqual(expect.arrayContaining([['SIGTERM'], ['SIGKILL']]));

      fetchSpy.mockRestore();
    } finally {
      vi.useRealTimers();
    }
  });
});

describe('BackendLifecycleManager crash restart', () => {
  it('attempts restart on unexpected exit within window', async () => {
    vi.useFakeTimers();
    try {
      // First createServer call assigns port 60001; subsequent restart uses port 60002
      let portCounter = 60000;
      vi.mocked(createServer).mockImplementation(
        () => makeFakeServer(++portCounter) as unknown as ReturnType<typeof createServer>
      );
      const child1 = makeFakeChild();
      const child2 = makeFakeChild();
      vi.mocked(spawn)
        .mockReturnValueOnce(child1 as unknown as ChildProcess)
        .mockReturnValueOnce(child2 as unknown as ChildProcess);

      const fetchSpy = vi
        .spyOn(globalThis, 'fetch')
        .mockResolvedValue(new Response('ok', { status: 200 }) as unknown as Response);

      const mgr = new BackendLifecycleManager(APP_META, () => '/x');
      await mgr.start('/db');
      expect(mgr.status).toBe('running');

      // Simulate first child crash
      (child1 as unknown as EventEmitter).emit('exit', 1);
      // handleCrash schedules restart after 1000ms (2^(1-1) * 1000)
      await vi.advanceTimersByTimeAsync(1_100);
      // Allow awaited findAvailablePort / spawn to settle
      await vi.advanceTimersByTimeAsync(0);

      expect(vi.mocked(spawn)).toHaveBeenCalledTimes(2);

      fetchSpy.mockRestore();
    } finally {
      vi.useRealTimers();
    }
  });
});

cd /Users/zhoukai/Documents/github/AionUi/packages/web-host
bunx vitest run backend-launcher.test.ts 2>&1 | tee /tmp/m4-phase2-test.log | tail -40

cd /Users/zhoukai/Documents/github/AionUi
git add packages/web-host/src/backend-launcher.test.ts
git commit -m "test(m4): mock-based unit tests for backend-launcher

Cover spawn arg shape, buildSpawnEnv merge, findAvailablePort,
start/stop happy path, health timeout, SIGKILL escalation, crash restart.
No real backend spawned; node:child_process / node:net / fetch all mocked."

{
  "name": "@aionui/desktop",
  "version": "0.0.0",
  "private": true,
  "description": "AionUi desktop Electron application",
  "main": "../../out/main/index.js"
}

{
  "name": "@aionui/desktop",
  "version": "0.0.0",
  "private": true,
  "description": "AionUi desktop Electron application",
  "main": "../../out/main/index.js",
  "dependencies": {
    "@aionui/web-host": "workspace:*"
  }
}

cd /Users/zhoukai/Documents/github/AionUi
bun install
# 验证 link 成立(两条之一应输出路径)
ls -la node_modules/@aionui/web-host 2>&1 || ls -la packages/desktop/node_modules/@aionui/web-host 2>&1

export { resolveBinaryPath } from './binaryResolver';
export { BackendLifecycleManager, buildSpawnArgs, buildSpawnEnv, findAvailablePort } from './lifecycleManager';
export type { BackendDirConfig } from './lifecycleManager';

export { resolveBinaryPath } from './binaryResolver';

import { BackendLifecycleManager } from '@process/backend';

import { BackendLifecycleManager } from '@aionui/web-host';
import { resolveBinaryPath } from '@process/backend';

const backendManager = new BackendLifecycleManager();

const backendManager = new BackendLifecycleManager(
  {
    version: app.getVersion(),
    isPackaged: app.isPackaged,
    resourcesPath: process.resourcesPath,
    userDataPath: app.getPath('userData'),
  },
  resolveBinaryPath
);

cd /Users/zhoukai/Documents/github/AionUi
bunx tsc --noEmit 2>&1 | tee /tmp/m4-phase3-tsc.log | tail -40

cd /Users/zhoukai/Documents/github/AionUi
git add packages/desktop/package.json packages/desktop/src/process/backend/index.ts packages/desktop/src/index.ts bun.lock
git status   # 核对文件清单
git commit -m "refactor(m4): wire desktop IPC to @aionui/web-host backend-launcher

- Add @aionui/web-host workspace dep to packages/desktop/package.json.
- Inject AppMetadata (from electron app.*) + resolveBinaryPath at
  BackendLifecycleManager construction site in packages/desktop/src/index.ts.
- Drop local re-export of lifecycle symbols in process/backend/index.ts; only
  resolveBinaryPath stays as the desktop-side BackendBinaryResolver impl."

cd /Users/zhoukai/Documents/github/AionUi
git rm packages/desktop/src/process/backend/lifecycleManager.ts

# 一:不应再有 import 指向旧路径
grep -rn "process/backend/lifecycleManager\|from '\./lifecycleManager'\|from \"\./lifecycleManager\"" packages/ 2>/dev/null
# 预期:无输出

# 二:不应再有 packages 外引用
grep -rn "process/backend/lifecycleManager" . \
  --include="*.ts" --include="*.tsx" --include="*.js" --include="*.json" \
  --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=out --exclude-dir=dist 2>/dev/null
# 预期:无输出

cd /Users/zhoukai/Documents/github/AionUi
bunx tsc --noEmit 2>&1 | tail -15
cd packages/web-host && bunx vitest run backend-launcher.test.ts 2>&1 | tail -10

cd /Users/zhoukai/Documents/github/AionUi
git add -A
git status
git commit -m "refactor(m4): remove obsolete packages/desktop/src/process/backend/lifecycleManager.ts"

cd /Users/zhoukai/Documents/github/AionUi
# 先清旧日志
rm -f /tmp/m4-dev.log

# 启动并后台收日志(25 秒窗口足够触发 backend spawn + health)
# 注意:不能用 `bun run dev &`,electron-vite 需要 stdin;改为 nohup
nohup bun run dev > /tmp/m4-dev.log 2>&1 &
DEV_PID=$!
echo "DEV_PID=$DEV_PID"

# 等 25 秒让 backend 起来
sleep 25

# 1) 日志里出现 backend 启动信息
grep -E "\[aionui-backend\] listening on port [0-9]+" /tmp/m4-dev.log | head -3

# 2) 解析端口
PORT=$(grep -oE "listening on port [0-9]+" /tmp/m4-dev.log | head -1 | grep -oE "[0-9]+$")
echo "BACKEND_PORT=$PORT"

# 3) /health 200
if [ -n "$PORT" ]; then
  curl -fsS -o /dev/null -w "HEALTH_STATUS=%{http_code}\n" "http://127.0.0.1:$PORT/health"
else
  echo "PORT_NOT_PARSED"
fi

# 找 backend 子进程(aionui-backend)
if [ -n "$PORT" ]; then
  BACKEND_PID=$(lsof -iTCP:$PORT -sTCP:LISTEN -nP 2>/dev/null | awk 'NR==2 {print $2}')
  echo "BACKEND_PID=$BACKEND_PID"
  if [ -n "$BACKEND_PID" ]; then
    kill -9 "$BACKEND_PID"
    # 按 handleCrash: 第 1 次重启 delay = 2^(1-1)*1000 = 1s
    sleep 4
    # 新的 backend 端口可能变了;重新扫描日志找到"最新"listening 行
    LATEST_PORT=$(grep -oE "listening on port [0-9]+" /tmp/m4-dev.log | tail -1 | grep -oE "[0-9]+$")
    echo "BACKEND_PORT_AFTER_RESTART=$LATEST_PORT"
    curl -fsS -o /dev/null -w "HEALTH_AFTER_RESTART=%{http_code}\n" "http://127.0.0.1:$LATEST_PORT/health"
  fi
fi

kill -TERM $DEV_PID 2>/dev/null || true
# 等父进程清理,Electron 不退出就 KILL
sleep 3
kill -9 $DEV_PID 2>/dev/null || true
# 以防 Electron 子进程残留
pgrep -f "electron-vite\|AionUi\|aionui-backend" | xargs -r kill -9 2>/dev/null || true

# 日志片段保存,handoff 要贴
grep -E "\[aionui-backend\] (starting|listening)" /tmp/m4-dev.log | head -6 > /tmp/m4-dev-evidence.log
cat /tmp/m4-dev-evidence.log

cd /Users/zhoukai/Documents/github/AionUi
bunx tsc --noEmit 2>&1 | tee /tmp/m4-final-tsc.log | tail -10

cd /Users/zhoukai/Documents/github/AionUi
bun run lint 2>&1 | tee /tmp/m4-final-lint.log | tail -10

bun run lint:fix
git add -A && git commit -m "style(m4): oxlint auto-fixes"

cd /Users/zhoukai/Documents/github/AionUi/packages/web-host
bunx vitest run backend-launcher.test.ts 2>&1 | tee /tmp/m4-final-wh-test.log | tail -20

cd /Users/zhoukai/Documents/github/AionUi
bun test 2>&1 | tee /tmp/m4-final-root-test.log | tail -20

cd /Users/zhoukai/Documents/github/AionUi
prek run --from-ref origin/feat/m3-web-host-skeleton --to-ref HEAD 2>&1 | tail -30

grep -rn "from ['\"]electron['\"]\|require(['\"]electron['\"])\|import \* as [a-zA-Z_]* from ['\"]electron['\"]" packages/web-host/src/
# 预期:无输出

grep -rnE "packages/desktop/src/process/(agent|worker|services)" packages/web-host/src/
# 预期:无输出

ls packages/desktop/src/process/backend/lifecycleManager.ts 2>&1
# 预期:No such file or directory

grep -rn "from ['\"]@aionui/web-host['\"]" packages/desktop/src/
# 预期:至少 1 行,且位置是 packages/desktop/src/index.ts

grep -rn "BackendLifecycleManager.*from.*@process/backend\|buildSpawnArgs.*from.*@process/backend\|buildSpawnEnv.*from.*@process/backend\|findAvailablePort.*from.*@process/backend\|BackendDirConfig.*from.*@process/backend" packages/
# 预期:无输出

grep -rn "import.*lifecycleManager" packages/desktop/src/
# 预期:无输出

cd /Users/zhoukai/Documents/github/AionUi
git status

git add bun.lock
git commit -m "chore(m4): update bun.lock for @aionui/web-host workspace link"

cd /Users/zhoukai/Documents/github/AionUi
git fetch origin feat/backend-migration
git log --oneline HEAD..origin/feat/backend-migration | head -10

# M4 backend-launcher 迁移 - 交付摘要

## 已交付

- 新建:`packages/web-host/src/backend-launcher.ts` 完整实现
  (`BackendLifecycleManager` 类 + `buildSpawnArgs` / `buildSpawnEnv` /
  `findAvailablePort` / `startBackend` / `stopBackend` / `BackendDirConfig` /
  `BackendLaunchOptions` / `BackendHandle`)
- 新建:`packages/web-host/src/backend-launcher.test.ts` 全 mock 覆盖
  (spawn 参数、buildSpawnEnv、findAvailablePort、start 成功、health 超时、
  SIGTERM→SIGKILL stop、crash 重启)
- 修改:`packages/web-host/src/index.ts` re-export backend-launcher 符号
- 修改:`packages/desktop/package.json` 新增 `@aionui/web-host: workspace:*`
- 修改:`packages/desktop/src/process/backend/index.ts` 只保留
  `resolveBinaryPath` 导出
- 修改:`packages/desktop/src/index.ts` 从 `@aionui/web-host` import
  `BackendLifecycleManager`,构造时注入 `AppMetadata` + `resolveBinaryPath`
- 删除:`packages/desktop/src/process/backend/lifecycleManager.ts`

## 对外接口(给 M5/M6 用)

- `new BackendLifecycleManager(appMeta: AppMetadata, resolveBackend: BackendBinaryResolver)`
- `startBackend(opts: { app, resolveBackend, port?, dataDir, logDir? }): Promise<{ port, stop }>`
- `AppMetadata` 的桌面注入点:`packages/desktop/src/index.ts`(`new BackendLifecycleManager({...})` 一处,其他里程碑不要再实例化)

## 与计划的偏离

- <无 / 列出>

## 给下一个里程碑的提醒

- `binaryResolver.ts` 还是 M4 前的"bundled → PATH"实现;UC-2 的严格分档由
  M7/M8/M9 落地
- `startWebHost` 的 `throw` 提示从 `M4:` 改成了 `M5:`
- crash 重启 e2e 在 dev 冒烟中<已覆盖 / 已跳过并原因>

## 验证证据(原始输出)

- 分支:feat/m4-backend-launcher-migration
- SHA:<填入 git rev-parse HEAD>
- 基线同步:origin/feat/backend-migration @ <基线 sha>(<已合入 / 无新 commit>)
- `bunx tsc --noEmit`:<贴 /tmp/m4-final-tsc.log 的 tail>
- `bun run lint`:<贴 /tmp/m4-final-lint.log 的 tail>
- `bunx vitest run backend-launcher.test.ts`:<贴 /tmp/m4-final-wh-test.log 的 tail>
- `bun run dev` backend 启动日志:<贴 /tmp/m4-dev-evidence.log>
- `curl /health`:<贴阶段 5.2 的 HEALTH_STATUS=200>
- grep 边界检查全部无输出(阶段 7.1/7.2/7.6):<贴输出或写 "no output">

## 遗留问题 / 跟进项

- <若跳过 crash 冒烟,写明原因;若 backend 二进制未就绪,写明并指向 M7>

cd /Users/zhoukai/Documents/github/AionUi
git add docs/backend-migration/handoffs/M4-outcome.md
git commit -m "docs(m4): handoff outcome for backend-launcher migration"
git rev-parse HEAD > /tmp/m4-final-sha.txt
cat /tmp/m4-final-sha.txt
git push -u origin feat/m4-backend-launcher-migration

SendMessage({
  to: "team-lead",
  summary: "M4 complete",
  message: "M4 完成。
  - 分支:feat/m4-backend-launcher-migration
  - SHA:<从 /tmp/m4-final-sha.txt 读>
  - 基线同步:origin/feat/backend-migration @ <基线 SHA>(已合入 / 无新 commit)
  - Handoff:docs/backend-migration/handoffs/M4-outcome.md
  - 偏离计划:<无 / 列出>
  请启动 M5。"
})

cd /Users/zhoukai/Documents/github/AionUi
# 若存在 e2e 脚本
grep -E "\"test:e2e\":" package.json && bun run test:e2e 2>&1 | tail -30

SendMessage({
  to: "team-lead",
  summary: "M4 blocked",
  message: "M4 执行被阻塞,需要人类决策。
  - 当前分支:feat/m4-backend-launcher-migration(本地,尚未 push)
  - 当前 SHA:<git rev-parse HEAD>
  - 问题:<简述>
  - 已尝试:<具体步骤>
  - 相关日志:<贴 tail 50 行>
  请决定如何处理。"
})

cd /Users/zhoukai/Documents/github/AionUi
git reset --hard origin/feat/m3-web-host-skeleton
git clean -fd
# 重新 install(因为 packages/desktop/package.json 回退了)
bun install

cd /Users/zhoukai/Documents/github/AionUi
git checkout feat/m3-web-host-skeleton
git branch -D feat/m4-backend-launcher-migration
git push origin --delete feat/m4-backend-launcher-migration
# 重建:从 0.3 开始

cd /Users/zhoukai/Documents/github/AionUi
git checkout feat/m4-backend-launcher-migration
# 修改问题代码
git commit -m "fix(m4): <describe fix>"
git push origin feat/m4-backend-launcher-migration
# 通知 M5 pull