mecord-connect 1.0.0

package/runtime/app/src/core/trusted-executable.js

@@ -0,0 +1,124 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { OperatorError } from './errors.js';
+
+const WINDOWS_NATIVE_EXTENSIONS = ['.exe', '.com']         ;
+const MIN_GIT_MAJOR = 2;
+const MIN_GIT_MINOR = 45;
+const GIT_VERSION_CACHE = new Map                                           ();
+
+export function assertSupportedGitVersionText(output        )                                                  {
+  const match = /^git version (\d+)\.(\d+)(?:\.(\d+))?(?:[.\-][^\s]+)?$/i.exec(String(output ?? '').trim());
+  if (!match) {
+    throw new OperatorError('GIT_VERSION_CHECK_FAILED', 'Operator could not parse the trusted Git executable version.');
+  }
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3] ?? 0);
+  if (major < MIN_GIT_MAJOR || (major === MIN_GIT_MAJOR && minor < MIN_GIT_MINOR)) {
+    throw new OperatorError(
+      'GIT_VERSION_UNSUPPORTED',
+      `Operator Git capabilities require Git ${MIN_GIT_MAJOR}.${MIN_GIT_MINOR} or newer so lazy promisor fetching can be disabled fail-closed.`
+    );
+  }
+  return { major, minor, patch };
+}
+
+export function resolveSupportedGitExecutable(source                    = process.env)         {
+  const executable = resolveTrustedExecutable('git', source);
+  const stat = fs.statSync(executable);
+  const cacheKey = process.platform === 'win32' ? executable.toLowerCase() : executable;
+  const cached = GIT_VERSION_CACHE.get(cacheKey);
+  if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return executable;
+
+  const result = spawnSync(executable, ['--version'], {
+    shell: false,
+    windowsHide: true,
+    encoding: 'utf8',
+    timeout: 5_000,
+    maxBuffer: 32 * 1024,
+    env: gitVersionProbeEnvironment(source)
+  });
+  if (result.error || result.status !== 0) {
+    throw new OperatorError('GIT_VERSION_CHECK_FAILED', 'Operator could not verify the trusted Git executable version.');
+  }
+  assertSupportedGitVersionText(String(result.stdout ?? ''));
+  GIT_VERSION_CACHE.set(cacheKey, { size: stat.size, mtimeMs: stat.mtimeMs });
+  return executable;
+}
+
+export function resolveTrustedExecutable(
+  input        ,
+  source                    = process.env
+)         {
+  const executable = String(input ?? '').trim();
+  if (!executable || executable.includes('\0')) {
+    throw new OperatorError('EXECUTABLE_INVALID', 'Executable must be a non-empty path or command name without NUL bytes.');
+  }
+
+  if (path.isAbsolute(executable)) return validateNativeExecutable(executable);
+  if (/[\\/]/.test(executable)) {
+    throw new OperatorError('EXECUTABLE_PATH_UNTRUSTED', 'Relative executable paths are not allowed.');
+  }
+
+  const pathValue = source.PATH ?? source.Path ?? '';
+  for (const rawDirectory of String(pathValue).split(path.delimiter)) {
+    const directory = stripOuterQuotes(rawDirectory.trim());
+    if (!directory || !path.isAbsolute(directory)) continue;
+    for (const name of candidateNames(executable, source)) {
+      const candidate = path.resolve(directory, name);
+      const resolved = tryNativeExecutable(candidate);
+      if (resolved) return resolved;
+    }
+  }
+
+  throw new OperatorError('EXECUTABLE_NOT_FOUND', `Trusted executable ${executable} was not found in absolute PATH directories.`);
+}
+function candidateNames(executable        , source                   )           {
+  if (process.platform !== 'win32') return [executable];
+  const extension = path.win32.extname(executable).toLowerCase();
+  if (extension) {
+    if (!WINDOWS_NATIVE_EXTENSIONS.includes(extension                   )) {
+      throw new OperatorError('EXECUTABLE_SCRIPT_DENIED', 'Windows command scripts are not valid shell-free executable authority.');
+    }
+    return [executable];
+  }
+  void source;
+  return WINDOWS_NATIVE_EXTENSIONS.map((item) => `${executable}${item}`);
+}
+
+function validateNativeExecutable(candidate        )         {
+  const resolved = tryNativeExecutable(candidate);
+  if (!resolved) throw new OperatorError('EXECUTABLE_NOT_FOUND', `Trusted executable does not exist or is not executable: ${candidate}`);
+  return resolved;
+}
+
+function tryNativeExecutable(candidate        )                     {
+  if (process.platform === 'win32') {
+    const extension = path.win32.extname(candidate).toLowerCase();
+    if (!WINDOWS_NATIVE_EXTENSIONS.includes(extension                   )) return undefined;
+  }
+  try {
+    const resolved = fs.realpathSync.native(candidate);
+    if (!path.isAbsolute(resolved) || !fs.statSync(resolved).isFile()) return undefined;
+    if (process.platform !== 'win32') fs.accessSync(resolved, fs.constants.X_OK);
+    return resolved;
+  } catch {
+    return undefined;
+  }
+}
+
+function stripOuterQuotes(value        )         {
+  return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}
+
+function gitVersionProbeEnvironment(source                   )                    {
+  const env                    = { LANG: 'C', LC_ALL: 'C' };
+  if (process.platform === 'win32') {
+    for (const key of ['SYSTEMROOT', 'WINDIR']) {
+      if (source[key] !== undefined) env[key] = source[key];
+    }
+  }
+  return env;
+}

