Fix subprocess tests: export format + base64 encoding bug

- Changed all test fixtures from 'export default async function main()'
  to 'export default async () =>' to match funee's expected format
- Fixed base64Encode padding logic bug that added extra null bytes
  when input length wasn't divisible by 3

Author: nev-offload

Cargo.lock

@@ -44,3 +44,7 @@ hyper = { version = "1.0", features = ["server", "http1"] }
 hyper-util = { version = "0.1", features = ["tokio", "server", "server-auto"] }
 http-body-util = "0.1"
 bytes = "1.0"
+
+# Unix process signals
+[target.'cfg(unix)'.dependencies]
+nix = { version = "0.29", features = ["signal"] }

Cargo.toml

@@ -666,3 +666,17 @@ export type {
 } from "./server/index.ts";
 
 export { serve } from "./server/index.ts";
+
+// ============================================================================
+// Subprocess - Child Process Management
+// ============================================================================
+
+export type {
+  SpawnOptions,
+  ProcessStatus,
+  CommandOutput,
+  Process,
+  Signal,
+} from "./process/index.ts";
+
+export { spawn } from "./process/index.ts";

funee-lib/index.ts

@@ -0,0 +1,70 @@
+/**
+ * Subprocess API for funee
+ * 
+ * Provides spawn() for running and managing child processes.
+ * The actual implementation is provided by the runtime bootstrap.
+ * 
+ * @example
+ * ```typescript
+ * import { spawn } from "funee";
+ * 
+ * // Simple usage - returns Promise<CommandOutput>
+ * const result = await spawn("echo", ["hello world"]);
+ * console.log(result.stdoutText()); // "hello world\n"
+ * console.log(result.status.code);  // 0
+ * 
+ * // With options - returns Process handle
+ * const proc = spawn({
+ *   cmd: ["cat"],
+ *   stdin: "piped",
+ *   stdout: "piped",
+ * });
+ * await proc.writeInput("hello");
+ * const output = await proc.output();
+ * console.log(output.stdoutText());  // "hello"
+ * ```
+ */
+
+import type { SpawnOptions, ProcessStatus, CommandOutput, Process, Signal } from "./types.ts";
+
+// Re-export types
+export type { SpawnOptions, ProcessStatus, CommandOutput, Process, Signal } from "./types.ts";
+
+// Declare the global spawn function (provided by runtime bootstrap)
+declare global {
+  function spawn(command: string, args?: string[]): Promise<CommandOutput>;
+  function spawn(options: SpawnOptions): Process;
+}
+
+/**
+ * Spawn a subprocess.
+ * 
+ * Two calling styles supported:
+ * 
+ * 1. Simple form - runs command and waits for output:
+ *    `const result = await spawn("echo", ["hello"]);`
+ *    Returns: Promise<CommandOutput>
+ * 
+ * 2. Options form - returns Process handle for streaming:
+ *    `const proc = spawn({ cmd: ["cat"], stdin: "piped" });`
+ *    Returns: Process
+ * 
+ * @example
+ * ```typescript
+ * // Simple: capture output
+ * const result = await spawn("ls", ["-la"]);
+ * console.log(result.stdoutText());
+ * console.log("Exit code:", result.status.code);
+ * 
+ * // Advanced: streaming with stdin
+ * const proc = spawn({
+ *   cmd: ["grep", "ERROR"],
+ *   stdin: "piped",
+ *   stdout: "piped",
+ * });
+ * await proc.writeInput("ERROR: something bad\nINFO: ok\n");
+ * const filtered = await proc.output();
+ * console.log(filtered.stdoutText());  // "ERROR: something bad\n"
+ * ```
+ */
+export const spawn = globalThis.spawn;

funee-lib/process/index.ts

@@ -0,0 +1,95 @@
+/**
+ * Subprocess Types
+ * 
+ * TypeScript interfaces for funee's subprocess API.
+ */
+
+/**
+ * Signal types supported for process killing
+ */
+export type Signal = 
+  | "SIGTERM"
+  | "SIGKILL"
+  | "SIGINT"
+  | "SIGHUP"
+  | "SIGQUIT";
+
+/**
+ * Options for spawning a subprocess
+ */
+export interface SpawnOptions {
+  /** Command and arguments as array */
+  cmd: string[];
+  
+  /** Working directory for the process */
+  cwd?: string;
+  
+  /** Environment variables (replaces or merges with process env) */
+  env?: Record<string, string>;
+  
+  /** Inherit environment and merge with env option (default: true) */
+  inheritEnv?: boolean;
+  
+  /** How to handle stdin: "piped" | "inherit" | "null" (default: "null") */
+  stdin?: "piped" | "inherit" | "null";
+  
+  /** How to handle stdout: "piped" | "inherit" | "null" (default: "piped") */
+  stdout?: "piped" | "inherit" | "null";
+  
+  /** How to handle stderr: "piped" | "inherit" | "null" (default: "piped") */
+  stderr?: "piped" | "inherit" | "null";
+}
+
+/**
+ * Process exit status
+ */
+export interface ProcessStatus {
+  /** True if process exited with code 0 */
+  success: boolean;
+  
+  /** Exit code (null if terminated by signal) */
+  code: number | null;
+  
+  /** Signal that terminated the process (null if normal exit) */
+  signal: Signal | null;
+}
+
+/**
+ * Output from a completed process
+ */
+export interface CommandOutput {
+  /** Process exit status */
+  status: ProcessStatus;
+  
+  /** Stdout as Uint8Array (empty if stdout not piped) */
+  stdout: Uint8Array;
+  
+  /** Stderr as Uint8Array (empty if stderr not piped) */
+  stderr: Uint8Array;
+  
+  /** Convenience: stdout decoded as UTF-8 string */
+  stdoutText(): string;
+  
+  /** Convenience: stderr decoded as UTF-8 string */
+  stderrText(): string;
+}
+
+/**
+ * Handle to a running subprocess
+ */
+export interface Process {
+  /** Process ID (OS-level PID) */
+  readonly pid: number;
+  
+  /** Promise that resolves with ProcessStatus when process exits */
+  readonly status: Promise<ProcessStatus>;
+  
+  /** Send a signal to the process */
+  kill(signal?: Signal): void;
+  
+  /** Wait for process and collect all output */
+  output(): Promise<CommandOutput>;
+  
+  /** Write data to stdin and close it */
+  writeInput(data: string | Uint8Array): Promise<void>;
+}