@schlenkr/ragents 0.1.4 → 0.1.6

package/packages/agent/src/config.ts

@@ -1,161 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { normalizePath } from "./utils/paths.ts";
-
-// =============================================================================
-// Package Detection
-// =============================================================================
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-/**
- * Detect if we're running as a Bun compiled binary.
- * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
- */
-export const isBunBinary =
-	import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
-
-// =============================================================================
-// Package Asset Paths (shipped with executable)
-// =============================================================================
-
-/**
- * Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
- * - For Bun binary: returns the directory containing the executable
- * - For Node.js (dist/): returns __dirname (the dist/ directory)
- * - For tsx (src/): returns parent directory (the package root)
- */
-export function getPackageDir(): string {
-	// Allow override via environment variable (useful for Nix/Guix where store paths tokenize poorly)
-	const envDir = process.env.AGENT_PACKAGE_DIR;
-	if (envDir) {
-		return normalizePath(envDir);
-	}
-
-	if (isBunBinary) {
-		// Bun binary: process.execPath points to the compiled executable
-		return dirname(process.execPath);
-	}
-	// Node.js: walk up from __dirname until we find package.json
-	let dir = __dirname;
-	while (dir !== dirname(dir)) {
-		if (existsSync(join(dir, "package.json"))) {
-			return dir;
-		}
-		dir = dirname(dir);
-	}
-	// Fallback (shouldn't happen)
-	return __dirname;
-}
-
-/**
- * Get path to HTML export template directory (shipped with package)
- * - For Bun binary: export-html/ next to executable
- * - For Node.js (dist/): dist/core/export-html/
- * - For tsx (src/): src/core/export-html/
- */
-export function getExportTemplateDir(): string {
-	if (isBunBinary) {
-		return join(getPackageDir(), "export-html");
-	}
-	const packageDir = getPackageDir();
-	const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
-	return join(packageDir, srcOrDist, "core", "export-html");
-}
-
-/** Get path to package.json */
-export function getPackageJsonPath(): string {
-	return join(getPackageDir(), "package.json");
-}
-
-// =============================================================================
-// App Config (aus package.json agentConfig)
-// =============================================================================
-
-interface PackageJson {
-	name?: string;
-	version?: string;
-	agentConfig?: {
-		name?: string;
-		configDir?: string;
-	};
-}
-
-let pkg: PackageJson = {};
-try {
-	pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8")) as PackageJson;
-} catch (e: unknown) {
-	const err = e as NodeJS.ErrnoException;
-	if (err.code !== "ENOENT") throw e;
-}
-
-const agentConfigName: string | undefined = pkg.agentConfig?.name;
-export const PACKAGE_NAME: string = pkg.name || "@aicontainer/agent";
-export const APP_NAME: string = agentConfigName || "agent";
-export const APP_TITLE: string = APP_NAME;
-export const CONFIG_DIR_NAME: string = pkg.agentConfig?.configDir || ".agent";
-export const VERSION: string = pkg.version || "0.0.0";
-
-// e.g., AGENT_CODING_AGENT_DIR or TAU_CODING_AGENT_DIR
-export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
-export const ENV_SESSION_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_SESSION_DIR`;
-
-export function expandTildePath(path: string): string {
-	return normalizePath(path);
-}
-
-// =============================================================================
-// User Config Paths (~/.agent/*)
-// =============================================================================
-
-/** Get the agent config directory (e.g., ~/.agent/) */
-export function getAgentDir(): string {
-	const envDir = process.env[ENV_AGENT_DIR];
-	if (envDir) {
-		return expandTildePath(envDir);
-	}
-	return join(homedir(), CONFIG_DIR_NAME, "agent");
-}
-
-/** Get path to models.json */
-export function getModelsPath(): string {
-	return join(getAgentDir(), "models.json");
-}
-
-/** Get path to auth.json */
-export function getAuthPath(): string {
-	return join(getAgentDir(), "auth.json");
-}
-
-/** Get path to settings.json */
-export function getSettingsPath(): string {
-	return join(getAgentDir(), "settings.json");
-}
-
-/** Get path to tools directory */
-export function getToolsDir(): string {
-	return join(getAgentDir(), "tools");
-}
-
-/** Get path to managed binaries directory (fd, rg) */
-export function getBinDir(): string {
-	return join(getAgentDir(), "bin");
-}
-
-/** Get path to prompt templates directory */
-export function getPromptsDir(): string {
-	return join(getAgentDir(), "prompts");
-}
-
-/** Get path to sessions directory */
-export function getSessionsDir(): string {
-	return join(getAgentDir(), "sessions");
-}
-
-/** Get path to debug log file */
-export function getDebugLogPath(): string {
-	return join(getAgentDir(), `${APP_NAME}-debug.log`);
-}

package/packages/agent/src/core/auth-storage.ts

@@ -1,271 +0,0 @@
-/**
- * CredentialStore implementation backed by auth.json.
- * Provider auth orchestration belongs to ModelRuntime and Models.
- */
-
-import type { Credential, CredentialInfo, CredentialStore } from "@aicontainer/ai";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
-import lockfile from "proper-lockfile";
-import { getAgentDir } from "../config.ts";
-import { normalizePath } from "../utils/paths.ts";
-import { resolveConfigValue } from "./resolve-config-value.ts";
-
-type AuthStorageData = Record<string, Credential>;
-
-type LockResult<T> = {
-	result: T;
-	next?: string;
-};
-
-const AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 0o600 } as const;
-
-export interface AuthStorageBackend {
-	withLock<T>(fn: (current: string | undefined) => LockResult<T>): T;
-	withLockAsync<T>(fn: (current: string | undefined) => Promise<LockResult<T>>): Promise<T>;
-}
-
-export class FileAuthStorageBackend implements AuthStorageBackend {
-	private authPath: string;
-
-	constructor(authPath: string = join(getAgentDir(), "auth.json")) {
-		this.authPath = normalizePath(authPath);
-	}
-
-	private ensureParentDir(): void {
-		const dir = dirname(this.authPath);
-		if (!existsSync(dir)) {
-			mkdirSync(dir, { recursive: true, mode: 0o700 });
-		}
-	}
-
-	private ensureFileExists(): void {
-		if (!existsSync(this.authPath)) {
-			writeFileSync(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS);
-			chmodSync(this.authPath, 0o600);
-		}
-	}
-
-	private acquireLockSyncWithRetry(path: string): () => void {
-		const maxAttempts = 10;
-		const delayMs = 20;
-		let lastError: unknown;
-
-		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-			try {
-				return lockfile.lockSync(path, { realpath: false });
-			} catch (error) {
-				const code =
-					typeof error === "object" && error !== null && "code" in error
-						? String((error as { code?: unknown }).code)
-						: undefined;
-				if (code !== "ELOCKED" || attempt === maxAttempts) {
-					throw error;
-				}
-				lastError = error;
-				const start = Date.now();
-				while (Date.now() - start < delayMs) {
-					// Sleep synchronously to avoid changing callers to async.
-				}
-			}
-		}
-
-		throw (lastError as Error) ?? new Error("Failed to acquire auth storage lock");
-	}
-
-	withLock<T>(fn: (current: string | undefined) => LockResult<T>): T {
-		this.ensureParentDir();
-		this.ensureFileExists();
-
-		let release: (() => void) | undefined;
-		try {
-			release = this.acquireLockSyncWithRetry(this.authPath);
-			const current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : undefined;
-			const { result, next } = fn(current);
-			if (next !== undefined) {
-				writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
-				chmodSync(this.authPath, 0o600);
-			}
-			return result;
-		} finally {
-			if (release) {
-				release();
-			}
-		}
-	}
-
-	async withLockAsync<T>(fn: (current: string | undefined) => Promise<LockResult<T>>): Promise<T> {
-		this.ensureParentDir();
-		this.ensureFileExists();
-
-		let release: (() => Promise<void>) | undefined;
-		let lockCompromised = false;
-		let lockCompromisedError: Error | undefined;
-		const throwIfCompromised = () => {
-			if (lockCompromised) {
-				throw lockCompromisedError ?? new Error("Auth storage lock was compromised");
-			}
-		};
-
-		try {
-			release = await lockfile.lock(this.authPath, {
-				retries: {
-					retries: 10,
-					factor: 2,
-					minTimeout: 100,
-					maxTimeout: 10000,
-					randomize: true,
-				},
-				stale: 30000,
-				onCompromised: (err) => {
-					lockCompromised = true;
-					lockCompromisedError = err;
-				},
-			});
-
-			throwIfCompromised();
-			const current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : undefined;
-			const { result, next } = await fn(current);
-			throwIfCompromised();
-			if (next !== undefined) {
-				writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
-				chmodSync(this.authPath, 0o600);
-			}
-			throwIfCompromised();
-			return result;
-		} finally {
-			if (release) {
-				try {
-					await release();
-				} catch {
-					// Ignore unlock errors when lock is compromised.
-				}
-			}
-		}
-	}
-}
-
-export class InMemoryAuthStorageBackend implements AuthStorageBackend {
-	private value: string | undefined;
-
-	withLock<T>(fn: (current: string | undefined) => LockResult<T>): T {
-		const { result, next } = fn(this.value);
-		if (next !== undefined) {
-			this.value = next;
-		}
-		return result;
-	}
-
-	async withLockAsync<T>(fn: (current: string | undefined) => Promise<LockResult<T>>): Promise<T> {
-		const { result, next } = await fn(this.value);
-		if (next !== undefined) {
-			this.value = next;
-		}
-		return result;
-	}
-}
-
-/**
- * Credential storage backed by a JSON file.
- */
-export class AuthStorage implements CredentialStore {
-	private data: AuthStorageData = {};
-	private storage: AuthStorageBackend;
-
-	private constructor(storage: AuthStorageBackend) {
-		this.storage = storage;
-		this.reload();
-	}
-
-	static create(authPath?: string): AuthStorage {
-		return new AuthStorage(new FileAuthStorageBackend(authPath ?? join(getAgentDir(), "auth.json")));
-	}
-
-	static fromStorage(storage: AuthStorageBackend): AuthStorage {
-		return new AuthStorage(storage);
-	}
-
-	static inMemory(data: AuthStorageData = {}): AuthStorage {
-		const storage = new InMemoryAuthStorageBackend();
-		storage.withLock(() => ({ result: undefined, next: JSON.stringify(data, null, 2) }));
-		return AuthStorage.fromStorage(storage);
-	}
-
-	private parseStorageData(content: string | undefined): AuthStorageData {
-		if (!content) {
-			return {};
-		}
-		return JSON.parse(content) as AuthStorageData;
-	}
-
-	/**
-	 * Reload credentials from storage.
-	 */
-	reload(): void {
-		let content: string | undefined;
-		try {
-			this.storage.withLock((current) => {
-				content = current;
-				return { result: undefined };
-			});
-			this.data = this.parseStorageData(content);
-		} catch {
-			// Preserve the last valid in-memory snapshot.
-		}
-	}
-
-	async read(provider: string): Promise<Credential | undefined> {
-		const credential = this.data[provider];
-		if (credential?.type !== "api_key") return credential;
-		if (credential.key === undefined) return credential;
-		return { ...credential, key: resolveConfigValue(credential.key, credential.env) };
-	}
-
-	async modify(
-		provider: string,
-		fn: (current: Credential | undefined) => Promise<Credential | undefined>,
-	): Promise<Credential | undefined> {
-		return this.storage.withLockAsync(async (content) => {
-			const currentData = this.parseStorageData(content);
-			const next = await fn(currentData[provider]);
-			if (next === undefined) {
-				this.data = currentData;
-				return { result: currentData[provider] };
-			}
-
-			const merged: AuthStorageData = { ...currentData, [provider]: next };
-			this.data = merged;
-			return { result: next, next: JSON.stringify(merged, null, 2) };
-		});
-	}
-
-	async delete(provider: string): Promise<void> {
-		await this.storage.withLockAsync(async (content) => {
-			const currentData = this.parseStorageData(content);
-			delete currentData[provider];
-			this.data = currentData;
-			return { result: undefined, next: JSON.stringify(currentData, null, 2) };
-		});
-	}
-
-	/** List credential metadata without resolving configured key values. */
-	async list(): Promise<readonly CredentialInfo[]> {
-		return Object.entries(this.data).map(([providerId, credential]) => ({ providerId, type: credential.type }));
-	}
-}
-
-/**
- * One-off synchronous read of a stored credential from an auth.json file,
- * without instantiating a store or resolving configured key values.
- */
-export function readStoredCredential(
-	providerId: string,
-	authPath: string = join(getAgentDir(), "auth.json"),
-): Credential | undefined {
-	try {
-		const data = JSON.parse(readFileSync(normalizePath(authPath), "utf-8")) as AuthStorageData;
-		return data[providerId];
-	} catch {
-		return undefined;
-	}
-}

package/packages/agent/src/core/bash-executor.ts

@@ -1,156 +0,0 @@
-/**
- * Bash command execution with streaming support and cancellation.
- *
- * This module provides a unified bash execution implementation used by:
- * - AgentSession.executeBash() for interactive and RPC modes
- * - Direct calls from modes that need bash execution
- */
-
-import { randomBytes } from "node:crypto";
-import { createWriteStream, type WriteStream } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { stripAnsi } from "../utils/ansi.ts";
-import { sanitizeBinaryOutput } from "../utils/shell.ts";
-import type { BashOperations } from "./tools/bash.ts";
-import { DEFAULT_MAX_BYTES, truncateTail } from "./tools/truncate.ts";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface BashExecutorOptions {
-	/** Callback for streaming output chunks (already sanitized) */
-	onChunk?: (chunk: string) => void;
-	/** AbortSignal for cancellation */
-	signal?: AbortSignal;
-}
-
-export interface BashResult {
-	/** Combined stdout + stderr output (sanitized, possibly truncated) */
-	output: string;
-	/** Process exit code (undefined if killed/cancelled) */
-	exitCode: number | undefined;
-	/** Whether the command was cancelled via signal */
-	cancelled: boolean;
-	/** Whether the output was truncated */
-	truncated: boolean;
-	/** Path to temp file containing full output (if output exceeded truncation threshold) */
-	fullOutputPath?: string;
-}
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-/**
- * Execute a bash command using custom BashOperations.
- * Used for remote execution (SSH, containers, etc.).
- */
-export async function executeBashWithOperations(
-	command: string,
-	cwd: string,
-	operations: BashOperations,
-	options?: BashExecutorOptions,
-): Promise<BashResult> {
-	const outputChunks: string[] = [];
-	let outputBytes = 0;
-	const maxOutputBytes = DEFAULT_MAX_BYTES * 2;
-
-	let tempFilePath: string | undefined;
-	let tempFileStream: WriteStream | undefined;
-	let totalBytes = 0;
-
-	const ensureTempFile = () => {
-		if (tempFilePath) {
-			return;
-		}
-		const id = randomBytes(8).toString("hex");
-		tempFilePath = join(tmpdir(), `agent-bash-${id}.log`);
-		tempFileStream = createWriteStream(tempFilePath);
-		for (const chunk of outputChunks) {
-			tempFileStream.write(chunk);
-		}
-	};
-
-	const decoder = new TextDecoder();
-
-	const onData = (data: Buffer) => {
-		totalBytes += data.length;
-
-		// Sanitize: strip ANSI, replace binary garbage, normalize newlines
-		const text = sanitizeBinaryOutput(stripAnsi(decoder.decode(data, { stream: true }))).replace(/\r/g, "");
-
-		// Start writing to temp file if exceeds threshold
-		if (totalBytes > DEFAULT_MAX_BYTES) {
-			ensureTempFile();
-		}
-
-		if (tempFileStream) {
-			tempFileStream.write(text);
-		}
-
-		// Keep rolling buffer
-		outputChunks.push(text);
-		outputBytes += text.length;
-		while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
-			const removed = outputChunks.shift()!;
-			outputBytes -= removed.length;
-		}
-
-		// Stream to callback
-		if (options?.onChunk) {
-			options.onChunk(text);
-		}
-	};
-
-	try {
-		const result = await operations.exec(command, cwd, {
-			onData,
-			signal: options?.signal,
-		});
-
-		const fullOutput = outputChunks.join("");
-		const truncationResult = truncateTail(fullOutput);
-		if (truncationResult.truncated) {
-			ensureTempFile();
-		}
-		if (tempFileStream) {
-			tempFileStream.end();
-		}
-		const cancelled = options?.signal?.aborted ?? false;
-
-		return {
-			output: truncationResult.truncated ? truncationResult.content : fullOutput,
-			exitCode: cancelled ? undefined : (result.exitCode ?? undefined),
-			cancelled,
-			truncated: truncationResult.truncated,
-			fullOutputPath: tempFilePath,
-		};
-	} catch (err) {
-		// Check if it was an abort
-		if (options?.signal?.aborted) {
-			const fullOutput = outputChunks.join("");
-			const truncationResult = truncateTail(fullOutput);
-			if (truncationResult.truncated) {
-				ensureTempFile();
-			}
-			if (tempFileStream) {
-				tempFileStream.end();
-			}
-			return {
-				output: truncationResult.truncated ? truncationResult.content : fullOutput,
-				exitCode: undefined,
-				cancelled: true,
-				truncated: truncationResult.truncated,
-				fullOutputPath: tempFilePath,
-			};
-		}
-
-		if (tempFileStream) {
-			tempFileStream.end();
-		}
-
-		throw err;
-	}
-}