package/runtime/app/src/core/types.js

@@ -0,0 +1,83 @@
+                                                                                  
+                                                                                                                       
+                                                      
+                            
+          
+             
+                    
+             
+             
+          
+                 
+               
+
+                             
+                       
+                  
+ 
+
+                           
+               
+                         
+                  
+                                 
+                    
+ 
+
+                                
+             
+                     
+                   
+                                 
+                         
+                  
+                  
+ 
+
+                               
+              
+                     
+                   
+                   
+                       
+           
+                 
+                    
+                        
+    
+                     
+ 
+
+                                    
+                                
+                         
+                               
+                                
+                               
+                             
+ 
+
+                                  
+                      
+                  
+                      
+                   
+                        
+                             
+                          
+ 
+
+                                             
+                       
+                           
+ 
+
+                                     
+               
+                                                              
+                                                                 
+                                                                           
+                                                                        
+                                                                                              
+                                 
+ 

package/runtime/app/src/core/windows-path-lease.js

@@ -0,0 +1,138 @@
+import { spawn,                                     } from 'node:child_process';
+import path from 'node:path';
+import { OperatorError } from './errors.js';
+import { safeChildEnvironment } from './child-environment.js';
+
+const READY_TIMEOUT_MS = 5_000;
+const RELEASE_TIMEOUT_MS = 5_000;
+const MAX_HELPER_TEXT_BYTES = 4 * 1024;
+
+                                                         
+
+                                          
+               
+                 
+                             
+                      
+ 
+
+export async function withWindowsPathLease   (
+  options                         ,
+  operation                  
+)             {
+  if (process.platform !== 'win32') return await operation();
+  const executable = options.executable ?? process.env.OPERATOR_WINDOWS_PATH_LEASE_PATH;
+  if (!executable || !path.isAbsolute(executable)) {
+    throw new OperatorError(
+      'WINDOWS_PATH_LEASE_HELPER_REQUIRED',
+      'Windows filesystem operations require the packaged path-lease helper.'
+    );
+  }
+  const child = spawn(executable, ['lease', options.mode, options.root, options.target], {
+    shell: false,
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: safeChildEnvironment('windows-native')
+  });
+  await waitForReady(child);
+
+  let value               ;
+  let operationError         ;
+  try {
+    value = await operation();
+  } catch (error) {
+    operationError = error;
+  }
+
+  let releaseError         ;
+  try {
+    await releaseLease(child);
+  } catch (error) {
+    releaseError = error;
+  }
+  if (operationError) throw operationError;
+  if (releaseError) throw releaseError;
+  return value     ;
+}
+
+async function waitForReady(child                                )                {
+  await new Promise      ((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const finish = (error                ) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(error); else resolve();
+    };
+    child.once('error', () => finish(new OperatorError(
+      'WINDOWS_PATH_LEASE_HELPER_FAILED',
+      'Windows path-lease helper could not be started.'
+    )));
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk        ) => {
+      if (Buffer.byteLength(stderr, 'utf8') >= MAX_HELPER_TEXT_BYTES) return;
+      stderr = (stderr + chunk).slice(0, MAX_HELPER_TEXT_BYTES);
+    });
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk        ) => {
+      if (settled) return;
+      stdout += chunk;
+      if (Buffer.byteLength(stdout, 'utf8') > MAX_HELPER_TEXT_BYTES) {
+        finish(new OperatorError('WINDOWS_PATH_LEASE_HELPER_FAILED', 'Windows path-lease helper returned invalid output.'));
+        return;
+      }
+      const newline = stdout.indexOf('\n');
+      if (newline < 0) return;
+      if (stdout.slice(0, newline).trim() !== 'READY') {
+        finish(new OperatorError('WINDOWS_PATH_LEASE_DENIED', 'Windows path authority validation failed.'));
+        return;
+      }
+      finish();
+    });
+    child.once('close', (code) => {
+      if (!settled) finish(new OperatorError(
+        'WINDOWS_PATH_LEASE_DENIED',
+        code === 0
+          ? 'Windows path-lease helper exited before establishing authority.'
+          : 'Windows path authority validation failed.'
+      ));
+    });
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      finish(new OperatorError('WINDOWS_PATH_LEASE_TIMEOUT', 'Windows path authority validation timed out.'));
+    }, READY_TIMEOUT_MS);
+    timer.unref();
+  });
+}
+
+async function releaseLease(child                                )                {
+  if (child.exitCode !== null) {
+    if (child.exitCode === 0) return;
+    throw new OperatorError('WINDOWS_PATH_LEASE_HELPER_FAILED', 'Windows path-lease helper exited unexpectedly.');
+  }
+  child.stdin.end();
+  await new Promise      ((resolve, reject) => {
+    let settled = false;
+    const finish = (error                ) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(error); else resolve();
+    };
+    child.once('error', () => finish(new OperatorError(
+      'WINDOWS_PATH_LEASE_HELPER_FAILED',
+      'Windows path-lease helper failed while releasing authority.'
+    )));
+    child.once('close', (code) => {
+      if (code === 0) finish();
+      else finish(new OperatorError('WINDOWS_PATH_LEASE_HELPER_FAILED', 'Windows path-lease helper failed while releasing authority.'));
+    });
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      finish(new OperatorError('WINDOWS_PATH_LEASE_TIMEOUT', 'Windows path-lease helper did not release authority in time.'));
+    }, RELEASE_TIMEOUT_MS);
+    timer.unref();
+  });
+}