tywrap 0.2.0 → 0.3.0

package/src/utils/runtime.ts

@@ -432,7 +432,8 @@ export const processUtils = {
    */
   async exec(
     command: string,
-    args: string[] = []
+    args: string[] = [],
+    options: { timeoutMs?: number; env?: Record<string, string | undefined>; cwd?: string } = {}
   ): Promise<{ stdout: string; stderr: string; code: number }> {
     const runtime = detectRuntime();
 
@@ -441,28 +442,88 @@ export const processUtils = {
     }
 
     if (runtime.name === 'deno' && Deno) {
-      const cmd = new Deno.Command(command, { args });
-      const { code, stdout, stderr } = await cmd.output();
+      const timeoutMs = options.timeoutMs;
+      const controller =
+        typeof timeoutMs === 'number' && timeoutMs > 0 ? new AbortController() : undefined;
+      const timeout =
+        controller && typeof timeoutMs === 'number'
+          ? setTimeout(() => controller.abort(), timeoutMs)
+          : undefined;
+      const env: Record<string, string> | undefined =
+        options.env && Object.keys(options.env).length > 0
+          ? Object.fromEntries(
+              Object.entries(options.env)
+                .filter(([, value]) => typeof value === 'string')
+                .map(([key, value]) => [key, value as string])
+            )
+          : undefined;
 
-      return {
-        code,
-        stdout: new TextDecoder().decode(stdout),
-        stderr: new TextDecoder().decode(stderr),
-      };
+      try {
+        const cmd = new Deno.Command(command, {
+          args,
+          ...(options.cwd ? { cwd: options.cwd } : {}),
+          ...(env ? { env } : {}),
+          ...(controller ? { signal: controller.signal } : {}),
+        });
+        const { code, stdout, stderr } = await cmd.output();
+
+        return {
+          code,
+          stdout: new TextDecoder().decode(stdout),
+          stderr: new TextDecoder().decode(stderr),
+        };
+      } catch (error: unknown) {
+        if (controller?.signal.aborted && typeof timeoutMs === 'number') {
+          throw new Error(`Command "${command}" timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
     }
 
     if (runtime.name === 'bun' && Bun) {
+      const timeoutMs = options.timeoutMs;
+      const mergedEnv: Record<string, string> | undefined = options.env
+        ? Object.fromEntries(
+            Object.entries({
+              ...(typeof process !== 'undefined' ? process.env : {}),
+              ...options.env,
+            })
+              .filter(([, value]) => typeof value === 'string')
+              .map(([key, value]) => [key, value as string])
+          )
+        : undefined;
       const proc = Bun.spawn([command, ...args], {
         stdout: 'pipe',
         stderr: 'pipe',
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        ...(mergedEnv ? { env: mergedEnv } : {}),
       });
 
+      let timedOut = false;
+      const timeout =
+        typeof timeoutMs === 'number' && timeoutMs > 0
+          ? setTimeout(() => {
+              timedOut = true;
+              proc.kill?.('SIGKILL');
+            }, timeoutMs)
+          : undefined;
+
       const [stdout, stderr] = await Promise.all([
         new Response(proc.stdout).text(),
         new Response(proc.stderr).text(),
       ]);
 
       await proc.exited;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      if (timedOut && typeof timeoutMs === 'number') {
+        throw new Error(`Command "${command}" timed out after ${timeoutMs}ms`);
+      }
 
       return {
         code: proc.exitCode ?? 0,
@@ -476,15 +537,51 @@ export const processUtils = {
       const { delimiter } = await import('node:path');
 
       return new Promise((resolve, reject) => {
-        const extraPyPath = pathUtils.join(process.cwd(), 'tywrap_ir');
-        const existingPyPath = process.env.PYTHONPATH;
-        const env = {
-          ...process.env,
-          PYTHONPATH: existingPyPath ? `${extraPyPath}${delimiter}${existingPyPath}` : extraPyPath,
-        };
-        const child = spawn(command, args, { env });
+        const cwd = options.cwd ?? process.cwd();
+        const extraPyPath = pathUtils.join(cwd, 'tywrap_ir');
+        const env: Record<string, string> = Object.create(null) as Record<string, string>;
+        Object.entries(process.env).forEach(([key, value]) => {
+          if (value !== undefined) {
+            // eslint-disable-next-line security/detect-object-injection -- environment variable keys are user/runtime supplied
+            env[key] = value;
+          }
+        });
+        Object.entries(options.env ?? {}).forEach(([key, value]) => {
+          if (value === undefined) {
+            // eslint-disable-next-line security/detect-object-injection -- environment variable keys are user/runtime supplied
+            delete env[key];
+            return;
+          }
+          // eslint-disable-next-line security/detect-object-injection -- environment variable keys are user/runtime supplied
+          env[key] = value;
+        });
+        const existingPyPath = env.PYTHONPATH;
+        env.PYTHONPATH = existingPyPath
+          ? `${extraPyPath}${delimiter}${existingPyPath}`
+          : extraPyPath;
+        const child = spawn(command, args, { env, cwd: options.cwd });
         let stdout = '';
         let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        const timeout =
+          typeof options.timeoutMs === 'number' && options.timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGKILL');
+              }, options.timeoutMs)
+            : undefined;
+
+        const finish = (fn: () => void): void => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+          fn();
+        };
 
         child.stdout?.on('data', data => {
           stdout += data.toString();
@@ -495,10 +592,23 @@ export const processUtils = {
         });
 
         child.on('close', code => {
-          resolve({ code: code ?? 0, stdout, stderr });
+          if (timedOut) {
+            const timeoutMs = options.timeoutMs;
+            finish(() =>
+              reject(
+                new Error(
+                  `Command "${command}" timed out after ${typeof timeoutMs === 'number' ? timeoutMs : 0}ms`
+                )
+              )
+            );
+            return;
+          }
+          finish(() => resolve({ code: code ?? 0, stdout, stderr }));
         });
 
-        child.on('error', reject);
+        child.on('error', error => {
+          finish(() => reject(error));
+        });
       });
     }
 
@@ -611,6 +721,7 @@ export const hashUtils = {
       hash = (hash << 5) + hash + text.charCodeAt(i);
       hash |= 0;
     }
-    return Math.abs(hash).toString(16);
+    // Match sha256 hex shape (64 chars) so callers can rely on fixed-length output.
+    return Math.abs(hash).toString(16).padStart(64, '0');
   },
 };