pi-background-tasks 0.7.3 → 0.7.4

package/src/core/pi-launch.ts

@@ -0,0 +1,225 @@
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import type { Stats } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, extname, isAbsolute, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export interface PiLaunchSpec {
+  readonly executable: string;
+  readonly argvPrefix: readonly string[];
+  readonly kind: 'path' | 'package-node-cli';
+}
+
+export interface PiLaunchDependencies {
+  readonly platform?: NodeJS.Platform;
+  readonly execPath?: string;
+  readonly resolvePackageJson?: (specifier: string) => string;
+  readonly readFile?: (path: string) => string | Buffer;
+  readonly realpath?: (path: string) => string;
+  readonly stat?: (path: string) => Pick<Stats, 'isFile'>;
+}
+
+export class PiLaunchResolutionError extends Error {
+  readonly code = 'pi_executable_resolution_failed';
+
+  constructor(message: string) {
+    super(`pi_executable_resolution_failed: ${message}`);
+    this.name = 'PiLaunchResolutionError';
+  }
+}
+
+export class PiCommandLineLimitError extends Error {
+  readonly code = 'pi_command_line_too_long';
+  readonly stage: string;
+  readonly measuredLength: number;
+  readonly limit: number;
+
+  constructor(stage: string, measuredLength: number, limit: number) {
+    super(
+      `pi_command_line_too_long: ${stage} measured UTF-16 command line length ${String(measuredLength)} exceeds limit ${String(limit)}`,
+    );
+    this.name = 'PiCommandLineLimitError';
+    this.stage = stage;
+    this.measuredLength = measuredLength;
+    this.limit = limit;
+  }
+}
+
+const PI_PACKAGE_NAME = '@earendil-works/pi-coding-agent';
+const PI_PACKAGE_MANIFEST = `${PI_PACKAGE_NAME}/package.json`;
+const WINDOWS_COMMAND_LINE_LIMIT = 32767;
+
+interface JsonRecord {
+  readonly [key: string]: unknown;
+}
+
+function defaultResolvePackageJson(specifier: string): string {
+  const requireForPi = createRequire(import.meta.url);
+  try {
+    return requireForPi.resolve(specifier);
+  } catch (manifestError) {
+    if (specifier !== PI_PACKAGE_MANIFEST) throw manifestError;
+    let packageEntry: string;
+    try {
+      packageEntry = fileURLToPath(import.meta.resolve(PI_PACKAGE_NAME));
+    } catch (entryError) {
+      throw new Error(
+        `${errorMessage(manifestError)}; package entry resolve failed: ${errorMessage(entryError)}`,
+      );
+    }
+    const diagnostics: string[] = [];
+    let dir = dirname(packageEntry);
+    for (;;) {
+      const candidate = join(dir, 'package.json');
+      try {
+        if (statSync(candidate).isFile()) return candidate;
+        diagnostics.push(`${candidate} is not a regular file`);
+      } catch (statError) {
+        diagnostics.push(`${candidate}: ${errorMessage(statError)}`);
+      }
+      const parent = dirname(dir);
+      if (parent === dir) {
+        throw new Error(
+          `${errorMessage(manifestError)}; package entry search failed: ${diagnostics.join('; ')}`,
+        );
+      }
+      dir = parent;
+    }
+  }
+}
+
+function failResolution(message: string): never {
+  throw new PiLaunchResolutionError(message);
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function readPath<T>(label: string, path: string, action: () => T): T {
+  try {
+    return action();
+  } catch (error) {
+    failResolution(`${label} failed for ${path}: ${errorMessage(error)}`);
+  }
+}
+
+function isJsonRecord(value: unknown): value is JsonRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseManifest(raw: string | Buffer, manifestPath: string): JsonRecord {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(Buffer.isBuffer(raw) ? raw.toString('utf8') : raw);
+  } catch (error) {
+    failResolution(`manifest JSON is invalid at ${manifestPath}: ${errorMessage(error)}`);
+  }
+  if (!isJsonRecord(parsed)) failResolution(`manifest is not an object at ${manifestPath}`);
+  return parsed;
+}
+
+function readPiBin(manifest: JsonRecord, manifestPath: string): string {
+  const bin = manifest['bin'];
+  if (typeof bin === 'string' && bin.trim().length > 0) return bin;
+  if (isJsonRecord(bin)) {
+    const pi = bin['pi'];
+    if (typeof pi === 'string' && pi.trim().length > 0) return pi;
+  }
+  failResolution(`manifest bin.pi is missing or malformed at ${manifestPath}`);
+}
+
+function pathInside(parent: string, child: string): boolean {
+  const rel = relative(parent, child);
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel) && !rel.split(sep).includes('..'));
+}
+
+export function resolvePiLaunch(deps: PiLaunchDependencies = {}): PiLaunchSpec {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== 'win32') return { executable: 'pi', argvPrefix: [], kind: 'path' };
+
+  const resolvePackageJson = deps.resolvePackageJson ?? defaultResolvePackageJson;
+  const readFile = deps.readFile ?? readFileSync;
+  const realpath = deps.realpath ?? realpathSync;
+  const stat = deps.stat ?? statSync;
+  const execPath = deps.execPath ?? process.execPath;
+
+  let manifestPath: string;
+  try {
+    manifestPath = resolvePackageJson(PI_PACKAGE_MANIFEST);
+  } catch (error) {
+    failResolution(`package manifest resolve failed for ${PI_PACKAGE_MANIFEST}: ${errorMessage(error)}`);
+  }
+
+  const packageRoot = dirname(manifestPath);
+  const packageRootReal = readPath('package root realpath', packageRoot, () => realpath(packageRoot));
+  const manifest = parseManifest(
+    readPath('manifest read', manifestPath, () => readFile(manifestPath)),
+    manifestPath,
+  );
+  const bin = readPiBin(manifest, manifestPath);
+  const targetCandidate = join(packageRoot, bin);
+  const targetReal = readPath('bin target realpath', targetCandidate, () => realpath(targetCandidate));
+  if (!pathInside(packageRootReal, targetReal)) {
+    failResolution('Pi package bin target resolves outside the package root');
+  }
+  const targetStat = readPath('bin target stat', targetReal, () => stat(targetReal));
+  if (!targetStat.isFile()) failResolution('Pi package bin target is not a regular file');
+
+  const extension = extname(targetReal).toLowerCase();
+  if (extension === '.js' || extension === '.cjs' || extension === '.mjs') {
+    return { executable: execPath, argvPrefix: [targetReal], kind: 'package-node-cli' };
+  }
+  if (extension === '.exe' || extension === '.com') {
+    return { executable: targetReal, argvPrefix: [], kind: 'package-node-cli' };
+  }
+  failResolution(`Pi package bin target extension is unsupported: ${extension || '<none>'}`);
+}
+
+export function piLaunchArgv(launch: PiLaunchSpec, piArgs: readonly string[]): string[] {
+  return [...launch.argvPrefix, ...piArgs];
+}
+
+function renderWindowsArgument(value: string): string {
+  if (value.length > 0 && !/[ \t"]/.test(value)) return value;
+  let rendered = '"';
+  let backslashes = 0;
+  for (const char of value) {
+    if (char === '\\') {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      rendered += '\\'.repeat(backslashes * 2 + 1);
+      rendered += '"';
+      backslashes = 0;
+      continue;
+    }
+    if (backslashes > 0) {
+      rendered += '\\'.repeat(backslashes);
+      backslashes = 0;
+    }
+    rendered += char;
+  }
+  if (backslashes > 0) rendered += '\\'.repeat(backslashes * 2);
+  rendered += '"';
+  return rendered;
+}
+
+function renderWindowsCommandLine(parts: readonly string[]): string {
+  return parts.map(renderWindowsArgument).join(' ');
+}
+
+export function assertWindowsCommandLineWithinLimit(
+  launch: PiLaunchSpec,
+  piArgs: readonly string[],
+  platform: NodeJS.Platform,
+  stage: string,
+): void {
+  if (platform !== 'win32') return;
+  const measuredLength =
+    renderWindowsCommandLine([launch.executable, ...launch.argvPrefix, ...piArgs]).length + 1;
+  if (measuredLength > WINDOWS_COMMAND_LINE_LIMIT) {
+    throw new PiCommandLineLimitError(stage, measuredLength, WINDOWS_COMMAND_LINE_LIMIT);
+  }
+}