@redue/cli 0.0.0-stage → 0.1.0-alpha.11

package/src/windows-process.mjs

@@ -0,0 +1,15 @@
+import {spawn} from 'node:child_process';
+
+// taskkill /T is the native narrow process-tree operation available without
+// elevation. It cannot own deliberately detached descendants.
+export function terminateWindowsTree(pid,{start=spawn,timeoutMs=5000}={}) {
+  if(!Number.isSafeInteger(pid)||pid<1)return Promise.reject(Error('invalid check PID'));
+  return new Promise((resolve,reject)=>{
+    const child=start('taskkill.exe',['/PID',String(pid),'/T','/F'],
+      {stdio:'ignore',windowsHide:true});
+    const timer=setTimeout(()=>{child.kill();reject(Error('taskkill deadline exceeded'));},timeoutMs);
+    child.once('error',error=>{clearTimeout(timer);reject(error);});
+    child.once('close',code=>{clearTimeout(timer);code===0?resolve():
+      reject(Error(`taskkill exited ${code}`));});
+  });
+}

package/src/yarn-workspace-inputs.mjs

@@ -0,0 +1,148 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {execFileSync} from 'node:child_process';
+import {createRequire} from 'node:module';
+import micromatch from './glob.mjs';
+import {withinPath as within,realObservedPath} from './path-identity.mjs';
+
+export function yarnLocalTsc(root){
+  const expected=path.join(root,'node_modules','typescript','bin','tsc');
+  if(process.platform==='win32'){
+    const shim=path.join(root,'node_modules','.bin','tsc.cmd');
+    const body=fs.readFileSync(shim,'utf8').replace(/\r\n/g,'\n').trim();
+    const standard=`@IF EXIST "%~dp0\\node.exe" (
+  "%~dp0\\node.exe"  "%~dp0\\..\\typescript\\bin\\tsc" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\\..\\typescript\\bin\\tsc" %*
+)`;
+    if(body!==standard)throw Error('local TypeScript executable is not the installed compiler');
+    return realObservedPath(expected);
+  }
+  const tsc=realObservedPath(path.join(root,'node_modules','.bin','tsc'));
+  if(tsc!==expected)throw Error('local TypeScript executable is not the installed compiler');
+  return tsc;
+}
+
+const posix=file=>file.split(path.sep).join('/');
+const read=file=>JSON.parse(fs.readFileSync(file,'utf8'));
+const relative=(root,file)=>posix(path.relative(root,file));
+const safeDirectory=(root,dir)=>{
+  const full=path.resolve(root,dir);
+  if(!within(full,root))throw Error('workspace path escapes checkout');
+  return full;
+};
+
+export function yarnWorkspacePackages(root){
+  root=realObservedPath(root);
+  const pkg=read(path.join(root,'package.json'));
+  const patterns=Array.isArray(pkg.workspaces)?pkg.workspaces:pkg.workspaces?.packages;
+  if(!Array.isArray(patterns)||!patterns.length||patterns.some(value=>
+    typeof value!=='string'||path.isAbsolute(value)||value.split('/').includes('..')))
+    throw Error('workspace declarations are unsupported');
+  const files=execFileSync('git',['ls-files','--cached','--others','--exclude-standard',
+    '-z','--',':(glob)**/package.json'],{cwd:root,env:{...process.env,GIT_OPTIONAL_LOCKS:'0'},
+    maxBuffer:32*1024*1024,timeout:5000}).toString().split('\0').filter(Boolean);
+  const found=new Map();
+  for(const file of files){
+    const dir=path.posix.dirname(file);
+    if(dir==='.'||dir.split('/').includes('node_modules')||
+      !micromatch.isMatch(dir,patterns,{dot:true}))continue;
+    const member=read(path.join(root,file));
+    if(!member.name||found.has(member.name))throw Error('workspace package name missing or duplicated');
+    found.set(member.name,{name:member.name,dir,manifest:file,pkg:member});
+  }
+  if(found.size>50)throw Error('workspace count exceeds narrow Node onboarding contract');
+  return found;
+}
+
+function parsedTypeScript(root,dir){
+  const require=createRequire(path.join(root,'package.json'));
+  const ts=require(path.join(root,'node_modules','typescript'));
+  const config=path.join(root,dir,'tsconfig.json'),reads=new Set();
+  const host={...ts.sys,readFile(file){reads.add(path.resolve(file));return ts.sys.readFile(file);},
+    onUnRecoverableConfigFileDiagnostic(){}};
+  const parsed=ts.getParsedCommandLineOfConfigFile(config,{},host);
+  if(!parsed||parsed.errors?.length)throw Error('TypeScript configuration unavailable');
+  const raw=ts.readConfigFile(config,ts.sys.readFile);
+  if(raw.error||!Array.isArray(raw.config?.include)||raw.config.include.length!==1||
+    !['src','src/**/*','src/**'].includes(raw.config.include[0]))
+    throw Error('workspace TypeScript file membership is outside the supported src include');
+  if(parsed.options.plugins?.length||parsed.options.incremental||parsed.options.composite)
+    throw Error('TypeScript plugins or incremental/project builds are outside this contract');
+  if(parsed.options.paths||parsed.options.baseUrl||parsed.options.rootDirs?.length||
+    parsed.options.typeRoots?.length||parsed.options.customConditions?.length||
+    parsed.options.moduleSuffixes?.length||
+    parsed.options.moduleResolution!==undefined&&
+      parsed.options.moduleResolution!==ts.ModuleResolutionKind.Node10)
+    throw Error('custom TypeScript module resolution needs explicit input coverage');
+  if(parsed.projectReferences?.length)throw Error('TypeScript project references need a separate contract');
+  for(const file of reads)if(!within(realObservedPath(file),root))
+    throw Error(`TypeScript configuration escapes the checkout: ${path.basename(file)}`);
+  return {parsed,configs:[...reads].map(file=>relative(root,file)).sort()};
+}
+
+export function yarnWorkspaceTypecheckInputs(root,workspace,script){
+  root=realObservedPath(root);
+  const rootPkg=read(path.join(root,'package.json'));
+  if(!/^yarn@4\./.test(rootPkg.packageManager||''))throw Error('pinned Yarn 4 required');
+  const yarnrc=fs.readFileSync(path.join(root,'.yarnrc.yml'),'utf8');
+  const linker=yarnrc.match(/^\s*nodeLinker\s*:\s*['"]?([\w-]+)/m)?.[1];
+  const mode=yarnrc.match(/^\s*nmMode\s*:\s*['"]?([\w-]+)/m)?.[1]||'classic';
+  if(linker!=='node-modules'||mode!=='classic')
+    throw Error('Yarn node-modules classic installation required');
+  if(/^\s*(?:yarnPath|plugins)\s*:/m.test(yarnrc))
+    throw Error('custom Yarn executable or plugins need explicit toolchain coverage');
+  const members=yarnWorkspacePackages(root),selected=members.get(workspace);
+  if(!selected)throw Error(`workspace ${workspace} is not declared`);
+  if(selected.pkg.scripts?.[script]?.trim()!=='tsc -p .'||
+    selected.pkg.scripts?.['pre'+script]||selected.pkg.scripts?.['post'+script])
+    throw Error('workspace typecheck must be standalone tsc -p .');
+  const packageDir=safeDirectory(root,selected.dir);
+  if(fs.existsSync(path.join(packageDir,'node_modules','.bin','tsc'))||
+    fs.existsSync(path.join(packageDir,'node_modules','.bin','tsc.cmd')))
+    throw Error('workspace-local TypeScript executable needs separate toolchain coverage');
+  const {parsed,configs}=parsedTypeScript(root,selected.dir);
+  const outDir=parsed.options.outDir&&within(path.resolve(parsed.options.outDir),root)?
+    relative(root,path.resolve(parsed.options.outDir)):null;
+  if(!parsed.options.noEmit&&!outDir)
+    throw Error('emitting TypeScript check needs an in-checkout outDir');
+  if(outDir&&within(path.join(root,outDir),path.join(packageDir,'src')))
+    throw Error('TypeScript output overlaps observed source inputs');
+  const closure=new Map(),visit=member=>{
+    for(const name of Object.keys({...member.pkg.dependencies,...member.pkg.devDependencies,
+      ...member.pkg.peerDependencies,...member.pkg.optionalDependencies})){
+      const dep=members.get(name);if(!dep||dep.name===selected.name||closure.has(name))continue;
+      closure.set(name,dep);visit(dep);
+    }
+  };
+  visit(selected);
+  const source=[...new Set(['package.json','yarn.lock','.yarnrc.yml',
+    selected.manifest,...configs,`${selected.dir}/src/**`])];
+  const installed=['node_modules/**',`${selected.dir}/node_modules/**`];
+  const generated=[];
+  const linkTriggers=[];
+  for(const member of members.values()){
+    const logical=`node_modules/${member.name}`;
+    installed.push(`!${logical}`,`!${logical}/**`);
+    if(!closure.has(member.name))continue;
+    installed.push(`${member.dir}/node_modules/**`);
+    const declaration=member.pkg.types||member.pkg.typings;
+    if(!declaration||path.isAbsolute(declaration)||declaration.split('/').includes('..'))
+      throw Error(`${member.name} has no supported declaration-output location`);
+    const output=path.posix.dirname(declaration);
+    const outputDir=output==='.'?member.dir:`${member.dir}/${output}`;
+    generated.push(`${outputDir}/**`);
+    source.push(member.manifest);
+    // The logical link is part of resolution identity even though its target
+    // contents are indexed at the physical workspace output location.
+    linkTriggers.push(logical);
+  }
+  yarnLocalTsc(root);
+  return {workspace:selected,closure:[...closure.values()],source:[...new Set(source)],
+    installed,generated:[...new Set(generated)],configs,
+    configurationInputs:[...new Set(['package.json','yarn.lock','.yarnrc.yml',
+      ...configs,...members.values().map(row=>row.manifest),
+      'node_modules/.yarn-state.yml'])],linkTriggers,outDir};
+}

package/src/yarn-workspace-typecheck-probe.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// Read-only applicability probe. Its output is one digest or a fixed reason;
+// source, configuration, environment values, and command output are not logged.
+import {compilerFiles} from './typescript-list.mjs';
+import {contextOnly,probeResult} from './probe-result.mjs';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {createHash} from 'node:crypto';
+import {spawnSync} from 'node:child_process';
+import {yarnWorkspaceTypecheckInputs,yarnLocalTsc} from './yarn-workspace-inputs.mjs';
+import {withinPath as within,realObservedPath} from './path-identity.mjs';
+import {windowsLaunch} from './windows-command.mjs';
+
+const [rootArg,workspace,script,yarnArg]=process.argv.slice(2);
+const hash=value=>createHash('sha256').update(value).digest('hex');
+const digestFile=file=>hash(fs.readFileSync(file));
+const fail=code=>{throw Object.assign(Error(code),{code});};
+function yarnDistribution(yarn,version){
+  let loader=yarn;
+  if(process.platform==='win32'&&/\.cmd$/i.test(yarn)){
+    const body=fs.readFileSync(yarn,'utf8').replace(/\r\n/g,'\n').trim();
+    const line=body.split('\n')[2]||'';
+    const match=/^  "%~dp0\\node\.exe"  "%~dp0\\(.+\\corepack\\dist\\yarn\.js)" %\*$/.exec(line);
+    if(!match)fail('yarn-distribution-unobservable');
+    const relative=match[1];
+    const standard=`@SETLOCAL
+@IF EXIST "%~dp0\\node.exe" (
+  "%~dp0\\node.exe"  "%~dp0\\${relative}" %*
+) ELSE (
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\\${relative}" %*
+)`;
+    if(body!==standard)fail('yarn-distribution-unobservable');
+    loader=realObservedPath(path.resolve(path.dirname(yarn),relative));
+  }
+  if(!/[/\\]corepack[/\\]dist[/\\]yarn\.js$/.test(loader))
+    return {distribution:yarn,loader};
+  if(process.env.COREPACK_HOME&&!path.isAbsolute(process.env.COREPACK_HOME))
+    fail('yarn-distribution-unobservable');
+  const candidates=process.env.COREPACK_HOME?
+    [path.join(process.env.COREPACK_HOME,'v1/yarn',version,'yarn.js')]:[
+      ...(process.platform==='win32'&&path.isAbsolute(process.env.LOCALAPPDATA||'')?
+        [path.join(process.env.LOCALAPPDATA,'node/corepack/v1/yarn',version,'yarn.js')]:[]),
+      path.join(os.homedir(),'.cache/node/corepack/v1/yarn',version,'yarn.js'),
+      path.join(os.homedir(),'Library/Caches/node/corepack/v1/yarn',version,'yarn.js')];
+  const found=candidates.find(file=>fs.existsSync(file));
+  if(!found)fail('yarn-distribution-unobservable');
+  return {distribution:found,loader};
+}
+try{
+  if(!rootArg||!workspace||!script||!yarnArg)fail('probe-arguments');
+  const root=realObservedPath(rootArg),yarn=realObservedPath(yarnArg);
+  const pkg=JSON.parse(fs.readFileSync(path.join(root,'package.json')));
+  if(process.env.NODE_OPTIONS||process.env.NODE_PATH||process.env.BASH_ENV||
+    process.env.ENV||Object.entries(process.env).some(([key,value])=>{
+      if(/^npm_config_prefix$/i.test(key)&&process.platform==='win32'){
+        return !path.isAbsolute(value);
+      }
+      if(key==='COREPACK_HOME')return !path.isAbsolute(value);
+      return /^(YARN_|COREPACK_|npm_config_|DYLD_|TSGO_)/i.test(key);
+    }))
+    fail('workspace-execution-environment-unsupported');
+  const launch=windowsLaunch([yarn,'--version']);
+  const version=spawnSync(launch.file,launch.args,{cwd:root,env:process.env,
+    ...launch.options,
+    encoding:'utf8',timeout:3000,maxBuffer:1024*1024,stdio:['ignore','pipe','pipe']});
+  if(version.error||version.signal||version.status!==0||
+    `yarn@${version.stdout.trim()}`!==pkg.packageManager)
+    fail('yarn-toolchain-unavailable');
+  const distribution=yarnDistribution(yarn,version.stdout.trim());
+  const contextFacts={yarnVersion:version.stdout.trim(),yarnShim:digestFile(yarn),
+    yarnLoader:digestFile(distribution.loader),
+    yarnDistribution:digestFile(distribution.distribution),node:process.version};
+  const contextHash=hash(JSON.stringify(contextFacts));
+  if(contextOnly(contextHash))process.exit(0);
+  const contract=yarnWorkspaceTypecheckInputs(root,workspace,script);
+  const cwd=path.join(root,contract.workspace.dir);
+  const tsc=yarnLocalTsc(root);
+  const captured=process.argv.includes('--redue-checkpoint')?compilerFiles(path.join(root,'node_modules/typescript'),cwd):null;
+  const listed=captured?{status:0,stdout:captured.files.join('\n')}:spawnSync(process.execPath,[tsc,'-p','.','--listFilesOnly'],
+    {cwd,env:process.env,encoding:'utf8',timeout:4000,maxBuffer:16*1024*1024,
+      stdio:['ignore','pipe','pipe']});
+  if(listed.error||listed.signal||listed.status!==0)fail('typescript-input-list-unavailable');
+  const inputs=listed.stdout.trim().split(/\r?\n/).filter(Boolean)
+    .map(file=>realObservedPath(file));
+  if(!inputs.length)fail('typescript-input-list-unavailable');
+  const selectedRoot=path.join(cwd,'src'),installedRoot=path.join(root,'node_modules');
+  const nestedInstalled=[contract.workspace,...contract.closure]
+    .map(member=>path.join(root,member.dir,'node_modules'));
+  const generated=contract.generated.map(value=>path.join(root,value.slice(0,-3)));
+  for(const file of inputs){
+    const covered=within(file,installedRoot)||nestedInstalled.some(dir=>within(file,dir))||
+      within(file,selectedRoot)||
+      generated.some(dir=>within(file,dir));
+    if(!covered||!within(file,root))fail('typescript-input-outside-workspace-contract');
+  }
+  const files=[...new Set(inputs)].sort().map(file=>
+    [hash(path.relative(root,file)),digestFile(file)]);
+  const configs=contract.configs.map(file=>[hash(file),digestFile(path.join(root,file))]);
+  probeResult(hash(JSON.stringify({schema:1,workspace,script,
+    files,configs,yarnVersion:version.stdout.trim(),yarnShim:digestFile(yarn),
+    yarnLoader:digestFile(distribution.loader),
+    yarnDistribution:digestFile(distribution.distribution),
+    node:process.version,tsc:digestFile(tsc)})),contextHash,captured?.queries);
+}catch(e){console.error(`VSTATE_REASON:${e.code&&/^[a-z-]+$/.test(e.code)?e.code:
+  'workspace-typecheck-contract-unavailable'}`);process.exitCode=2;}