codexgpt 1.0.0

package/scripts/policy-windows-spike.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const SPIKE_CAPABILITY_NAMES = Object.freeze([
+  "filesystemReadBoundary",
+  "filesystemWriteBoundary",
+  "processTreeControl",
+  "networkEgressControl",
+  "environmentIsolation"
+]);
+
+const PROBES = Object.freeze([
+  Object.freeze({ id: "workspace_read", capability: "filesystemReadBoundary" }),
+  Object.freeze({ id: "outside_read", capability: "filesystemWriteBoundary" }),
+  Object.freeze({ id: "child_tree", capability: "processTreeControl" }),
+  Object.freeze({ id: "filtered_environment", capability: "environmentIsolation" }),
+  Object.freeze({ id: "loopback_network", capability: "networkEgressControl" })
+]);
+
+function isSubpath(candidate, parent) {
+  const relative = path.relative(parent, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function assertSyntheticFixtureRoot(fixtureRoot) {
+  const resolved = path.resolve(fixtureRoot);
+  const temporaryRoot = path.resolve(os.tmpdir());
+  if (!isSubpath(resolved, temporaryRoot) || resolved === temporaryRoot || !path.basename(resolved).startsWith("codexgpt-")) {
+    throw new Error("Windows spike requires a temporary synthetic fixture root.");
+  }
+  return resolved;
+}
+
+function validateProbeResult(probe, result) {
+  if (
+    !result ||
+    result.id !== probe.id ||
+    !["pass", "blocked", "unavailable", "error"].includes(result.outcome) ||
+    typeof result.detailCode !== "string" ||
+    !/^[A-Za-z0-9._-]{1,80}$/.test(result.detailCode)
+  ) {
+    throw new Error(`Windows spike probe result is invalid for ${probe.id}.`);
+  }
+  return Object.freeze({
+    id: probe.id,
+    capability: probe.capability,
+    outcome: result.outcome,
+    detailCode: result.detailCode
+  });
+}
+
+function conservativeObserved(results) {
+  const byId = new Map(results.map((result) => [result.id, result]));
+  return Object.freeze({
+    filesystemReadBoundary: byId.get("workspace_read")?.outcome === "pass" && byId.get("outside_read")?.outcome === "blocked"
+      ? "brokered"
+      : "none",
+    filesystemWriteBoundary: "none",
+    processTreeControl: byId.get("child_tree")?.outcome === "pass" ? "best_effort" : "none",
+    networkEgressControl: "none",
+    environmentIsolation: byId.get("filtered_environment")?.outcome === "pass" ? "filtered" : "none"
+  });
+}
+
+export async function runSpikeFixture({ fixtureRoot, platform = process.platform, execute }) {
+  if (typeof execute !== "function") throw new Error("Windows spike requires an executor.");
+  assertSyntheticFixtureRoot(fixtureRoot);
+  const results = [];
+  for (const probe of PROBES) {
+    results.push(validateProbeResult(probe, await execute(probe)));
+  }
+  return Object.freeze({
+    schemaVersion: 1,
+    platform,
+    fixtureRoot: "[synthetic fixture]",
+    capabilities: [...SPIKE_CAPABILITY_NAMES],
+    observed: conservativeObserved(results),
+    probes: results,
+    persistentHostChanges: false
+  });
+}
+
+async function defaultExecutor(fixtureRoot, probe) {
+  switch (probe.id) {
+    case "workspace_read": {
+      const value = await fs.readFile(path.join(fixtureRoot, "workspace", "inside.txt"), "utf8");
+      return { id: probe.id, outcome: value === "synthetic-inside\n" ? "pass" : "error", detailCode: "fixture-read" };
+    }
+    case "outside_read": {
+      try {
+        await fs.readFile(path.join(fixtureRoot, "outside", "outside.txt"), "utf8");
+        return { id: probe.id, outcome: "unavailable", detailCode: "no-boundary" };
+      } catch {
+        return { id: probe.id, outcome: "blocked", detailCode: "read-blocked" };
+      }
+    }
+    case "child_tree":
+      return { id: probe.id, outcome: "unavailable", detailCode: "not-probed" };
+    case "filtered_environment":
+      return { id: probe.id, outcome: "unavailable", detailCode: "not-isolated" };
+    case "loopback_network":
+      return { id: probe.id, outcome: "unavailable", detailCode: "not-enforced" };
+    default:
+      return { id: probe.id, outcome: "error", detailCode: "unknown-probe" };
+  }
+}
+
+async function main() {
+  const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codexgpt-policy-spike-"));
+  try {
+    await fs.mkdir(path.join(fixtureRoot, "workspace"), { recursive: true });
+    await fs.mkdir(path.join(fixtureRoot, "outside"), { recursive: true });
+    await fs.writeFile(path.join(fixtureRoot, "workspace", "inside.txt"), "synthetic-inside\n", "utf8");
+    await fs.writeFile(path.join(fixtureRoot, "outside", "outside.txt"), "synthetic-outside\n", "utf8");
+    const report = await runSpikeFixture({
+      fixtureRoot,
+      platform: process.platform,
+      execute: (probe) => defaultExecutor(fixtureRoot, probe)
+    });
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } finally {
+    await fs.rm(fixtureRoot, { recursive: true, force: true });
+  }
+}
+
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invokedPath && invokedPath === path.resolve(fileURLToPath(import.meta.url))) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}

