@runeditrun/rer 0.0.0-stage → 0.1.1

package/onboarding/providers.mjs

@@ -0,0 +1,289 @@
+import { access, constants } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { delimiter, isAbsolute, resolve } from 'node:path';
+
+const PROVIDER_NAMES = ['cloudflare', 'github'];
+const MAX_OUTPUT = 256 * 1024;
+
+/**
+ * These are the only provider commands the installer can run. Values returned
+ * by local files or HTTP requests never become command arguments.
+ */
+export const PROVIDER_COMMANDS = Object.freeze({
+  cloudflare: Object.freeze({
+    binary: 'wrangler',
+    version: Object.freeze(['--version']),
+    auth: Object.freeze(['whoami']),
+    connect: Object.freeze(['login']),
+  }),
+  github: Object.freeze({
+    binary: 'gh',
+    version: Object.freeze(['--version']),
+    auth: Object.freeze(['auth', 'status', '--hostname', 'github.com']),
+    account: Object.freeze(['api', 'user', '--hostname', 'github.com', '--jq', '{login,id,name}']),
+    repository: Object.freeze(['repo', 'view', '--json', 'nameWithOwner,isPrivate,defaultBranchRef,pushedAt']),
+    connect: Object.freeze(['auth', 'login', '--hostname', 'github.com', '--git-protocol', 'https', '--web']),
+  }),
+});
+
+function providerName(value) {
+  if (typeof value !== 'string' || !PROVIDER_NAMES.includes(value)) {
+    throw new Error('Unsupported provider');
+  }
+  return value;
+}
+
+function commandConfig(provider) {
+  return PROVIDER_COMMANDS[providerName(provider)];
+}
+
+function output(value) {
+  return typeof value === 'string' ? value.slice(0, MAX_OUTPUT) : '';
+}
+
+async function executable(binary, env = process.env) {
+  if (isAbsolute(binary)) {
+    try {
+      await access(binary, constants.X_OK);
+      return binary;
+    } catch {
+      return null;
+    }
+  }
+  for (const directory of String(env.PATH || '').split(delimiter)) {
+    if (!directory) continue;
+    const candidate = resolve(directory, binary);
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      // Continue through PATH without exposing filesystem errors to the UI.
+    }
+  }
+  return null;
+}
+
+function runCommand(file, args, { cwd, signal, interactive = false, onDevice, env = process.env } = {}) {
+  return new Promise((resolveResult, reject) => {
+    let child;
+    try {
+      child = spawn(file, args, {
+        cwd,
+        env,
+        shell: false,
+        detached: false,
+        stdio: [interactive ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      resolveResult({ code: null, signal: null, stdout: '', stderr: '' });
+      return;
+    }
+
+    if (interactive) child.stdin?.end('\n');
+    let stdout = '';
+    let stderr = '';
+    const collect = (kind, chunk) => {
+      // Provider auth tools can print credentials or token fragments. Keep
+      // output private to this process and bounded; callers only parse it.
+      if (kind === 'stdout') stdout = (stdout + String(chunk)).slice(0, MAX_OUTPUT);
+      else stderr = (stderr + String(chunk)).slice(0, MAX_OUTPUT);
+      if (interactive && onDevice) {
+        const clean = (stdout + stderr).replace(/\x1b\[[0-9;]*m/g, '');
+        const code = clean.match(/one-time code:\s*([A-Z0-9]{4}-[A-Z0-9]{4})/i)?.[1];
+        if (code) onDevice(code);
+      }
+    };
+    child.stdout?.on('data', chunk => collect('stdout', chunk));
+    child.stderr?.on('data', chunk => collect('stderr', chunk));
+
+    const timeout = setTimeout(() => child.kill('SIGTERM'), interactive ? 180000 : 12000);
+    let settled = false;
+    const abort = () => {
+      if (!settled) child.kill('SIGTERM');
+    };
+    let processExit;
+    const finish = result => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      signal?.removeEventListener('abort', abort);
+      if (processExit) process.removeListener('exit', processExit);
+      resolveResult(result);
+    };
+    processExit = () => abort();
+    process.once('exit', processExit);
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, { once: true });
+    child.once('error', () => finish({ code: null, signal: null, stdout, stderr }));
+    child.once('close', (code, childSignal) => finish({ code, signal: childSignal, stdout, stderr }));
+  });
+}
+
+function status(provider, executablePath, state, extra = {}) {
+  return {
+    provider,
+    installed: Boolean(executablePath),
+    executable: executablePath || null,
+    state,
+    authenticated: state === 'connected',
+    ...extra,
+  };
+}
+
+function cloudflareAccounts(text) {
+  const lines = String(text).split(/\r?\n/);
+  const accounts = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const idMatch = line.match(/\b([a-f0-9]{32})\b/i);
+    if (!idMatch) continue;
+    let name = line
+      .replace(idMatch[0], '')
+      .replace(/[│|]/g, ' ')
+      .replace(/account\s*id\s*:?/gi, '')
+      .trim();
+    if (!name || /^id$/i.test(name)) {
+      const previous = lines[index - 1] || '';
+      const nameMatch = previous.match(/account\s*name\s*:?\s*([^│|]+)$/i);
+      name = nameMatch?.[1]?.trim() || null;
+    }
+    if (name && /email|logged|token|account\s*id/i.test(name)) name = null;
+    if (!accounts.some(account => account.id === idMatch[1])) {
+      accounts.push({ id: idMatch[1], ...(name ? { name } : {}) });
+    }
+  }
+  return accounts;
+}
+
+function cloudflareAuthenticated(result) {
+  const text = `${result.stdout}\n${result.stderr}`.toLowerCase();
+  return result.code === 0 && !/(not logged|not authenticated|run .*login|authentication required)/i.test(text);
+}
+
+function githubAuthenticated(result) {
+  const text = `${result.stdout}\n${result.stderr}`.toLowerCase();
+  return result.code === 0 && !/(not logged|not authenticated|no accounts|authentication required)/i.test(text);
+}
+
+function safeJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function gitRemoteName(value) {
+  const remote = String(value || '').trim();
+  const match = remote.match(/^(?:https?:\/\/github\.com\/|git@github\.com:)([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/i);
+  if (!match) return null;
+  return `${match[1]}/${match[2]}`;
+}
+
+async function discoverCloudflare(root, options) {
+  const config = commandConfig('cloudflare');
+  const path = await executable(config.binary, options.env);
+  if (!path) return status('cloudflare', null, 'not_installed', { accounts: [] });
+  const versionResult = await options.run(path, config.version, { cwd: root, signal: options.signal, env: options.env });
+  const authResult = await options.run(path, config.auth, { cwd: root, signal: options.signal, env: options.env });
+  const connected = cloudflareAuthenticated(authResult);
+  return status('cloudflare', path, connected ? 'connected' : 'auth_required', {
+    version: output(versionResult.stdout || versionResult.stderr).split(/\r?\n/, 1)[0] || null,
+    accounts: connected ? cloudflareAccounts(`${authResult.stdout}\n${authResult.stderr}`) : [],
+    connect: { command: config.connect.slice(), opensBrowser: true },
+  });
+}
+
+async function discoverGithub(root, options) {
+  const config = commandConfig('github');
+  const path = await executable(config.binary, options.env);
+  if (!path) return status('github', null, 'not_installed', { account: null, repository: null });
+  const versionResult = await options.run(path, config.version, { cwd: root, signal: options.signal, env: options.env });
+  const authResult = await options.run(path, config.auth, { cwd: root, signal: options.signal, env: options.env });
+  const connected = githubAuthenticated(authResult);
+  const result = status('github', path, connected ? 'connected' : 'auth_required', {
+    version: output(versionResult.stdout || versionResult.stderr).split(/\r?\n/, 1)[0] || null,
+    account: null,
+    repository: null,
+    connect: { command: config.connect.slice(), opensBrowser: true },
+  });
+  if (!connected) return result;
+
+  const accountResult = await options.run(path, config.account, { cwd: root, signal: options.signal, env: options.env });
+  const account = safeJson(output(accountResult.stdout));
+  if (account && typeof account === 'object' && typeof account.login === 'string' && (typeof account.id === 'number' || typeof account.id === 'string')) {
+    result.account = {
+      login: account.login,
+      id: String(account.id),
+      ...(typeof account.name === 'string' && account.name ? { name: account.name } : {}),
+    };
+  }
+
+  const remoteResult = await options.run('git', ['config', '--get', 'remote.origin.url'], { cwd: root, signal: options.signal, env: options.env });
+  const nameWithOwner = gitRemoteName(remoteResult.stdout);
+  if (!nameWithOwner) return result;
+  const repositoryResult = await options.run(path, [...config.repository, nameWithOwner], { cwd: root, signal: options.signal, env: options.env });
+  const repository = safeJson(output(repositoryResult.stdout));
+  if (repository && typeof repository === 'object' && typeof repository.nameWithOwner === 'string') {
+    result.repository = {
+      nameWithOwner: repository.nameWithOwner,
+      ...(typeof repository.isPrivate === 'boolean' ? { isPrivate: repository.isPrivate } : {}),
+      ...(repository.defaultBranchRef?.name ? { defaultBranch: repository.defaultBranchRef.name } : {}),
+      ...(typeof repository.pushedAt === 'string' ? { pushedAt: repository.pushedAt } : {}),
+    };
+  }
+  return result;
+}
+
+/** Discover local CLI availability and account metadata without returning CLI output. */
+export async function discoverProviders(root = process.cwd(), { signal, run = runCommand, env = process.env } = {}) {
+  const directory = resolve(root);
+  const options = { signal, run, env };
+  const [cloudflare, github] = await Promise.all([
+    discoverCloudflare(directory, options),
+    discoverGithub(directory, options),
+  ]);
+  return { schemaVersion: 1, providers: { cloudflare, github } };
+}
+
+/**
+ * Start one of the fixed, browser-based provider logins. This function is
+ * intended for an explicit Connect action; discovery alone has no remote side
+ * effects. The returned status is refreshed after the child exits, so a zero
+ * exit code never becomes a false connected state.
+ */
+export async function connectProvider(root = process.cwd(), provider, { signal, onProgress, run = runCommand, env = process.env } = {}) {
+  const name = providerName(provider);
+  const config = commandConfig(name);
+  const directory = resolve(root);
+  const path = await executable(config.binary, env);
+  if (!path) {
+    const result = (await discoverProviders(directory, { signal, run, env })).providers[name];
+    onProgress?.({ provider: name, state: result.state });
+    return { ...result, operation: { state: 'failed', reason: 'not_installed' } };
+  }
+
+  onProgress?.({ provider: name, state: 'awaiting_browser' });
+  const login = await run(path, config.connect.slice(), {
+    cwd: directory,
+    signal,
+    env,
+    interactive: true,
+    onDevice: name === 'github' ? deviceCode => onProgress?.({ provider: name, state: 'awaiting_browser', deviceCode, verificationUrl: 'https://github.com/login/device' }) : undefined,
+  });
+  if (signal?.aborted) {
+    onProgress?.({ provider: name, state: 'cancelled' });
+    const result = (await discoverProviders(directory, { signal, run, env })).providers[name];
+    return { ...result, operation: { state: 'cancelled' } };
+  }
+
+  onProgress?.({ provider: name, state: 'refreshing' });
+  const result = (await discoverProviders(directory, { signal, run, env })).providers[name];
+  const operation = result.authenticated
+    ? { state: 'connected' }
+    : { state: 'auth_required', reason: login.code === 0 ? 'authentication_not_confirmed' : 'login_failed' };
+  onProgress?.({ provider: name, state: operation.state });
+  return { ...result, operation };
+}
+
+export const providerNames = Object.freeze(PROVIDER_NAMES.slice());

package/onboarding/queue.mjs

@@ -0,0 +1,53 @@
+import { basename, dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { readFile, realpath } from 'node:fs/promises';
+const portable = basename(dirname(fileURLToPath(import.meta.url))) === 'base-onboarding';
+const queueURL = new URL(portable ? '../base-cli/modules/job-queue/' : '../modules/job-queue/', import.meta.url);
+export const heavyVerbs = new Set(['install', 'setup', 'build', 'verify', 'dev', 'preview', 'deploy', 'release', 'export', 'import', 'installer']);
+export async function queueLabel(root, verb, phase) {
+ root = await realpath(root);
+ let project='project';
+ for(const file of ['OPERATIONS.json','package.json']){
+  try{const value=JSON.parse(await readFile(join(root,file),'utf8')),name=value.project??value.name;
+   if(typeof name==='string'&&/^@?[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)?$/.test(name)){project=name;break;}
+  }catch{}
+ }
+
+ return `${project} ${verb}:${phase} [${createHash('sha256').update(root).digest('hex').slice(0, 12)}]`;
+}
+
+function shellQuote(value) {
+ if (process.platform === 'win32') return `"${String(value).replaceAll('"', '""')}"`;
+ return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function waitingText(wait, waitingMessage) {
+ return `${waitingMessage(wait)}\nRun from the project root. Inspect the queue with: ${wait.statusCommandText}`;
+}
+
+export async function queuedCommand(command, args, options) {
+ const { createQueue } = await import(new URL('index.mjs', queueURL));
+ const { liveMembership } = await import(new URL('membership.mjs', queueURL));
+ const { waitingMessage } = await import(new URL('waiting.mjs', queueURL));
+ const statusCommand = [process.execPath, fileURLToPath(new URL('cli.mjs', queueURL)), 'status', '--json'];
+ // An inherited credential-shaped PWD can redact an absolute project prefix.
+ // Keep the human recipe relative while retaining the executable argv for tools.
+ const statusCommandText = [basename(process.execPath), relative(options.cwd ?? process.cwd(), statusCommand[1]), ...statusCommand.slice(2)].map(shellQuote).join(' ');
+ // Read the original caller's decision before an install synthesizes CI=true.
+ if (options.originalCI === true || await liveMembership()) return null;
+ const queue = await createQueue();
+ try {
+  const result = await queue.run([command, ...args], { ...options, kind: 'heavy', maxWait: 1200,
+   onWaiting: (reason, detail) => {
+    const wait = { ...(detail ?? { reason }), statusCommand, statusCommandText };
+    if (typeof options.onWaiting === 'function') return options.onWaiting(wait);
+    return options.report?.(waitingText(wait, waitingMessage));
+   },
+   onStarted: () => options.report(`Heavy job admitted: ${options.label}`) });
+  if (result.supervisorEnded) options.report?.(result.error);
+  return result;
+ } finally { await queue.close(); }
+}
+
+export async function commandPolicy(){const {callerPolicy}=await import(new URL('policy.mjs',queueURL));return callerPolicy();}

package/onboarding/queued-entry.mjs

@@ -0,0 +1,34 @@
+import { fileURLToPath,pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+import { mkdtemp,rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createCommands } from './commands.mjs';
+import { commandPolicy,queuedCommand,queueLabel } from './queue.mjs';
+
+// Called by real suite entrypoints before their runtime imports/side effects.
+// The admitted child runs the original file/argv, retaining its own stack.
+export async function queuedEntrypoint(url,verb='verify') {
+ const directory=await mkdtemp(join(tmpdir(),'rer-heavy-'));
+ let store;
+ try{
+  store=await createCommands(directory,{logs:[]},{terminal:text=>process.stderr.write(text),queue:{verb}});
+  const policy=await commandPolicy();
+  try{
+   const result=await queuedCommand(process.execPath,[...process.execArgv,fileURLToPath(url),...process.argv.slice(2)],{
+    cwd:process.cwd(),originalCI:policy.ci,label:await queueLabel(process.cwd(),verb,'suite'),report:text=>store.report(text),env:{...process.env,...policy.environment},
+    spawn:(command,args,options)=>store.spawn(verb,command,args,options),cleanup:child=>store.stop(child)});
+   return result?.code??null;
+  }finally{await policy.close();}
+ }finally{await store?.closeCommands();await rm(directory,{recursive:true,force:true});}
+}
+
+if(process.argv[1] && pathToFileURL(resolve(process.argv[1])).href===import.meta.url){
+ const [verb,separator,command,...args]=process.argv.slice(2);
+ if(separator!=='--'||!command)throw Error('Usage: queued-entry VERB -- COMMAND ARGS');
+ const directory=await mkdtemp(join(tmpdir(),'rer-heavy-'));
+ const store=await createCommands(directory,{logs:[]},{terminal:text=>process.stdout.write(text),queue:{verb}});
+ try{await store.run(verb,command,args,{cwd:process.cwd()});}
+ catch(error){process.exitCode=error.childExitCode??1;}
+ finally{await store.closeCommands();await rm(directory,{recursive:true,force:true});}
+}

package/onboarding/readiness.mjs

@@ -0,0 +1,59 @@
+const defaultWait = (ms,signal) => new Promise(resolve => {
+ const done = () => { clearTimeout(timer); signal?.removeEventListener('abort',done); resolve(); };
+ const timer = setTimeout(done,ms); signal?.addEventListener('abort',done,{once:true}); if(signal?.aborted)done();
+});
+
+export async function waitForReadiness(label, child, health, options, capture, report, failure) {
+ const {signal, timeoutMs=900000, intervalMs=1000, softAfterMs=30000, probeTimeoutMs=Math.max(5000,intervalMs*3), now=Date.now, wait=defaultWait}=options;
+ if (!Number.isFinite(timeoutMs)||timeoutMs<=0||!Number.isFinite(intervalMs)||intervalMs<=0||!Number.isFinite(probeTimeoutMs)||probeTimeoutMs<=0)throw TypeError('Readiness intervals must be positive.');
+ const start=now(), scope=new AbortController();
+ let lastHealth='No healthy response yet', cancelled;
+ const aborted = new Promise(resolve=>{cancelled=()=>resolve({kind:'cancel'});signal?.addEventListener('abort',cancelled,{once:true});if(signal?.aborted)cancelled();});
+ const closed = capture.closed.then(result=>({kind:'closed',result}));
+ const exited = capture.exited.then(result=>({kind:'exit',result}));
+ const failed = capture.failed.then(result=>({kind:'error',result}));
+ const deadline = wait(timeoutMs,scope.signal).then(()=>({kind:'deadline'}));
+ const progress=(async()=>{
+  await wait(Math.max(1,softAfterMs),scope.signal);
+  while(!scope.signal.aborted){report(`${label}: Still starting (${Math.floor((now()-start)/1000)} s)`);await wait(Math.max(1000,intervalMs),scope.signal);}
+ })();
+ const stopped = () => child.exitCode!==null&&child.exitCode!==undefined || child.signalCode!==null&&child.signalCode!==undefined;
+ const fail = (reason,result) => {throw failure(label,{...result,reason,lastHealth});};
+ // Give ordinary final pipe bytes a bounded chance to arrive after exit. A
+ // descendant holding stdio cannot keep an already-dead app in readiness.
+ const drain = async () => {
+  const result=await Promise.race([closed,failed,aborted,deadline,wait(50,scope.signal).then(()=>({kind:'exit',result:capture.exitResult}))]);
+  return fail(result.kind,result.result);
+ };
+ try {
+  for (;;) {
+   if(signal?.aborted)return await fail('cancel');
+   if(stopped())return await drain();
+   if(now()-start>=timeoutMs)return await fail('deadline');
+   const probeScope=new AbortController();
+   const probeSignal=AbortSignal.any([scope.signal,probeScope.signal]);
+   const probe=Promise.resolve().then(()=>health(probeSignal)).then(value=>({kind:'health',value}),()=>({kind:'health',value:{ready:false,message:'Health probe failed'}}));
+   // Race independently of the callback: adapters that ignore abort must not
+   // consume the entire startup window with one request.
+   const probeDeadline=wait(probeTimeoutMs,probeScope.signal).then(()=>{
+    if(!probeScope.signal.aborted)probeScope.abort();
+    return {kind:'health',value:{ready:false,message:'Health probe timed out'}};
+   });
+   let result;
+   try { result=await Promise.race([probe,probeDeadline,closed,exited,failed,aborted,deadline]); }
+   finally { probeScope.abort(); }
+
+   if(result.kind==='exit')return await drain();
+   if(result.kind!=='health')return await fail(result.kind,result.result);
+   if(stopped())return await drain();
+   if(signal?.aborted)return await fail('cancel');
+   if(now()-start>=timeoutMs)return await fail('deadline');
+   if(result.value===true||result.value?.ready===true)return result.value;
+   if(typeof result.value==='string')lastHealth=result.value;
+   else if(typeof result.value?.message==='string')lastHealth=result.value.message;
+   result=await Promise.race([wait(Math.min(intervalMs,timeoutMs-(now()-start)),scope.signal).then(()=>({kind:'tick'})),closed,exited,failed,aborted,deadline]);
+   if(result.kind==='exit')return await drain();
+   if(result.kind!=='tick')return await fail(result.kind,result.result);
+  }
+ } finally { scope.abort();signal?.removeEventListener('abort',cancelled);await progress; }
+}

package/onboarding/redaction-jwt.mjs

@@ -0,0 +1,32 @@
+// Scan each base64url segment once. A header may start inside a diagnostic
+// word (session-eyJ...), so retrying a regex at each eyJ in a long segment
+// would be quadratic. Only three adjacent dot-separated segments can be a JWT.
+const SEGMENT = /[A-Za-z0-9_-]+/g;
+const HEADER = /eyJ(?=[A-Za-z0-9_-])/i;
+const TOKEN_CHAR = /[A-Za-z0-9_.-]/;
+
+export function jwtRanges(text) {
+ const found = [];
+ let previous = [];
+ for (const part of text.matchAll(SEGMENT)) {
+  const last = previous.at(-1);
+  if (last && (part.index !== last.end + 1 || text[last.end] !== '.')) previous = [];
+  previous.push({ start: part.index, end: part.index + part[0].length, text: part[0] });
+  if (previous.length < 3) continue;
+  const header = HEADER.exec(previous[0].text);
+  if (header) found.push([previous[0].start + header.index, previous[2].end]);
+  previous.shift();
+ }
+ return found;
+}
+
+export const jwtHold = { exec(text) {
+ // Only the tail after the third-last dot can still become a partial JWT.
+ let start = text.length, dots = 0;
+ while (start > 0 && TOKEN_CHAR.test(text[start - 1])) {
+  if (text[start - 1] === '.' && ++dots === 3) break;
+  start--;
+ }
+ const at = /eyJ/i.exec(text.slice(start));
+ return at ? { index: start + at.index } : null;
+} };