@schlenkr/ragents 0.1.0

package/packages/agent/src/utils/photon.ts

@@ -0,0 +1,139 @@
+/**
+ * Photon image processing wrapper.
+ *
+ * This module provides a unified interface to @silvia-odwyer/photon-node that works in:
+ * 1. Node.js (development, npm run build)
+ * 2. Bun compiled binaries (standalone distribution)
+ *
+ * The challenge: photon-node's CJS entry uses fs.readFileSync(__dirname + '/photon_rs_bg.wasm')
+ * which bakes the build machine's absolute path into Bun compiled binaries.
+ *
+ * Solution:
+ * 1. Patch fs.readFileSync to redirect missing photon_rs_bg.wasm reads
+ * 2. Copy photon_rs_bg.wasm next to the executable in build:binary
+ */
+
+import type { PathOrFileDescriptor } from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+const require = createRequire(import.meta.url);
+const fs = require("fs") as typeof import("fs");
+
+// Re-export types from the main package
+export type { PhotonImage as PhotonImageType } from "@silvia-odwyer/photon-node";
+
+type ReadFileSync = typeof fs.readFileSync;
+
+const WASM_FILENAME = "photon_rs_bg.wasm";
+
+// Lazy-loaded photon module
+let photonModule: typeof import("@silvia-odwyer/photon-node") | null = null;
+let loadPromise: Promise<typeof import("@silvia-odwyer/photon-node") | null> | null = null;
+
+function pathOrNull(file: PathOrFileDescriptor): string | null {
+	if (typeof file === "string") {
+		return file;
+	}
+	if (file instanceof URL) {
+		return fileURLToPath(file);
+	}
+	return null;
+}
+
+function getFallbackWasmPaths(): string[] {
+	const execDir = path.dirname(process.execPath);
+	return [
+		path.join(execDir, WASM_FILENAME),
+		path.join(execDir, "photon", WASM_FILENAME),
+		path.join(process.cwd(), WASM_FILENAME),
+	];
+}
+
+function patchPhotonWasmRead(): () => void {
+	const originalReadFileSync: ReadFileSync = fs.readFileSync.bind(fs);
+	const fallbackPaths = getFallbackWasmPaths();
+	const mutableFs = fs as { readFileSync: ReadFileSync };
+
+	const patchedReadFileSync: ReadFileSync = ((...args: Parameters<ReadFileSync>) => {
+		const [file, options] = args;
+		const resolvedPath = pathOrNull(file);
+
+		if (resolvedPath?.endsWith(WASM_FILENAME)) {
+			try {
+				return originalReadFileSync(...args);
+			} catch (error) {
+				const err = error as NodeJS.ErrnoException;
+				if (err?.code && err.code !== "ENOENT") {
+					throw error;
+				}
+
+				for (const fallbackPath of fallbackPaths) {
+					if (!fs.existsSync(fallbackPath)) {
+						continue;
+					}
+					if (options === undefined) {
+						return originalReadFileSync(fallbackPath);
+					}
+					return originalReadFileSync(fallbackPath, options);
+				}
+
+				throw error;
+			}
+		}
+
+		return originalReadFileSync(...args);
+	}) as ReadFileSync;
+
+	try {
+		mutableFs.readFileSync = patchedReadFileSync;
+	} catch {
+		Object.defineProperty(fs, "readFileSync", {
+			value: patchedReadFileSync,
+			writable: true,
+			configurable: true,
+		});
+	}
+
+	return () => {
+		try {
+			mutableFs.readFileSync = originalReadFileSync;
+		} catch {
+			Object.defineProperty(fs, "readFileSync", {
+				value: originalReadFileSync,
+				writable: true,
+				configurable: true,
+			});
+		}
+	};
+}
+
+/**
+ * Load the photon module asynchronously.
+ * Returns cached module on subsequent calls.
+ */
+export async function loadPhoton(): Promise<typeof import("@silvia-odwyer/photon-node") | null> {
+	if (photonModule) {
+		return photonModule;
+	}
+
+	if (loadPromise) {
+		return loadPromise;
+	}
+
+	loadPromise = (async () => {
+		const restoreReadFileSync = patchPhotonWasmRead();
+		try {
+			photonModule = await import("@silvia-odwyer/photon-node");
+			return photonModule;
+		} catch {
+			photonModule = null;
+			return photonModule;
+		} finally {
+			restoreReadFileSync();
+		}
+	})();
+
+	return loadPromise;
+}

package/packages/agent/src/utils/shell.ts