package/scripts/pro-apply.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+function usage() {
+  console.log(`Apply a planning-model response to the agent handoff file
+
+Usage:
+  codexgpt pro-apply --root /path/to/repo --file plan.md
+  cat plan.md | codexgpt pro-apply --root /path/to/repo --stdin
+
+Options:
+  --root <dir>       Workspace root. Default: current directory.
+  --file <path>      Plan file to read.
+  --stdin            Read the plan from stdin.
+  --title <text>     Add a heading when the plan does not already start with one.
+  --append           Append to .ai-bridge/current-plan.md instead of overwriting.
+  --help             Show this message.
+`);
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (!raw.startsWith('--')) continue;
+    const eq = raw.indexOf('=');
+    const key = eq === -1 ? raw.slice(2) : raw.slice(2, eq);
+    const inlineValue = eq === -1 ? undefined : raw.slice(eq + 1);
+    if (key === 'help') out.help = true;
+    else if (key === 'stdin') out.stdin = true;
+    else if (key === 'append') out.append = true;
+    else {
+      const next = inlineValue ?? argv[i + 1];
+      if (!next || next.startsWith('--')) throw new Error(`Missing value for --${key}`);
+      if (inlineValue === undefined) i += 1;
+      out[key.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = next;
+    }
+  }
+  return out;
+}
+
+function requireBuild() {
+  const distPath = path.resolve('dist/fsOps.js');
+  if (!fs.existsSync(distPath)) {
+    throw new Error('Missing dist/fsOps.js. Run npm install && npm run build first.');
+  }
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+function resolvePlanPath(args) {
+  const callerCwd = process.env.CODEXGPT_CALLER_CWD || process.cwd();
+  return path.isAbsolute(args.file) ? args.file : path.resolve(callerCwd, args.file);
+}
+
+async function readPlan(args) {
+  if (args.stdin && args.file) throw new Error('Use either --stdin or --file, not both.');
+  if (args.stdin) return readStdin();
+  if (!args.file) throw new Error('Missing --file <path> or --stdin.');
+  return fsp.readFile(resolvePlanPath(args), 'utf8');
+}
+
+function normalizePlan(rawPlan, title) {
+  const trimmed = rawPlan.trim();
+  if (!trimmed) throw new Error('Plan is empty.');
+  if (trimmed.startsWith('#')) return `${trimmed}\n`;
+  return `# ${title || 'Planning Model Handoff'}\n\nUpdated: ${new Date().toISOString()}\n\n${trimmed}\n`;
+}
+
+function jsonlEvent(event, data) {
+  return `${JSON.stringify({ ts: new Date().toISOString(), event, ...data })}\n`;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    usage();
+    return;
+  }
+  requireBuild();
+
+  const [
+    { loadConfig },
+    { WorkspaceManager, PathGuard },
+    { AI_BRIDGE_SCAFFOLD_FILES, aiBridgeScaffoldWrites, makeUnifiedDiff, prepareWorkspaceTextBatch },
+    { LocalMutationService }
+  ] = await Promise.all([
+    import('../dist/config.js'),
+    import('../dist/guard.js'),
+    import('../dist/fsOps.js'),
+    import('../dist/mutations/index.js')
+  ]);
+
+  const config = loadConfig(process.argv.slice(2));
+  const guard = new PathGuard(config);
+  const workspaces = new WorkspaceManager(config);
+  const workspace = workspaces.openWorkspace(config.defaultRoot);
+
+  const planPath = `${config.contextDir}/current-plan.md`;
+  const rawPlan = await readPlan(args);
+  const newPlan = normalizePlan(rawPlan, args.title);
+  const logRel = `${config.contextDir}/session-log.jsonl`;
+  const executionLogRel = `${config.contextDir}/execution-log.jsonl`;
+  const event = jsonlEvent('pro_apply', {
+    plan_path: planPath,
+    source_file: args.file ? resolvePlanPath(args) : 'stdin',
+    append: Boolean(args.append)
+  });
+  const replacedPaths = new Set([planPath, logRel, executionLogRel]);
+  const prepared = await prepareWorkspaceTextBatch(config, guard, workspace, [
+    ...aiBridgeScaffoldWrites(config).filter((write) => !replacedPaths.has(write.path)),
+    {
+      path: planPath,
+      content: args.append ? `\n\n---\n\n${newPlan}` : newPlan,
+      mode: args.append ? 'append' : 'replace',
+      missingContent: args.append
+        ? `${AI_BRIDGE_SCAFFOLD_FILES['current-plan.md'].trimEnd()}\n\n---\n\n${newPlan}`
+        : undefined
+    },
+    { path: logRel, content: event, mode: 'append' },
+    { path: executionLogRel, content: event, mode: 'append' }
+  ]);
+  const planOperation = prepared.operations.find((operation) => operation.path === planPath);
+  if (!planOperation) throw new Error('Atomic plan operation is missing.');
+  const previousText = planOperation.before.bytes?.toString('utf8') ?? '';
+  const content = planOperation.operation.bytes.toString('utf8');
+  const diff = makeUnifiedDiff(previousText, content, planPath);
+  const service = new LocalMutationService(config, guard);
+  try {
+    await service.executeBatch(workspace, prepared, { ok: true }, { toolName: 'pro_apply' });
+  } finally {
+    service.dispose();
+  }
+
+  console.log(`Wrote ${path.join(workspace.root, planPath)}`);
+  console.log(`Bytes: ${planOperation.operation.bytes.length}`);
+  console.log(`Diff stats: +${diff.additions} -${diff.deletions}`);
+  console.log(`Session log: ${path.join(workspace.root, logRel)}`);
+  console.log(`Execution log: ${path.join(workspace.root, executionLogRel)}`);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exit(1);
+});

