@coze-arch/cli 0.1.8-alpha.e237ba → 0.1.8

package/lib/__templates__/vite/scripts/local-workspace.cjs

@@ -1,302 +0,0 @@
-#!/usr/bin/env node
-// Web source is owned by Drive. Only these wrappers may write to the local mirror.
-/* eslint-disable @typescript-eslint/no-require-imports -- Standalone CommonJS runtime shipped without CLI dependencies. */
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const { createHash } = require('node:crypto');
-const { spawn, execFileSync } = require('node:child_process');
-const { setTimeout: delay } = require('node:timers/promises');
-
-const scriptRoot = fs.realpathSync(path.resolve(__dirname, '..'));
-const source = fs.realpathSync(
-  process.env.COZE_WEB_LOCAL_ACTIVE === scriptRoot && process.env.COZE_WEB_SOURCE_PATH
-    ? process.env.COZE_WEB_SOURCE_PATH : scriptRoot,
-);
-const drivePath = path.resolve(process.env.COZE_DRIVE_ROOT || '/Coze/Drive');
-const drive = fs.existsSync(drivePath) ? fs.realpathSync(drivePath) : drivePath;
-const inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path.sep}`);
-const onDrive = inside(drive, source);
-const digest = value => createHash('sha256').update(value).digest('hex');
-// Separate from /tmp/nm: older dependency helpers clean unknown entries there.
-const cacheRoot = path.join(os.tmpdir(), `coze-web-${process.getuid()}`);
-const projectCache = path.join(cacheRoot, digest(source));
-const exclusions = [
-  'node_modules', '.git', '/logs', '.pnpm-store', '.next', '.nuxt', '.output',
-  '/dist', '/dist-server', '.cache', '.turbo', '*.tsbuildinfo',
-  '.eslintcache', '.stylelintcache', '/next-env.d.ts', '/tsconfig.json',
-];
-const installArgs = ['install', '--prefer-frozen-lockfile', '--prefer-offline'];
-let interrupted = false;
-const children = new Set();
-
-function stopTree(child) {
-  if (!child.pid || child.exitCode !== null) return;
-  // Keep descendants in the detached launcher's group so readiness ownership works.
-  // Also stop grandchildren when the test/foreground path is signalled directly.
-  let rows = [];
-  try {
-    rows = execFileSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8' })
-      .trim().split('\n').map(line => line.trim().split(/\s+/).map(Number));
-  } catch { /* The launcher still owns and reaps its process group. */ }
-  const pids = [child.pid];
-  for (let i = 0; i < pids.length; i++) {
-    for (const [pid, parent] of rows) if (parent === pids[i]) pids.push(pid);
-  }
-  for (const pid of pids.reverse()) {
-    try { process.kill(pid, 'SIGTERM'); } catch { /* Already exited. */ }
-  }
-  const timer = setTimeout(() => {
-    for (const pid of pids) {
-      try { process.kill(pid, 'SIGKILL'); } catch { /* Already exited. */ }
-    }
-  }, 2000);
-  timer.unref();
-}
-
-for (const signal of ['SIGINT', 'SIGTERM']) {
-  process.on(signal, () => {
-    interrupted = true;
-    process.exitCode = signal === 'SIGINT' ? 130 : 143;
-    for (const child of children) stopTree(child);
-  });
-}
-
-function run(command, args, cwd, env = process.env) {
-  if (interrupted) return Promise.reject(new Error('Interrupted'));
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, env, stdio: 'inherit' });
-    children.add(child);
-    child.once('error', error => { children.delete(child); reject(error); });
-    child.once('exit', (code, signal) => {
-      children.delete(child);
-      if (code === 0) resolve();
-      else reject(new Error(`${command} exited with ${signal || code}`));
-    });
-  });
-}
-
-function ensureCache() {
-  for (const dir of [cacheRoot, projectCache]) {
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    if (fs.lstatSync(dir).isSymbolicLink() || fs.statSync(dir).uid !== process.getuid()) {
-      throw new Error(`Refusing unmanaged workspace directory: ${dir}`);
-    }
-    if (inside(drive, fs.realpathSync(dir))) {
-      throw new Error(`Local workspace must be outside Coze Drive: ${dir}`);
-    }
-  }
-}
-
-async function locked(action, name = 'sync') {
-  const lock = path.join(projectCache, `${name}.lock`);
-  const started = Date.now();
-  let missingOwner = 0;
-  while (true) {
-    if (interrupted) throw new Error('Interrupted');
-    try { fs.mkdirSync(lock); break; } catch (error) {
-      if (error.code !== 'EEXIST') throw error;
-    }
-    let alive = false;
-    try {
-      const pid = Number(fs.readFileSync(path.join(lock, 'pid'), 'utf8'));
-      if (Number.isInteger(pid) && pid > 0) { process.kill(pid, 0); alive = true; }
-    } catch (error) { if (error.code === 'EPERM') alive = true; }
-    missingOwner = alive ? 0 : missingOwner + 1;
-    if (missingOwner >= 2) {
-      const stale = `${lock}.stale-${process.pid}`;
-      try {
-        fs.renameSync(lock, stale);
-        fs.rmSync(stale, { recursive: true });
-      } catch (error) { if (error.code !== 'ENOENT') throw error; }
-      missingOwner = 0;
-      continue;
-    }
-    if (Date.now() - started > 120000) throw new Error(`Timed out waiting for ${lock}`);
-    await delay(500);
-  }
-  fs.writeFileSync(path.join(lock, 'pid'), String(process.pid));
-  try { return await action(); }
-  finally { fs.rmSync(lock, { recursive: true, force: true }); }
-}
-
-async function sync(local) {
-  if (!fs.existsSync(path.join(source, 'package.json'))) {
-    throw new Error(`Source project is unavailable: ${source}`);
-  }
-  fs.mkdirSync(local, { recursive: true });
-  if (fs.realpathSync(local) !== local) throw new Error(`Refusing workspace symlink: ${local}`);
-  // Checksums catch same-size edits with unchanged/epoch Drive mtimes. Do not use -t:
-  // changed local files get fresh mtimes and unchanged files retain watcher snapshots.
-  // Materialize source links so the framework never follows them back onto Drive.
-  await run('rsync', [
-    '-rLp', '--checksum', '--delete', '--delay-updates',
-    ...exclusions.map(entry => `--exclude=${entry}`), `${source}/`, `${local}/`,
-  ], source);
-  // Next rewrites these inputs (dev/types vs types and tsconfig defaults). Preserve
-  // generated local changes until their canonical source content actually changes.
-  for (const file of ['next-env.d.ts', 'tsconfig.json']) {
-    const input = path.join(source, file);
-    const output = path.join(local, file);
-    const state = path.join(projectCache, `${path.basename(local)}.${file}.source`);
-    const fingerprint = fs.existsSync(input) ? digest(fs.readFileSync(input)) : 'missing';
-    if (readOptional(state).toString() !== fingerprint || !fs.existsSync(output)) {
-      if (fingerprint !== 'missing') fs.copyFileSync(input, output);
-      else fs.rmSync(output, { force: true });
-      fs.writeFileSync(state, fingerprint);
-    }
-  }
-}
-
-function readOptional(file) {
-  try { return fs.readFileSync(file); }
-  catch (error) { if (error.code === 'ENOENT') return Buffer.alloc(0); throw error; }
-}
-
-function installInput(root) {
-  const hash = createHash('sha256');
-  const visit = (dir, all = false) => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      if (['node_modules', '.git', 'logs', '.pnpm-store', '.next', '.nuxt', '.output', 'dist', 'dist-server', '.cache', '.turbo'].includes(entry.name)) continue;
-      const file = path.join(dir, entry.name);
-      // Follow source links just as rsync -L does, while detecting loops explicitly.
-      const real = fs.realpathSync(file);
-      if (entry.isDirectory() || (entry.isSymbolicLink() && fs.statSync(file).isDirectory())) {
-        if (ancestors.has(real)) throw new Error(`Source symlink cycle: ${file}`);
-        ancestors.add(real);
-        visit(file, all || entry.name === 'patches');
-        ancestors.delete(real);
-      }
-      else if (all || ['package.json', 'pnpm-lock.yaml', 'pnpm-workspace.yaml', '.npmrc', '.pnpmfile.cjs', '.pnpmfile.js'].includes(entry.name)) {
-        hash.update(path.relative(root, file)).update('\0').update(readOptional(file)).update('\0');
-      }
-    }
-  };
-  const ancestors = new Set([fs.realpathSync(root)]);
-  visit(root);
-  return hash.digest('hex');
-}
-
-function localEnv(local) {
-  return {
-    ...process.env,
-    COZE_WEB_LOCAL_ACTIVE: local,
-    COZE_WEB_SOURCE_PATH: source,
-    COZE_WEB_LOCAL_MIRROR: onDrive ? '1' : '',
-    COZE_WORKSPACE_PATH: local,
-    // Keep the existing discoverable log/PID location in the source project.
-    COZE_LOG_DIR: process.env.COZE_LOG_DIR || path.join(source, 'logs'),
-    PWD: local,
-    INIT_CWD: local,
-    ...(onDrive ? { npm_config_store_dir: path.join(cacheRoot, 'store') } : {}),
-  };
-}
-
-async function install(local, mode) {
-  const state = path.join(projectCache, `${mode}.install`);
-  const version = execFileSync('pnpm', ['--version'], { encoding: 'utf8' }).trim();
-  const fingerprint = () => digest([
-    installInput(local), version, process.version, process.env.NODE_ENV,
-    process.env.npm_config_production, process.env.NPM_CONFIG_PRODUCTION,
-    process.env.PNPM_CONFIG_PRODUCTION,
-  ].join('\n'));
-  // Lifecycle scripts may generate files from arbitrary source, so do not reuse
-  // their install based on dependency metadata alone. Read manifests as text here
-  // (no executable hooks or private CLI dependencies in the standalone helper).
-  const manifest = readOptional(path.join(local, 'package.json')).toString();
-  const hasLifecycle = /"(?:install|postinstall|prepare)"\s*:/.test(manifest);
-  // Workspace and local file dependencies can run lifecycles outside the root.
-  // Let pnpm validate those installs instead of assuming the root marker is enough.
-  const hasLocalDependencies = fs.existsSync(path.join(local, 'pnpm-workspace.yaml')) ||
-    /"(?:workspace|file|link):/.test(manifest);
-  const hasHooks = ['.pnpmfile.cjs', '.pnpmfile.js'].some(file => fs.existsSync(path.join(local, file))) ||
-    /^\s*pnpmfile\s*=/m.test(readOptional(path.join(local, '.npmrc')).toString());
-  if (!hasLifecycle && !hasHooks && !hasLocalDependencies && readOptional(state).toString() === fingerprint() &&
-      fs.existsSync(path.join(local, 'node_modules', '.modules.yaml'))) return;
-  fs.rmSync(state, { force: true });
-  const before = installInput(source);
-  if (before !== installInput(local)) {
-    throw new Error('Dependency inputs changed during sync; rerun prepare.sh.');
-  }
-  await run('pnpm', [...installArgs, '--store-dir', path.join(cacheRoot, 'store')], local, localEnv(local));
-  if (before !== installInput(source)) {
-    throw new Error('Dependency inputs changed on Drive during installation; rerun prepare.sh. Lockfile was not overwritten.');
-  }
-  const lockfile = path.join(local, 'pnpm-lock.yaml');
-  if (fs.existsSync(lockfile) && !readOptional(lockfile).equals(readOptional(path.join(source, 'pnpm-lock.yaml')))) {
-    const temporary = path.join(source, `.pnpm-lock.yaml.${process.pid}.tmp`);
-    try {
-      fs.copyFileSync(lockfile, temporary);
-      fs.renameSync(temporary, path.join(source, 'pnpm-lock.yaml'));
-    } finally { fs.rmSync(temporary, { force: true }); }
-  }
-  fs.writeFileSync(state, fingerprint());
-}
-
-async function watch(args) {
-  const local = fs.realpathSync(process.env.COZE_WEB_LOCAL_ACTIVE || path.resolve(__dirname, '..'));
-  if (!onDrive) return run(args[0], args.slice(1), local);
-  ensureCache();
-  if (local !== path.join(fs.realpathSync(projectCache), 'dev')) {
-    throw new Error(`Refusing to watch an unmanaged workspace: ${local}`);
-  }
-  const preparedInput = installInput(local);
-  let running = true;
-  let syncError;
-  const command = run(args[0], args.slice(1), local).finally(() => { running = false; });
-  const poll = (async () => {
-    while (running && !interrupted) {
-      await delay(1000);
-      if (!running || interrupted) break;
-      try {
-        await locked(async () => {
-          await sync(local);
-          if (installInput(local) !== preparedInput) {
-            throw new Error('Dependency inputs changed; rerun prepare.sh and dev.sh before previewing.');
-          }
-        });
-      }
-      catch (error) {
-        syncError = error;
-        for (const child of children) stopTree(child);
-        break;
-      }
-    }
-  })();
-  const results = await Promise.allSettled([command, poll]);
-  if (syncError) throw syncError;
-  if (results[0].status === 'rejected') throw results[0].reason;
-}
-
-async function main() {
-  const [action, ...args] = process.argv.slice(2);
-  if (action === 'watch') return watch(args);
-  if (!['prepare', 'dev', 'validate'].includes(action)) throw new Error(`Unknown Web action: ${action}`);
-  if (!onDrive) {
-    return run('bash', [path.join(source, 'scripts', `${action}.sh`), ...args], source, localEnv(source));
-  }
-  ensureCache();
-  const mode = action === 'validate' ? 'check' : 'dev';
-  const local = path.join(fs.realpathSync(projectCache), mode);
-  console.log(`[web] Source: ${source}\n[web] Local ${mode} workspace: ${local}`);
-  if (action === 'validate') {
-    return locked(async () => {
-      await locked(async () => {
-        await sync(local);
-        await install(local, mode);
-      });
-      await run('bash', [path.join(local, 'scripts', 'validate.sh'), ...args], local, localEnv(local));
-    }, 'check');
-  } else {
-    await locked(async () => {
-      await sync(local);
-      await install(local, mode);
-    });
-  }
-  await run('bash', [path.join(local, 'scripts', `${action}.sh`), ...args], local, localEnv(local));
-}
-
-main().catch(error => {
-  console.error(`[web] ${error.message}`);
-  process.exitCode = process.exitCode || 1;
-});