@@ -0,0 +1,225 @@
+import { existsSync } from "node:fs";
+import { delimiter } from "node:path";
+import { spawn, spawnSync } from "child_process";
+import { getBinDir } from "../config.ts";
+
+export interface ShellConfig {
+	shell: string;
+	args: string[];
+	commandTransport?: "argv" | "stdin";
+}
+
+/**
+ * Find bash executable on PATH (cross-platform)
+ */
+function isLegacyWslBashPath(path: string): boolean {
+	const normalized = path.replace(/\//g, "\\").toLowerCase();
+	return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(normalized);
+}
+
+function getBashShellConfig(shell: string): ShellConfig {
+	return isLegacyWslBashPath(shell) ? { shell, args: ["-s"], commandTransport: "stdin" } : { shell, args: ["-c"] };
+}
+
+function findBashOnPath(platform: NodeJS.Platform): string | null {
+	if (platform === "win32") {
+		// Windows: Use 'where' and verify file exists (where can return non-existent paths)
+		try {
+			const result = spawnSync("where", ["bash.exe"], {
+				encoding: "utf-8",
+				timeout: 5000,
+				windowsHide: true,
+			});
+			if (result.status === 0 && result.stdout) {
+				const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+				if (firstMatch && existsSync(firstMatch)) {
+					return firstMatch;
+				}
+			}
+		} catch {
+			// Ignore errors
+		}
+		return null;
+	}
+
+	// Unix: Use 'which' and trust its output (handles Termux and special filesystems)
+	try {
+		const result = spawnSync("which", ["bash"], { encoding: "utf-8", timeout: 5000 });
+		if (result.status === 0 && result.stdout) {
+			const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+			if (firstMatch) {
+				return firstMatch;
+			}
+		}
+	} catch {
+		// Ignore errors
+	}
+	return null;
+}
+
+/**
+ * Resolve shell configuration based on platform and an optional explicit shell path.
+ * Resolution order:
+ * 1. User-specified shellPath
+ * 2. On Windows: Git Bash in known locations, then bash on PATH
+ * 3. On Unix: /bin/bash, then bash on PATH, then fallback to sh
+ */
+export function getShellConfig(customShellPath?: string, platform: NodeJS.Platform = process.platform): ShellConfig {
+	// 1. Check user-specified shell path
+	if (customShellPath) {
+		if (existsSync(customShellPath)) {
+			return getBashShellConfig(customShellPath);
+		}
+		throw new Error(`Custom shell path not found: ${customShellPath}`);
+	}
+
+	if (platform === "win32") {
+		// 2. Try Git Bash in known locations
+		const paths: string[] = [];
+		const programFiles = process.env.ProgramFiles;
+		if (programFiles) {
+			paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+		}
+		const programFilesX86 = process.env["ProgramFiles(x86)"];
+		if (programFilesX86) {
+			paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+		}
+
+		for (const path of paths) {
+			if (existsSync(path)) {
+				return getBashShellConfig(path);
+			}
+		}
+
+		// 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
+		const bashOnPath = findBashOnPath(platform);
+		if (bashOnPath) {
+			return getBashShellConfig(bashOnPath);
+		}
+
+		throw new Error(
+			`No bash shell found. Options:\n` +
+				`  1. Install Git for Windows: https://git-scm.com/download/win\n` +
+				`  2. Add your bash to PATH (Cygwin, MSYS2, etc.)\n` +
+				"  3. Set shellPath in settings.json\n\n" +
+				`Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`,
+		);
+	}
+
+	// Unix: try /bin/bash, then bash on PATH, then fallback to sh
+	if (existsSync("/bin/bash")) {
+		return getBashShellConfig("/bin/bash");
+	}
+
+	const bashOnPath = findBashOnPath(platform);
+	if (bashOnPath) {
+		return getBashShellConfig(bashOnPath);
+	}
+
+	return { shell: "sh", args: ["-c"] };
+}
+
+export function getShellEnv(): NodeJS.ProcessEnv {
+	const binDir = getBinDir();
+	const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+	const currentPath = process.env[pathKey] ?? "";
+	const pathEntries = currentPath.split(delimiter).filter(Boolean);
+	const hasBinDir = pathEntries.includes(binDir);
+	const updatedPath = hasBinDir ? currentPath : [binDir, currentPath].filter(Boolean).join(delimiter);
+
+	return {
+		...process.env,
+		[pathKey]: updatedPath,
+	};
+}
+
+/**
+ * Sanitize binary output for display/storage.
+ * Removes characters that crash string-width or cause display issues:
+ * - Control characters (except tab, newline, carriage return)
+ * - Lone surrogates
+ * - Unicode Format characters (crash string-width due to a bug)
+ * - Characters with undefined code points
+ */
+export function sanitizeBinaryOutput(str: string): string {
+	// Use Array.from to properly iterate over code points (not code units)
+	// This handles surrogate pairs correctly and catches edge cases where
+	// codePointAt() might return undefined
+	return Array.from(str)
+		.filter((char) => {
+			// Filter out characters that cause string-width to crash
+			// This includes:
+			// - Unicode format characters
+			// - Lone surrogates (already filtered by Array.from)
+			// - Control chars except \t \n \r
+			// - Characters with undefined code points
+
+			const code = char.codePointAt(0);
+
+			// Skip if code point is undefined (edge case with invalid strings)
+			if (code === undefined) return false;
+
+			// Allow tab, newline, carriage return
+			if (code === 0x09 || code === 0x0a || code === 0x0d) return true;
+
+			// Filter out control characters (0x00-0x1F, except 0x09, 0x0a, 0x0x0d)
+			if (code <= 0x1f) return false;
+
+			// Filter out Unicode format characters
+			if (code >= 0xfff9 && code <= 0xfffb) return false;
+
+			return true;
+		})
+		.join("");
+}
+
+/**
+ * Detached child processes must be tracked so they can be killed on parent
+ * shutdown signals (SIGHUP/SIGTERM).
+ */
+const trackedDetachedChildPids = new Set<number>();
+
+export function trackDetachedChildPid(pid: number): void {
+	trackedDetachedChildPids.add(pid);
+}
+
+export function untrackDetachedChildPid(pid: number): void {
+	trackedDetachedChildPids.delete(pid);
+}
+
+export function killTrackedDetachedChildren(): void {
+	for (const pid of trackedDetachedChildPids) {
+		killProcessTree(pid);
+	}
+	trackedDetachedChildPids.clear();
+}
+
+/**
+ * Kill a process and all its children (cross-platform)
+ */
+export function killProcessTree(pid: number): void {
+	if (process.platform === "win32") {
+		// Use taskkill on Windows to kill process tree
+		try {
+			spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+				stdio: "ignore",
+				detached: true,
+				windowsHide: true,
+			});
+		} catch {
+			// Ignore errors if taskkill fails
+		}
+	} else {
+		// Use SIGKILL on Unix/Linux/Mac
+		try {
+			process.kill(-pid, "SIGKILL");
+		} catch {
+			// Fallback to killing just the child if process group kill fails
+			try {
+				process.kill(pid, "SIGKILL");
+			} catch {
+				// Process already dead
+			}
+		}
+	}
+}