package/scripts/pro-bundle.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+function usage() {
+  console.log(`CodexGPT context bundle
+
+Usage:
+  codexgpt pro-bundle --root /path/to/repo --copy
+  codexgpt pro-bundle --root /path/to/repo --path src/App.tsx --glob "src/**/*.ts"
+
+Options:
+  --root <dir>              Workspace root. Default: current directory.
+  --path <file>             Extra file to include. Can be repeated.
+  --glob <pattern>          Extra glob to include. Can be repeated.
+  --title <text>            Context title.
+  --max-files <n>           Maximum file contents to include. Default: 24.
+  --max-file-bytes <n>      Maximum bytes per included file. Default: 60000.
+  --max-total-bytes <n>     Maximum bytes in .ai-bridge/pro-context.md.
+  --no-important-files      Do not auto-include root config/docs such as AGENTS.md, README.md, package.json.
+  --no-changed-files        Do not auto-include currently changed files from git status.
+  --no-diff                 Do not include git diff.
+  --no-ai-bridge            Do not include existing .ai-bridge files.
+  --copy                    Copy generated context to the macOS clipboard with pbcopy.
+  --help                    Show this message.
+`);
+}
+
+function parseArgs(argv) {
+  const out = { paths: [], globs: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (!raw.startsWith('--')) continue;
+    const eq = raw.indexOf('=');
+    const key = eq === -1 ? raw.slice(2) : raw.slice(2, eq);
+    const inlineValue = eq === -1 ? undefined : raw.slice(eq + 1);
+    if (key === 'help') out.help = true;
+    else if (key === 'copy') out.copy = true;
+    else if (key === 'no-important-files') out.noImportantFiles = true;
+    else if (key === 'no-changed-files') out.noChangedFiles = true;
+    else if (key === 'no-diff') out.noDiff = true;
+    else if (key === 'no-ai-bridge') out.noAiBridge = true;
+    else {
+      const next = inlineValue ?? argv[i + 1];
+      if (!next || next.startsWith('--')) throw new Error(`Missing value for --${key}`);
+      if (inlineValue === undefined) i += 1;
+      if (key === 'path') out.paths.push(next);
+      else if (key === 'glob') out.globs.push(next);
+      else out[key.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = next;
+    }
+  }
+  return out;
+}
+
+function requireBuild() {
+  const distPath = path.resolve('dist/proContext.js');
+  if (!fs.existsSync(distPath)) {
+    throw new Error('Missing dist/proContext.js. Run npm install && npm run build first.');
+  }
+}
+
+function numberArg(value) {
+  if (value === undefined) return undefined;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`Invalid number: ${value}`);
+  return parsed;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    usage();
+    return;
+  }
+  requireBuild();
+
+  const [{ loadConfig }, { WorkspaceManager, PathGuard }, { exportProContext }] = await Promise.all([
+    import('../dist/config.js'),
+    import('../dist/guard.js'),
+    import('../dist/proContext.js')
+  ]);
+
+  const config = loadConfig(process.argv.slice(2));
+  const guard = new PathGuard(config);
+  const workspaces = new WorkspaceManager(config);
+  const workspace = workspaces.openWorkspace(config.defaultRoot);
+  const result = await exportProContext(config, guard, workspace, {
+    title: args.title,
+    selectedPaths: args.paths,
+    extraGlobs: args.globs,
+    includeImportantFiles: !args.noImportantFiles,
+    includeChangedFiles: !args.noChangedFiles,
+    includeDiff: !args.noDiff,
+    includeAiBridge: !args.noAiBridge,
+    maxFiles: numberArg(args.maxFiles),
+    maxFileBytes: numberArg(args.maxFileBytes),
+    maxTotalBytes: numberArg(args.maxTotalBytes)
+  });
+
+  const absPath = path.join(workspace.root, result.path);
+  console.log(`Wrote ${absPath}`);
+  console.log(`Bytes: ${result.bytes}`);
+  console.log(`Files included: ${result.filesIncluded.length}`);
+  console.log(`Files skipped: ${result.filesSkipped.length}`);
+  console.log(`Truncated: ${result.truncated}`);
+
+  if (args.copy) {
+    const copied = spawnSync('pbcopy', { input: result.markdown, encoding: 'utf8' });
+    if (copied.status !== 0) {
+      throw new Error(`pbcopy failed: ${copied.stderr || copied.error?.message || `exit ${copied.status}`}`);
+    }
+    console.log('Copied Pro context to clipboard.');
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exit(1);
+});

