@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/src/sdk/broker/process-incarnation.ts

@@ -0,0 +1,151 @@
+import { dlopen, ptr } from "bun:ffi";
+import { Process } from "@sayknow-cli/natives";
+import { readLinuxProcStartTimeSync } from "../../skc-runtime/linux-proc";
+
+const DARWIN_PROC_PIDTBSDINFO = 3;
+const DARWIN_PROC_BSDINFO_SIZE = 136;
+const DARWIN_PROC_BSDINFO_START_SECONDS_OFFSET = 120;
+const DARWIN_PROC_BSDINFO_START_MICROSECONDS_OFFSET = 128;
+const POWERSHELL_PROCESS_INCARNATION_COMMAND = "powershell.exe";
+const WIN32_PROCESS_INCARNATION_OUTPUT = /^(\d+)\t(0|[1-9]\d*)(?:\r?\n)?$/;
+const MAX_WINDOWS_FILETIME_TICKS = 18_446_744_073_709_551_615n;
+
+const darwinProcLibrary =
+	process.platform === "darwin"
+		? (() => {
+				try {
+					return dlopen("/usr/lib/libproc.dylib", {
+						proc_pidinfo: {
+							args: ["i32", "i32", "u64", "ptr", "i32"],
+							returns: "i32",
+						},
+					});
+				} catch {
+					return undefined;
+				}
+			})()
+		: undefined;
+
+type ProcessIncarnationCommandResult = { exitCode: number | null; stdout: string } | undefined;
+
+export type ProcessIncarnationCommandRunner = (
+	command: string,
+	args: readonly string[],
+) => ProcessIncarnationCommandResult;
+
+export interface ProcessIncarnationOptions {
+	platform?: typeof process.platform;
+	runCommand?: ProcessIncarnationCommandRunner;
+}
+
+function runProcessIncarnationCommand(command: string, args: readonly string[]): ProcessIncarnationCommandResult {
+	try {
+		const result = Bun.spawnSync([command, ...args], { stdin: "ignore", stdout: "pipe", stderr: "ignore" });
+		return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout).toString("utf8") };
+	} catch {
+		return undefined;
+	}
+}
+
+function windowsProcessIncarnationCommand(pid: number): { command: string; args: string[] } {
+	return {
+		command: POWERSHELL_PROCESS_INCARNATION_COMMAND,
+		args: [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			[
+				"$ErrorActionPreference = 'Stop'",
+				"$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+				`$process = Get-Process -Id ${pid} -ErrorAction Stop`,
+				"$filetime = [UInt64]($process.StartTime.ToUniversalTime().ToFileTimeUtc())",
+				'[Console]::Out.WriteLine(("{0}`t{1}" -f $process.Id, $filetime))',
+			].join("; "),
+		],
+	};
+}
+
+function isWindowsFiletimeTicks(value: string): boolean {
+	if (!/^(?:0|[1-9]\d*)$/.test(value)) return false;
+	try {
+		return BigInt(value) <= MAX_WINDOWS_FILETIME_TICKS;
+	} catch {
+		return false;
+	}
+}
+
+function parseWin32ProcessIncarnation(pid: number, output: string): string | undefined {
+	const match = WIN32_PROCESS_INCARNATION_OUTPUT.exec(output);
+	if (!match || match[1] !== String(pid) || !isWindowsFiletimeTicks(match[2])) return undefined;
+	return `windows:${match[2]}`;
+}
+
+/** Parse the microsecond-resolution start timestamp returned by Darwin proc_pidinfo. */
+export function parseDarwinProcessIncarnation(info: Uint8Array): string | undefined {
+	if (info.byteLength < DARWIN_PROC_BSDINFO_SIZE) return undefined;
+	try {
+		const view = new DataView(info.buffer, info.byteOffset, info.byteLength);
+		const seconds = view.getBigUint64(DARWIN_PROC_BSDINFO_START_SECONDS_OFFSET, true);
+		const microseconds = view.getBigUint64(DARWIN_PROC_BSDINFO_START_MICROSECONDS_OFFSET, true);
+		if (seconds === 0n || microseconds >= 1_000_000n) return undefined;
+		return `darwin:${seconds}:${microseconds}`;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Whether `value` is a canonical process-incarnation string (`linux:`/`darwin:`/`windows:`). */
+export function isProcessIncarnation(value: unknown): value is string {
+	return (
+		typeof value === "string" &&
+		(/^(?:linux:\d+|darwin:[1-9]\d*:\d+)$/.test(value) ||
+			(value.startsWith("windows:") && isWindowsFiletimeTicks(value.slice("windows:".length))))
+	);
+}
+
+/** A PID is reusable; bind it to the strongest OS-provided process start incarnation available. */
+export function processIncarnation(pid: number, options: ProcessIncarnationOptions = {}): string | undefined {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return undefined;
+	const platform = options.platform ?? process.platform;
+	if (platform === process.platform && options.runCommand === undefined) {
+		try {
+			const nativeProcess = Process.fromPid(pid) as { incarnation?: unknown } | null;
+			if (isProcessIncarnation(nativeProcess?.incarnation)) return nativeProcess.incarnation;
+		} catch {
+			// Fall through to the platform-specific reader.
+		}
+	}
+	if (platform === "linux") {
+		const startTicks = readLinuxProcStartTimeSync(pid);
+		return startTicks ? `linux:${startTicks}` : undefined;
+	}
+	if (platform === "darwin") {
+		const info = new Uint8Array(DARWIN_PROC_BSDINFO_SIZE);
+		try {
+			const bytesRead = darwinProcLibrary?.symbols.proc_pidinfo(
+				pid,
+				DARWIN_PROC_PIDTBSDINFO,
+				0,
+				ptr(info),
+				info.byteLength,
+			);
+			return bytesRead === DARWIN_PROC_BSDINFO_SIZE ? parseDarwinProcessIncarnation(info) : undefined;
+		} catch {
+			return undefined;
+		}
+	}
+	if (platform === "win32") {
+		const command = windowsProcessIncarnationCommand(pid);
+		let result: ProcessIncarnationCommandResult;
+		try {
+			result = (options.runCommand ?? runProcessIncarnationCommand)(command.command, command.args);
+		} catch {
+			return undefined;
+		}
+		return result?.exitCode === 0 && typeof result.stdout === "string"
+			? parseWin32ProcessIncarnation(pid, result.stdout)
+			: undefined;
+	}
+	return undefined;
+}

package/src/sdk/broker/runtime.ts

@@ -0,0 +1,164 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import internalSourceMarker from "./internal-source-marker-2178.txt" with { type: "file" };
+
+export type SdkInternalAction = "broker-internal" | "session-host-internal";
+
+export type SdkInternalSpawnCommand =
+	| {
+			kind: "bun-source";
+			file: string;
+			args: string[];
+			env: NodeJS.ProcessEnv;
+			cwd: string;
+	  }
+	| {
+			kind: "compiled";
+			file: string;
+			args: string[];
+			env: NodeJS.ProcessEnv;
+			cwd?: undefined;
+	  };
+
+type EmbeddedFile = Blob | { name: string };
+
+/** Test-only injectable inputs for hostile evidence and platform grammar coverage. */
+export interface SdkInternalRuntimeDescriptorTestOptions {
+	execPath?: string;
+	environment?: NodeJS.ProcessEnv;
+	embeddedFiles?: readonly EmbeddedFile[];
+	markerPath?: string;
+	brokerDirectory?: string;
+	cliPath?: string;
+	configPath?: string;
+	bunAvailable?: boolean;
+}
+
+const COMPILED_MARKER_NAME = /^internal-source-marker-2178-[A-Za-z0-9]+\.txt$/;
+const POSIX_MARKER_VFS_PATH = /^\/\$bunfs\/root\/internal-source-marker-2178-[A-Za-z0-9]+\.txt$/;
+const WINDOWS_MARKER_VFS_PATH = /^[A-Za-z]:\/~BUN\/(?:root\/)?internal-source-marker-2178-[A-Za-z0-9]+\.txt$/;
+
+function isCompiledMarkerPath(markerPath: string): boolean {
+	const normalized = markerPath.replaceAll("\\", "/");
+	return POSIX_MARKER_VFS_PATH.test(normalized) || WINDOWS_MARKER_VFS_PATH.test(normalized);
+}
+function embeddedFileName(file: EmbeddedFile): string | undefined {
+	return "name" in file && typeof file.name === "string" ? file.name : undefined;
+}
+
+function containedPath(parent: string, candidate: string): boolean {
+	const relative = path.relative(parent, candidate);
+	return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+
+function regularReadablePath(file: string, label: string): string {
+	let canonical: string;
+	try {
+		canonical = fs.realpathSync(file);
+		const stat = fs.statSync(canonical);
+		fs.accessSync(canonical, fs.constants.R_OK);
+		if (!stat.isFile()) throw new Error("not a regular file");
+	} catch {
+		throw new Error(`SDK internal launch refused: ${label} is not a readable regular file.`);
+	}
+	return canonical;
+}
+
+function internalEnvironment(environment: NodeJS.ProcessEnv, source: boolean): NodeJS.ProcessEnv {
+	const isolated = { ...environment };
+	delete isolated.BUN_OPTIONS;
+	if (source) {
+		delete isolated.PI_COMPILED;
+		delete isolated.SKC_COMPILED;
+	}
+	return isolated;
+}
+function expectedPackageName(packageDirectory: string): void {
+	try {
+		const manifest = JSON.parse(fs.readFileSync(path.join(packageDirectory, "package.json"), "utf8")) as {
+			name?: unknown;
+		};
+		if (manifest.name !== "@sayknow-cli/coding-agent") throw new Error("unexpected package name");
+	} catch {
+		throw new Error("SDK internal launch refused: product package identity is invalid.");
+	}
+}
+
+function sourceDescriptor(
+	action: SdkInternalAction,
+	options: SdkInternalRuntimeDescriptorTestOptions,
+	markerPath: string,
+): SdkInternalSpawnCommand {
+	if (options.bunAvailable === false || typeof Bun === "undefined")
+		throw new Error("SDK internal launch refused: Bun source runtime is unavailable.");
+	const brokerDirectory = path.resolve(options.brokerDirectory ?? import.meta.dir);
+	const packageDirectory = path.resolve(brokerDirectory, "../../..");
+	const sourceDirectory = path.resolve(brokerDirectory, "../..");
+	const runtime = regularReadablePath(path.resolve(options.execPath ?? process.execPath), "runtime executable");
+	const cli = regularReadablePath(
+		path.resolve(options.cliPath ?? path.join(sourceDirectory, "cli.ts")),
+		"CLI entrypoint",
+	);
+	const config = regularReadablePath(
+		path.resolve(options.configPath ?? path.join(brokerDirectory, "internal-source.bunfig.toml")),
+		"isolated Bun configuration",
+	);
+	const marker = regularReadablePath(path.resolve(markerPath), "source marker");
+	const canonicalBrokerDirectory = fs.realpathSync(brokerDirectory);
+	const canonicalPackageDirectory = fs.realpathSync(packageDirectory);
+	const canonicalSourceDirectory = fs.realpathSync(sourceDirectory);
+	expectedPackageName(canonicalPackageDirectory);
+	if (
+		!containedPath(canonicalPackageDirectory, canonicalBrokerDirectory) ||
+		!containedPath(canonicalPackageDirectory, canonicalSourceDirectory) ||
+		!containedPath(canonicalSourceDirectory, cli) ||
+		!containedPath(canonicalBrokerDirectory, config) ||
+		!containedPath(canonicalBrokerDirectory, marker)
+	)
+		throw new Error("SDK internal launch refused: product runtime assets escape their trusted directories.");
+	return {
+		kind: "bun-source",
+		file: runtime,
+		args: ["--no-env-file", `--config=${config}`, cli, "sdk", action],
+		env: internalEnvironment(options.environment ?? process.env, true),
+		cwd: canonicalBrokerDirectory,
+	};
+}
+
+function resolveSdkInternalSpawnCommandWithEvidence(
+	action: SdkInternalAction,
+	options: SdkInternalRuntimeDescriptorTestOptions,
+): SdkInternalSpawnCommand {
+	const markerPath = options.markerPath ?? internalSourceMarker;
+	const embeddedFiles = options.embeddedFiles ?? (typeof Bun === "undefined" ? undefined : Bun.embeddedFiles);
+	if (!embeddedFiles) throw new Error("SDK internal launch refused: Bun runtime evidence is unavailable.");
+	const markerName = path.basename(markerPath.replaceAll("\\", "/"));
+	const markerEntries = embeddedFiles.filter(file => embeddedFileName(file) === markerName);
+	const compiledMarkerPath = isCompiledMarkerPath(markerPath);
+	const exactCompiledArtifact = COMPILED_MARKER_NAME.test(markerName) && markerEntries.length === 1;
+	const isSourceMarker = path.isAbsolute(markerPath) && !compiledMarkerPath;
+	if (embeddedFiles.length === 0 && isSourceMarker) return sourceDescriptor(action, options, markerPath);
+	if (exactCompiledArtifact && compiledMarkerPath) {
+		const executable = regularReadablePath(path.resolve(options.execPath ?? process.execPath), "compiled executable");
+		return {
+			kind: "compiled",
+			file: executable,
+			args: ["sdk", action],
+			env: internalEnvironment(options.environment ?? process.env, false),
+		};
+	}
+	throw new Error("SDK internal launch refused: compiled-runtime marker evidence is inconsistent.");
+}
+
+/** Resolve the production descriptor from the statically imported marker and current Bun runtime evidence. */
+export function resolveSdkInternalSpawnCommand(action: SdkInternalAction): SdkInternalSpawnCommand {
+	return resolveSdkInternalSpawnCommandWithEvidence(action, {});
+}
+
+/** Test hook: injects runtime evidence without weakening the production marker authority. */
+export function resolveSdkInternalSpawnCommandForTest(
+	action: SdkInternalAction,
+	options: SdkInternalRuntimeDescriptorTestOptions,
+): SdkInternalSpawnCommand {
+	return resolveSdkInternalSpawnCommandWithEvidence(action, options);
+}