package/packages/agent/src/utils/sleep.ts

@@ -0,0 +1,18 @@
+/**
+ * Sleep helper that respects abort signal.
+ */
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new Error("Aborted"));
+			return;
+		}
+
+		const timeout = setTimeout(resolve, ms);
+
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(new Error("Aborted"));
+		});
+	});
+}

package/packages/agent/src/utils/tools-manager.ts

@@ -0,0 +1,63 @@
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { platform } from "os";
+import { join } from "path";
+import { getBinDir } from "../config.ts";
+
+const TOOLS_DIR = getBinDir();
+
+interface ToolConfig {
+	name: string;
+	binaryName: string;
+	systemBinaryNames?: string[];
+	installHint: string;
+}
+
+const TOOLS: Record<"fd" | "rg", ToolConfig> = {
+	fd: {
+		name: "fd",
+		binaryName: "fd",
+		systemBinaryNames: ["fd", "fdfind"],
+		installHint: "brew install fd (macOS) bzw. apt install fd-find (Debian/Ubuntu)",
+	},
+	rg: {
+		name: "ripgrep",
+		binaryName: "rg",
+		installHint: "brew install ripgrep (macOS) bzw. apt install ripgrep (Debian/Ubuntu)",
+	},
+};
+
+function commandExists(cmd: string): boolean {
+	try {
+		const result = spawnSync(cmd, ["--version"], { stdio: "pipe" });
+		return result.error === undefined || result.error === null;
+	} catch {
+		return false;
+	}
+}
+
+export function getToolPath(tool: "fd" | "rg"): string | null {
+	const config = TOOLS[tool];
+	if (!config) return null;
+
+	const localPath = join(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+	if (existsSync(localPath)) {
+		return localPath;
+	}
+
+	const systemBinaryNames = config.systemBinaryNames ?? [config.binaryName];
+	for (const systemBinaryName of systemBinaryNames) {
+		if (commandExists(systemBinaryName)) {
+			return systemBinaryName;
+		}
+	}
+
+	return null;
+}
+
+export function requireToolPath(tool: "fd" | "rg"): string {
+	const resolved = getToolPath(tool);
+	if (resolved) return resolved;
+	const config = TOOLS[tool];
+	throw new Error(`${config.name} ist nicht installiert. Bitte einrichten: ${config.installHint}`);
+}

package/packages/agent-core/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@aicontainer/agent-core",
+	"version": "0.80.10",
+	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
+	"type": "module",
+	"main": "./src/index.ts",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./src/index.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"build": "rm -rf dist && tsc -p tsconfig.build.json",
+		"test": "node --test tests/*.test.ts"
+	},
+	"dependencies": {
+		"@aicontainer/ai": "^0.80.10",
+		"ignore": "7.0.5",
+		"typebox": "1.1.38",
+		"yaml": "2.9.0"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"devDependencies": {
+		"@types/node": "24.12.4",
+		"typescript": "5.9.3"
+	}
+}