package/scripts/pro-smoke.mjs

@@ -0,0 +1,97 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+function run(args, options = {}) {
+  const result = spawnSync(process.execPath, args, {
+    cwd: path.resolve('.'),
+    encoding: 'utf8',
+    ...options
+  });
+  if (result.status !== 0) {
+    throw new Error(`${args.join(' ')} failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+  return result;
+}
+
+function runFail(args, options = {}) {
+  const result = spawnSync(process.execPath, args, {
+    cwd: path.resolve('.'),
+    encoding: 'utf8',
+    ...options
+  });
+  if (result.status === 0) {
+    throw new Error(`${args.join(' ')} unexpectedly passed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+  return result;
+}
+
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-pro-smoke-'));
+const stateHome = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-pro-smoke-home-'));
+const proApplyEnv = { ...process.env, CODEXGPT_HOME: stateHome };
+const codexgptCli = path.resolve('scripts/codexgpt.mjs');
+await fs.writeFile(path.join(root, 'README.md'), '# Demo\n', 'utf8');
+await fs.writeFile(path.join(root, 'demo.txt'), 'alpha\nbeta\n', 'utf8');
+
+run(['scripts/pro-bundle.mjs', `--root=${root}`, '--path=demo.txt', '--max-files', '4', '--max-total-bytes', '80000']);
+const proContext = await fs.readFile(path.join(root, '.ai-bridge', 'pro-context.md'), 'utf8');
+if (!proContext.includes('CodexGPT Context Bundle') || !proContext.includes('demo.txt')) {
+  throw new Error('pro context bundle did not include expected content');
+}
+
+const selectedRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-pro-selected-'));
+await fs.writeFile(path.join(selectedRoot, 'README.md'), '# Selected\n', 'utf8');
+await fs.writeFile(path.join(selectedRoot, 'demo.txt'), 'selected only\n', 'utf8');
+run([
+  'scripts/pro-bundle.mjs',
+  `--root=${selectedRoot}`,
+  '--path=demo.txt',
+  '--no-important-files',
+  '--no-changed-files',
+  '--no-diff',
+  '--no-ai-bridge',
+  '--max-files', '4',
+  '--max-total-bytes', '80000'
+]);
+const selectedBridgeFiles = await fs.readdir(path.join(selectedRoot, '.ai-bridge'));
+if (selectedBridgeFiles.join(',') !== 'pro-context.md') {
+  throw new Error(`selected-only pro context created unexpected bridge files: ${selectedBridgeFiles.join(', ')}`);
+}
+const exactProContext = await fs.readFile(path.join(selectedRoot, '.ai-bridge', 'pro-context.md'), 'utf8');
+if (!exactProContext.includes('Auto-include important root files: no') || !exactProContext.includes('Auto-include changed files: no')) {
+  throw new Error('selected-only pro context did not record disabled auto-inclusion settings');
+}
+if (!exactProContext.includes('### demo.txt') || exactProContext.includes('### README.md')) {
+  throw new Error('selected-only pro context did not include exactly the requested file');
+}
+
+run([codexgptCli, 'pro-bundle', `--root=${root}`, '--path=demo.txt', '--max-files=4', '--max-total-bytes=80000']);
+
+const planFile = path.join(root, 'plan.md');
+await fs.writeFile(planFile, 'Inspect demo.txt and keep changes narrow.\n', 'utf8');
+run(['scripts/pro-apply.mjs', `--root=${root}`, `--file=${planFile}`, '--title', 'Smoke Pro Plan'], { env: proApplyEnv });
+run([codexgptCli, 'pro-apply', `--root=${root}`, '--file=plan.md', '--title', 'Relative Pro Plan'], { cwd: root, env: proApplyEnv });
+const currentPlan = await fs.readFile(path.join(root, '.ai-bridge', 'current-plan.md'), 'utf8');
+if (!currentPlan.includes('Relative Pro Plan') || !currentPlan.includes('Inspect demo.txt')) {
+  throw new Error('pro apply did not write expected current-plan content');
+}
+const executionLog = await fs.readFile(path.join(root, '.ai-bridge', 'execution-log.jsonl'), 'utf8');
+if (!executionLog.includes('"event":"pro_apply"')) {
+  throw new Error('pro apply did not append execution-log event');
+}
+const proApplyEvents = executionLog.trim().split('\n').map((line) => JSON.parse(line));
+if (!proApplyEvents.some((event) => event.source_file === planFile)) {
+  throw new Error(`pro apply logged the wrong source file\n${executionLog}`);
+}
+
+const missingRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-pro-missing-'));
+runFail(['scripts/pro-apply.mjs', `--root=${missingRoot}`, '--file=missing-plan.md'], { env: { ...proApplyEnv, CODEXGPT_CALLER_CWD: missingRoot } });
+try {
+  await fs.stat(path.join(missingRoot, '.ai-bridge'));
+  throw new Error('failed pro-apply created .ai-bridge before validating input');
+} catch (error) {
+  if (error?.code !== 'ENOENT') throw error;
+}
+
+console.log('✓ pro CLI smoke test passed');

package/scripts/process-identity.mjs

@@ -0,0 +1,67 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+export function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+function windowsProcessCreationTime(pid) {
+  const systemRoot = process.env.SystemRoot?.trim() || process.env.WINDIR?.trim();
+  if (!systemRoot) return undefined;
+  const powershell = path.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const script = [
+    "$ErrorActionPreference='Stop'",
+    `$p=Get-Process -Id ${pid}`,
+    "$p.StartTime.ToUniversalTime().ToString('O')"
+  ].join(";");
+  const result = spawnSync(powershell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 10_000
+  });
+  if (result.status !== 0) return undefined;
+  const value = String(result.stdout ?? "").trim();
+  return value || undefined;
+}
+
+function linuxProcessCreationTime(pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+    const closing = stat.lastIndexOf(")");
+    if (closing < 0) return undefined;
+    const fields = stat.slice(closing + 2).trim().split(/\s+/u);
+    const startTicks = fields[19];
+    return startTicks ? `linux:${startTicks}` : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function unixProcessCreationTime(pid) {
+  const ps = fs.existsSync("/bin/ps") ? "/bin/ps" : "/usr/bin/ps";
+  const result = spawnSync(ps, ["-o", "lstart=", "-p", String(pid)], {
+    encoding: "utf8",
+    timeout: 5_000
+  });
+  if (result.status !== 0) return undefined;
+  const value = String(result.stdout ?? "").trim();
+  return value ? `ps:${value}` : undefined;
+}
+
+export function processCreationTimeSync(pid) {
+  if (!processIsAlive(pid)) return undefined;
+  if (process.platform === "win32") return windowsProcessCreationTime(pid);
+  if (process.platform === "linux") return linuxProcessCreationTime(pid);
+  return unixProcessCreationTime(pid);
+}
+
+export async function processCreationTime(pid) {
+  return processCreationTimeSync(pid);
+}