@gobing-ai/ts-runtime 0.2.7 → 0.2.9

package/src/fs.ts

@@ -1,18 +1,5 @@
-import { createWriteStream, mkdirSync } from 'node:fs';
-import {
-    access,
-    appendFile,
-    cp,
-    mkdir,
-    readdir,
-    readFile,
-    realpath,
-    rename,
-    rm,
-    stat,
-    writeFile,
-} from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirnamePath, getProcessCwd, joinPath, resolvePath } from './path';
 
 export interface FileStat {
     isFile(): boolean;
@@ -41,26 +28,55 @@ export interface FileSystem {
     createLogStream(path: string): LogStream;
 }
 
+export interface SyncFileSystem {
+    readFile(path: string): string;
+    writeFile(path: string, content: string): void;
+    mkdir(path: string): void;
+    readDir(path: string): string[];
+    unlink(path: string): void;
+}
+
+type NodeFsPromises = typeof import('node:fs/promises');
+type NodeFs = typeof import('node:fs');
+
+let fsPromisesModule: Promise<NodeFsPromises> | null = null;
+let fsModule: Promise<NodeFs> | null = null;
+
+function nodeFsPromises(): Promise<NodeFsPromises> {
+    fsPromisesModule ??= import('node:fs/promises');
+    return fsPromisesModule;
+}
+
+function nodeFs(): Promise<NodeFs> {
+    fsModule ??= import('node:fs');
+    return fsModule;
+}
+
 export class NodeFileSystem implements FileSystem {
     async readFile(path: string): Promise<string> {
+        const { readFile } = await nodeFsPromises();
         return await readFile(path, 'utf-8');
     }
 
     async writeFile(path: string, content: string): Promise<void> {
+        const { writeFile } = await nodeFsPromises();
         await ensureDirForFile(path, this);
         await writeFile(path, content, 'utf-8');
     }
 
     async appendFile(path: string, content: string): Promise<void> {
+        const { appendFile } = await nodeFsPromises();
         await ensureDirForFile(path, this);
         await appendFile(path, content, 'utf-8');
     }
 
     async mkdir(path: string): Promise<void> {
+        const { mkdir } = await nodeFsPromises();
         await mkdir(path, { recursive: true });
     }
 
     async exists(path: string): Promise<boolean> {
+        const { access } = await nodeFsPromises();
         try {
             await access(path);
             return true;
@@ -70,14 +86,17 @@ export class NodeFileSystem implements FileSystem {
     }
 
     async readDir(path: string): Promise<string[]> {
+        const { readdir } = await nodeFsPromises();
         return await readdir(path);
     }
 
     async unlink(path: string): Promise<void> {
+        const { rm } = await nodeFsPromises();
         await rm(path, { recursive: true, force: true });
     }
 
     async stat(path: string): Promise<FileStat | null> {
+        const { stat } = await nodeFsPromises();
         try {
             const value = await stat(path);
             return {
@@ -92,20 +111,80 @@ export class NodeFileSystem implements FileSystem {
     }
 
     async realpath(path: string): Promise<string> {
+        const { realpath } = await nodeFsPromises();
         return await realpath(path);
     }
 
     async copy(src: string, dest: string): Promise<void> {
+        const { cp } = await nodeFsPromises();
         await cp(src, dest, { recursive: true });
     }
 
     async rename(src: string, dest: string): Promise<void> {
+        const { rename } = await nodeFsPromises();
         await rename(src, dest);
     }
 
     createLogStream(path: string): LogStream {
-        mkdirSync(dirname(path), { recursive: true });
-        return createWriteStream(path, { flags: 'a' });
+        return new LazyNodeLogStream(path);
+    }
+}
+
+export class NodeSyncFileSystem implements SyncFileSystem {
+    readFile(path: string): string {
+        return readFileSync(path, 'utf-8');
+    }
+
+    writeFile(path: string, content: string): void {
+        ensureDirForFileSync(path, this);
+        writeFileSync(path, content, 'utf-8');
+    }
+
+    mkdir(path: string): void {
+        mkdirSync(path, { recursive: true });
+    }
+
+    readDir(path: string): string[] {
+        return readdirSync(path);
+    }
+
+    unlink(path: string): void {
+        rmSync(path, { recursive: true, force: true });
+    }
+}
+
+class LazyNodeLogStream implements LogStream {
+    private readonly ready: Promise<{
+        write: (chunk: string) => void;
+        end: () => void;
+    }>;
+    private ended = false;
+    // Single serialized chain: every write/end is appended here, so the underlying stream observes
+    // them in call order regardless of how the resolving microtasks interleave. A per-write `shift()`
+    // off a shared buffer (the previous approach) could reorder writes that arrived in the same tick.
+    private tail: Promise<unknown>;
+
+    constructor(path: string) {
+        this.ready = nodeFs().then(({ createWriteStream, mkdirSync }) => {
+            mkdirSync(dirnamePath(path), { recursive: true });
+            const stream = createWriteStream(path, { flags: 'a' });
+            return {
+                write: (chunk: string) => stream.write(chunk),
+                end: () => stream.end(),
+            };
+        });
+        this.tail = this.ready;
+    }
+
+    write(chunk: string): void {
+        if (this.ended) return;
+        this.tail = this.tail.then(() => this.ready.then((stream) => stream.write(chunk)));
+    }
+
+    end(): void {
+        if (this.ended) return;
+        this.ended = true;
+        this.tail = this.tail.then(() => this.ready.then((stream) => stream.end()));
     }
 }
 
@@ -180,12 +259,16 @@ export function getFs(): FileSystem {
 }
 
 export async function ensureDirForFile(path: string, fs = getFs()): Promise<void> {
-    await fs.mkdir(dirname(path));
+    await fs.mkdir(dirnamePath(path));
+}
+
+export function ensureDirForFileSync(path: string, fs: SyncFileSystem): void {
+    fs.mkdir(dirnamePath(path));
 }
 
 export async function atomicWriteFile(path: string, content: string, fs = getFs()): Promise<void> {
     await ensureDirForFile(path, fs);
-    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    const tempPath = `${path}.${getProcessPid()}.${uniqueToken()}.tmp`;
     await fs.writeFile(tempPath, content);
     await fs.rename(tempPath, path);
 }
@@ -206,7 +289,7 @@ export async function walkDir(path: string, fs = getFs()): Promise<string[]> {
     const entries = (await fs.readDir(path)).sort();
     const result: string[] = [];
     for (const entry of entries) {
-        const fullPath = join(path, entry);
+        const fullPath = joinPath(path, entry);
         const entryStat = await fs.stat(fullPath);
         if (entryStat?.isDirectory()) {
             result.push(...(await walkDir(fullPath, fs)));
@@ -217,13 +300,13 @@ export async function walkDir(path: string, fs = getFs()): Promise<string[]> {
     return result;
 }
 
-export function getProjectRoot(startDir = process.cwd()): string {
-    let current = resolve(startDir);
+export function getProjectRoot(startDir = getProcessCwd()): string {
+    let current = resolvePath(startDir);
     for (let i = 0; i < 12; i++) {
-        if (Bun.file(join(current, 'bun.lock')).size !== 0 || Bun.file(join(current, 'package.json')).size !== 0) {
+        if (hasBunFile(joinPath(current, 'bun.lock')) || hasBunFile(joinPath(current, 'package.json'))) {
             return current;
         }
-        const parent = dirname(current);
+        const parent = dirnamePath(current);
         if (parent === current) return startDir;
         current = parent;
     }
@@ -231,9 +314,25 @@ export function getProjectRoot(startDir = process.cwd()): string {
 }
 
 export function resolveProjectPath(...segments: string[]): string {
-    return resolve(getProjectRoot(), ...segments);
+    return resolvePath(getProjectRoot(), ...segments);
 }
 
 export function createLogStream(path: string, fs = getFs()): LogStream {
     return fs.createLogStream(path);
 }
+
+function hasBunFile(path: string): boolean {
+    const bun = (globalThis as { Bun?: { file: (path: string) => { size: number } } }).Bun;
+    if (bun === undefined) return false;
+    return bun.file(path).size !== 0;
+}
+
+function getProcessPid(): number {
+    return (globalThis as { process?: { pid?: number } }).process?.pid ?? 0;
+}
+
+// Two writers to the same path in the same millisecond must not share a temp name, or one clobbers
+// the other before rename. randomUUID disambiguates; Date.now keeps names sortable for debugging.
+function uniqueToken(): string {
+    return `${Date.now()}.${crypto.randomUUID()}`;
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './config';
 export * from './context';
 export * from './fs';
+export * from './path';
 export * from './process-executor';
+export * from './schema-validation';
 export * from './types';

package/src/path.ts

@@ -0,0 +1,54 @@
+// Runtime-portable path math. Deliberately avoids `node:path` so the same logic works on
+// `cloudflare-workers` (no `node:*`) as on node-bun (ADR-008). POSIX-style separators throughout;
+// Windows drive paths (`C:/...`) are normalized and treated as absolute.
+
+export function normalizeSeparators(path: string): string {
+    return path.replaceAll('\\', '/');
+}
+
+export function isAbsolutePath(path: string): boolean {
+    return path.startsWith('/') || /^[A-Za-z]:\//.test(normalizeSeparators(path));
+}
+
+export function dirnamePath(path: string): string {
+    const input = normalizeSeparators(path);
+    if (/^\/+$/.test(input)) return '/';
+    const normalized = input.replace(/\/+$/, '');
+    if (normalized === '' || normalized === '/') return normalized || '.';
+    const index = normalized.lastIndexOf('/');
+    if (index < 0) return '.';
+    if (index === 0) return '/';
+    return normalized.slice(0, index);
+}
+
+export function joinPath(...segments: string[]): string {
+    const filtered = segments.filter((segment) => segment.length > 0).map(normalizeSeparators);
+    if (filtered.length === 0) return '.';
+    const absolute = isAbsolutePath(filtered[0] ?? '');
+    const joined = filtered.join('/').replace(/\/+/g, '/');
+    return absolute ? joined : joined.replace(/^\//, '');
+}
+
+export function resolvePath(...segments: string[]): string {
+    const candidates = segments.length === 0 ? [getProcessCwd()] : segments;
+    let resolved = '';
+    for (const segment of candidates.map(normalizeSeparators)) {
+        if (segment.length === 0) continue;
+        resolved = isAbsolutePath(segment) ? segment : joinPath(resolved || getProcessCwd(), segment);
+    }
+    const parts: string[] = [];
+    const absolute = isAbsolutePath(resolved);
+    for (const part of resolved.split('/')) {
+        if (part === '' || part === '.') continue;
+        if (part === '..') {
+            parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+    return `${absolute ? '/' : ''}${parts.join('/')}` || (absolute ? '/' : '.');
+}
+
+export function getProcessCwd(): string {
+    return (globalThis as { process?: { cwd?: () => string } }).process?.cwd?.() ?? '/';
+}

package/src/process-executor.ts

@@ -13,6 +13,11 @@ export interface ProcessOptions {
     command: string;
     args?: string[];
     cwd?: string;
+    /**
+     * Environment forwarded verbatim to the child process. Caller-controlled — when launching an
+     * untrusted command, pass an explicit allowlist rather than the parent's full environment, so
+     * inherited secrets are not leaked into the subprocess.
+     */
     env?: Record<string, string>;
     timeout?: number;
     /** Maximum output buffer size in bytes (maps to execa `maxBuffer`). */
@@ -36,6 +41,32 @@ export interface ProcessExecutor {
     run(options: ProcessOptions): Promise<ProcessResult>;
 }
 
+export interface SyncProcessExecutor {
+    runSync(options: Omit<ProcessOptions, 'timeout'>): ProcessResult;
+}
+
+export interface PipeProcessOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    /** Forwarded verbatim to the child — pass an allowlist for untrusted commands (see {@link ProcessOptions.env}). */
+    env?: Record<string, string>;
+}
+
+export interface PipeProcess {
+    readonly pid: number | null;
+    readonly stdout: ReadableStream<Uint8Array> | null;
+    readonly stderr: ReadableStream<Uint8Array> | null;
+    readonly exited: Promise<number | null>;
+    writeStdin(input: string | Uint8Array): void;
+    endStdin(): void;
+    kill(signal?: ProcessSignal): void;
+}
+
+export interface PipeProcessSpawner {
+    spawn(options: PipeProcessOptions): PipeProcess;
+}
+
 export class NodeProcessExecutor implements ProcessExecutor {
     constructor(private readonly config: ProcessExecutorConfig = {}) {}
 
@@ -84,6 +115,95 @@ export class NodeProcessExecutor implements ProcessExecutor {
     }
 }
 
+export class BunSyncProcessExecutor implements SyncProcessExecutor {
+    runSync(options: Omit<ProcessOptions, 'timeout'>): ProcessResult {
+        const args = options.args ?? [];
+        const startedAt = Date.now();
+        const result = Bun.spawnSync({
+            cmd: [options.command, ...args],
+            stdout: 'pipe',
+            stderr: 'pipe',
+            stdin: 'ignore',
+            ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+            ...(options.env !== undefined ? { env: options.env } : {}),
+        });
+        if (options.rejectOnError === true && result.exitCode !== 0) {
+            throw new Error(
+                `${options.command} ${args.join(' ')} failed with exit code ${result.exitCode}: ${stripFinalNewline(
+                    asString(result.stderr),
+                )}`,
+            );
+        }
+        return {
+            command: options.command,
+            args,
+            exitCode: result.exitCode,
+            stdout: stripFinalNewline(asString(result.stdout)),
+            stderr: stripFinalNewline(asString(result.stderr)),
+            durationMs: Date.now() - startedAt,
+        };
+    }
+}
+
+export class BunPipeProcessSpawner implements PipeProcessSpawner {
+    spawn(options: PipeProcessOptions): PipeProcess {
+        const subprocess = Bun.spawn({
+            cmd: [options.command, ...(options.args ?? [])],
+            stdin: 'pipe',
+            stdout: 'pipe',
+            stderr: 'pipe',
+            ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+            ...(options.env !== undefined ? { env: options.env } : {}),
+        });
+        return new BunPipeProcess(subprocess);
+    }
+}
+
+type BunSubprocess = ReturnType<typeof Bun.spawn>;
+type ProcessSignal = Parameters<BunSubprocess['kill']>[0];
+type StdinSink = {
+    write: (data: string | Uint8Array) => unknown;
+    end?: () => unknown;
+    flush?: () => unknown;
+};
+
+class BunPipeProcess implements PipeProcess {
+    private readonly writer: StdinSink;
+
+    constructor(private readonly subprocess: BunSubprocess) {
+        this.writer = subprocess.stdin as StdinSink;
+    }
+
+    get pid(): number | null {
+        return this.subprocess.pid ?? null;
+    }
+
+    get stdout(): ReadableStream<Uint8Array> | null {
+        return isReadableStream(this.subprocess.stdout) ? this.subprocess.stdout : null;
+    }
+
+    get stderr(): ReadableStream<Uint8Array> | null {
+        return isReadableStream(this.subprocess.stderr) ? this.subprocess.stderr : null;
+    }
+
+    get exited(): Promise<number | null> {
+        return this.subprocess.exited;
+    }
+
+    writeStdin(input: string | Uint8Array): void {
+        this.writer.write(input);
+        this.writer.flush?.();
+    }
+
+    endStdin(): void {
+        this.writer.end?.();
+    }
+
+    kill(signal?: ProcessSignal): void {
+        this.subprocess.kill(signal);
+    }
+}
+
 function buildExecaOptions(opts: {
     cwd: string | undefined;
     env: Record<string, string> | undefined;
@@ -116,3 +236,11 @@ function asString(value: string | string[] | unknown[] | Uint8Array | undefined)
     if (Array.isArray(value)) return value.map(String).join('');
     return '';
 }
+
+function stripFinalNewline(value: string): string {
+    return value.endsWith('\r\n') ? value.slice(0, -2) : value.endsWith('\n') ? value.slice(0, -1) : value;
+}
+
+function isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {
+    return value instanceof ReadableStream;
+}