@agentuity/runtime 0.0.43 → 0.0.45

package/src/services/local/_db.ts

@@ -0,0 +1,182 @@
+import { Database } from 'bun:sqlite';
+import { mkdirSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+let dbInstance: Database | null = null;
+
+export function getLocalDB(): Database {
+	if (dbInstance) {
+		return dbInstance;
+	}
+
+	const configDir = join(homedir(), '.config', 'agentuity');
+
+	if (!existsSync(configDir)) {
+		mkdirSync(configDir, { recursive: true });
+	}
+
+	const dbPath = join(configDir, 'local.db');
+	dbInstance = new Database(dbPath);
+
+	initializeTables(dbInstance);
+	cleanupOrphanedProjects(dbInstance);
+
+	return dbInstance;
+}
+
+function initializeTables(db: Database): void {
+	// KeyValue Storage table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS kv_storage (
+			project_path TEXT NOT NULL,
+			name TEXT NOT NULL,
+			key TEXT NOT NULL,
+			value BLOB NOT NULL,
+			content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
+			expires_at INTEGER,
+			created_at INTEGER NOT NULL,
+			updated_at INTEGER NOT NULL,
+			PRIMARY KEY (project_path, name, key)
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_kv_expires 
+		ON kv_storage(expires_at) 
+		WHERE expires_at IS NOT NULL
+	`);
+
+	// Object Storage table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS object_storage (
+			project_path TEXT NOT NULL,
+			bucket TEXT NOT NULL,
+			key TEXT NOT NULL,
+			data BLOB NOT NULL,
+			content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
+			content_encoding TEXT,
+			cache_control TEXT,
+			content_disposition TEXT,
+			content_language TEXT,
+			metadata TEXT,
+			created_at INTEGER NOT NULL,
+			updated_at INTEGER NOT NULL,
+			PRIMARY KEY (project_path, bucket, key)
+		)
+	`);
+
+	// Stream Storage table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS stream_storage (
+			project_path TEXT NOT NULL,
+			id TEXT PRIMARY KEY,
+			name TEXT NOT NULL,
+			metadata TEXT,
+			content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
+			data BLOB,
+			size_bytes INTEGER NOT NULL DEFAULT 0,
+			created_at INTEGER NOT NULL
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_stream_name 
+		ON stream_storage(project_path, name)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_stream_metadata 
+		ON stream_storage(metadata)
+	`);
+
+	// Vector Storage table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS vector_storage (
+			project_path TEXT NOT NULL,
+			name TEXT NOT NULL,
+			id TEXT PRIMARY KEY,
+			key TEXT NOT NULL,
+			embedding TEXT NOT NULL,
+			document TEXT,
+			metadata TEXT,
+			created_at INTEGER NOT NULL,
+			updated_at INTEGER NOT NULL,
+			UNIQUE (project_path, name, key)
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_vector_lookup 
+		ON vector_storage(project_path, name, key)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_vector_name 
+		ON vector_storage(project_path, name)
+	`);
+}
+
+function cleanupOrphanedProjects(db: Database): void {
+	// Get the current project path to exclude from cleanup
+	const currentProjectPath = process.cwd();
+
+	// Query all tables for unique project paths
+	const kvPaths = db.query('SELECT DISTINCT project_path FROM kv_storage').all() as Array<{
+		project_path: string;
+	}>;
+	const objectPaths = db.query('SELECT DISTINCT project_path FROM object_storage').all() as Array<{
+		project_path: string;
+	}>;
+	const streamPaths = db.query('SELECT DISTINCT project_path FROM stream_storage').all() as Array<{
+		project_path: string;
+	}>;
+	const vectorPaths = db.query('SELECT DISTINCT project_path FROM vector_storage').all() as Array<{
+		project_path: string;
+	}>;
+
+	// Combine and deduplicate all project paths
+	const allPaths = new Set<string>();
+	[...kvPaths, ...objectPaths, ...streamPaths, ...vectorPaths].forEach((row) => {
+		allPaths.add(row.project_path);
+	});
+
+	// Check which paths no longer exist and are not the current project
+	const pathsToDelete: string[] = [];
+	for (const path of allPaths) {
+		if (path !== currentProjectPath && !existsSync(path)) {
+			pathsToDelete.push(path);
+		}
+	}
+
+	// Delete data for removed projects
+	if (pathsToDelete.length > 0) {
+		const placeholders = pathsToDelete.map(() => '?').join(', ');
+
+		// Delete from all tables
+		const deleteKv = db.prepare(`DELETE FROM kv_storage WHERE project_path IN (${placeholders})`);
+		const deleteObject = db.prepare(
+			`DELETE FROM object_storage WHERE project_path IN (${placeholders})`
+		);
+		const deleteStream = db.prepare(
+			`DELETE FROM stream_storage WHERE project_path IN (${placeholders})`
+		);
+		const deleteVector = db.prepare(
+			`DELETE FROM vector_storage WHERE project_path IN (${placeholders})`
+		);
+
+		deleteKv.run(...pathsToDelete);
+		deleteObject.run(...pathsToDelete);
+		deleteStream.run(...pathsToDelete);
+		deleteVector.run(...pathsToDelete);
+
+		console.log(`[LocalDB] Cleaned up data for ${pathsToDelete.length} orphaned project(s)`);
+	}
+}
+
+export function closeLocalDB(): void {
+	if (dbInstance) {
+		dbInstance.close();
+		dbInstance = null;
+	}
+}

package/src/services/local/_router.ts

@@ -0,0 +1,86 @@
+import type { Database } from 'bun:sqlite';
+import { createRouter } from '../../router';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createLocalStorageRouter(db: Database, projectPath: string): any {
+	const router = createRouter();
+
+	// so we can detect if we're running in local mode easily
+	router.get('/_agentuity/local/health', (c) => c.text('OK'));
+
+	// Serve objects: GET /_agentuity/local/object/:bucket/:key
+	router.get('/_agentuity/local/object/:bucket/:key', async (c) => {
+		const bucket = c.req.param('bucket');
+		const key = c.req.param('key');
+
+		const query = db.query(`
+			SELECT data, content_type, content_encoding, cache_control, 
+						 content_disposition, content_language 
+			FROM object_storage 
+			WHERE project_path = ? AND bucket = ? AND key = ?
+		`);
+
+		const row = query.get(projectPath, bucket, key) as {
+			data: Buffer;
+			content_type: string;
+			content_encoding: string | null;
+			cache_control: string | null;
+			content_disposition: string | null;
+			content_language: string | null;
+		} | null;
+
+		if (!row) {
+			return c.notFound();
+		}
+
+		// Set headers
+		const headers: Record<string, string> = {
+			'Content-Type': row.content_type,
+		};
+
+		if (row.content_encoding) {
+			headers['Content-Encoding'] = row.content_encoding;
+		}
+		if (row.cache_control) {
+			headers['Cache-Control'] = row.cache_control;
+		}
+		if (row.content_disposition) {
+			headers['Content-Disposition'] = row.content_disposition;
+		}
+		if (row.content_language) {
+			headers['Content-Language'] = row.content_language;
+		}
+
+		return c.body(new Uint8Array(row.data), 200, headers);
+	});
+
+	// Serve streams: GET /_agentuity/local/stream/:id
+	router.get('/_agentuity/local/stream/:id', async (c) => {
+		const id = c.req.param('id');
+
+		const query = db.query(`
+			SELECT data, content_type 
+			FROM stream_storage 
+			WHERE project_path = ? AND id = ?
+		`);
+
+		const row = query.get(projectPath, id) as {
+			data: Buffer | null;
+			content_type: string;
+		} | null;
+
+		if (!row) {
+			return c.notFound();
+		}
+
+		if (!row.data) {
+			return c.json({ error: 'Stream not finalized' }, 400);
+		}
+
+		return c.body(new Uint8Array(row.data), 200, {
+			'Content-Type': row.content_type,
+		});
+	});
+
+	return router;
+}

package/src/services/local/_util.ts

@@ -0,0 +1,49 @@
+import { resolve } from 'node:path';
+
+/**
+ * Normalize a project path to an absolute path for consistent DB keys
+ */
+export function normalizeProjectPath(cwd: string = process.cwd()): string {
+	return resolve(cwd);
+}
+
+/**
+ * Simple character-based embedding for local vector search
+ * Not production-quality, but good enough for local dev/testing
+ */
+export function simpleEmbedding(text: string, dimensions = 128): number[] {
+	const vec = new Array(dimensions).fill(0);
+	const normalized = text.toLowerCase();
+
+	for (let i = 0; i < normalized.length; i++) {
+		const charCode = normalized.charCodeAt(i);
+		vec[i % dimensions] += Math.sin(charCode * (i + 1));
+		vec[(i * 2) % dimensions] += Math.cos(charCode);
+	}
+
+	// Normalize vector
+	const magnitude = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
+	return magnitude > 0 ? vec.map((v) => v / magnitude) : vec;
+}
+
+/**
+ * Calculate cosine similarity between two vectors
+ */
+export function cosineSimilarity(a: number[], b: number[]): number {
+	if (a.length !== b.length) {
+		throw new Error('Vectors must have the same dimension');
+	}
+
+	const dot = a.reduce((sum, ai, i) => sum + ai * (b[i] ?? 0), 0);
+	const normA = Math.sqrt(a.reduce((sum, ai) => sum + ai * ai, 0));
+	const normB = Math.sqrt(b.reduce((sum, bi) => sum + bi * bi, 0));
+
+	return normA > 0 && normB > 0 ? dot / (normA * normB) : 0;
+}
+
+/**
+ * Get current timestamp in milliseconds
+ */
+export function now(): number {
+	return Date.now();
+}

package/src/services/local/index.ts

@@ -0,0 +1,7 @@
+export { getLocalDB, closeLocalDB } from './_db';
+export { normalizeProjectPath, simpleEmbedding, cosineSimilarity } from './_util';
+export { createLocalStorageRouter } from './_router';
+export { LocalKeyValueStorage } from './keyvalue';
+export { LocalObjectStorage } from './objectstore';
+export { LocalStreamStorage } from './stream';
+export { LocalVectorStorage } from './vector';

package/src/services/local/keyvalue.ts

@@ -0,0 +1,118 @@
+import type { Database } from 'bun:sqlite';
+import type {
+	KeyValueStorage,
+	DataResult,
+	DataResultNotFound,
+	KeyValueStorageSetParams,
+} from '@agentuity/core';
+import { now } from './_util';
+
+export class LocalKeyValueStorage implements KeyValueStorage {
+	#db: Database;
+	#projectPath: string;
+
+	constructor(db: Database, projectPath: string) {
+		this.#db = db;
+		this.#projectPath = projectPath;
+	}
+
+	async get<T>(name: string, key: string): Promise<DataResult<T>> {
+		const query = this.#db.query(`
+			SELECT value, content_type, expires_at 
+			FROM kv_storage 
+			WHERE project_path = ? AND name = ? AND key = ?
+		`);
+
+		const row = query.get(this.#projectPath, name, key) as {
+			value: Buffer;
+			content_type: string;
+			expires_at: number | null;
+		} | null;
+
+		if (!row) {
+			return { exists: false } as DataResultNotFound;
+		}
+
+		// Check expiration
+		if (row.expires_at && row.expires_at < now()) {
+			// Delete expired row
+			await this.delete(name, key);
+			return { exists: false } as DataResultNotFound;
+		}
+
+		// Deserialize based on content type
+		let data: T;
+		if (row.content_type === 'application/json') {
+			data = JSON.parse(row.value.toString('utf-8'));
+		} else if (row.content_type.startsWith('text/')) {
+			data = row.value.toString('utf-8') as T;
+		} else {
+			data = new Uint8Array(row.value) as T;
+		}
+
+		return {
+			data,
+			contentType: row.content_type,
+			exists: true,
+		};
+	}
+
+	async set<T = unknown>(
+		name: string,
+		key: string,
+		value: T,
+		params?: KeyValueStorageSetParams
+	): Promise<void> {
+		// Validate TTL
+		if (params?.ttl && params.ttl < 60) {
+			throw new Error(`ttl must be at least 60 seconds, got ${params.ttl}`);
+		}
+
+		// Serialize value
+		let buffer: Buffer;
+		let contentType = params?.contentType || 'application/octet-stream';
+
+		if (typeof value === 'string') {
+			buffer = Buffer.from(value, 'utf-8');
+			if (!params?.contentType) {
+				contentType = 'text/plain';
+			}
+		} else if (value instanceof Uint8Array) {
+			buffer = Buffer.from(value);
+		} else if (value instanceof ArrayBuffer) {
+			buffer = Buffer.from(new Uint8Array(value));
+		} else if (typeof value === 'object') {
+			buffer = Buffer.from(JSON.stringify(value), 'utf-8');
+			contentType = 'application/json';
+		} else {
+			buffer = Buffer.from(String(value), 'utf-8');
+		}
+
+		// Calculate expiration
+		const expiresAt = params?.ttl ? now() + params.ttl * 1000 : null;
+		const timestamp = now();
+
+		// UPSERT
+		const stmt = this.#db.prepare(`
+			INSERT INTO kv_storage (project_path, name, key, value, content_type, expires_at, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(project_path, name, key) 
+			DO UPDATE SET 
+				value = excluded.value,
+				content_type = excluded.content_type,
+				expires_at = excluded.expires_at,
+				updated_at = excluded.updated_at
+		`);
+
+		stmt.run(this.#projectPath, name, key, buffer, contentType, expiresAt, timestamp, timestamp);
+	}
+
+	async delete(name: string, key: string): Promise<void> {
+		const stmt = this.#db.prepare(`
+			DELETE FROM kv_storage 
+			WHERE project_path = ? AND name = ? AND key = ?
+		`);
+
+		stmt.run(this.#projectPath, name, key);
+	}
+}

package/src/services/local/objectstore.ts

@@ -0,0 +1,152 @@
+import type { Database } from 'bun:sqlite';
+import type {
+	ObjectStorage,
+	ObjectResult,
+	ObjectResultNotFound,
+	ObjectStorePutParams,
+	CreatePublicURLParams,
+} from '@agentuity/core';
+import { now } from './_util';
+
+export class LocalObjectStorage implements ObjectStorage {
+	#db: Database;
+	#projectPath: string;
+	#serverUrl: string;
+
+	constructor(db: Database, projectPath: string, serverUrl: string) {
+		this.#db = db;
+		this.#projectPath = projectPath;
+		this.#serverUrl = serverUrl;
+	}
+
+	async get(bucket: string, key: string): Promise<ObjectResult> {
+		if (!bucket?.trim() || !key?.trim()) {
+			throw new Error('bucket and key are required');
+		}
+
+		const query = this.#db.query(`
+			SELECT data, content_type 
+			FROM object_storage 
+			WHERE project_path = ? AND bucket = ? AND key = ?
+		`);
+
+		const row = query.get(this.#projectPath, bucket, key) as {
+			data: Buffer;
+			content_type: string;
+		} | null;
+
+		if (!row) {
+			return { exists: false } as ObjectResultNotFound;
+		}
+
+		return {
+			exists: true,
+			data: new Uint8Array(row.data),
+			contentType: row.content_type,
+		};
+	}
+
+	async put(
+		bucket: string,
+		key: string,
+		data: Uint8Array | ArrayBuffer | ReadableStream,
+		params?: ObjectStorePutParams
+	): Promise<void> {
+		if (!bucket?.trim() || !key?.trim()) {
+			throw new Error('bucket and key are required');
+		}
+
+		// Convert data to Buffer
+		let buffer: Buffer;
+		if (data instanceof ReadableStream) {
+			// Read entire stream into buffer
+			const reader = data.getReader();
+			const chunks: Uint8Array[] = [];
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				chunks.push(value);
+			}
+			const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+			buffer = Buffer.concat(
+				chunks.map((c) => Buffer.from(c)),
+				totalLength
+			);
+		} else if (data instanceof ArrayBuffer) {
+			buffer = Buffer.from(data);
+		} else {
+			buffer = Buffer.from(data);
+		}
+
+		const timestamp = now();
+		const metadata = params?.metadata ? JSON.stringify(params.metadata) : null;
+
+		const stmt = this.#db.prepare(`
+			INSERT INTO object_storage (
+				project_path, bucket, key, data, content_type, 
+				content_encoding, cache_control, content_disposition, 
+				content_language, metadata, created_at, updated_at
+			)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(project_path, bucket, key) 
+			DO UPDATE SET 
+				data = excluded.data,
+				content_type = excluded.content_type,
+				content_encoding = excluded.content_encoding,
+				cache_control = excluded.cache_control,
+				content_disposition = excluded.content_disposition,
+				content_language = excluded.content_language,
+				metadata = excluded.metadata,
+				updated_at = excluded.updated_at
+		`);
+
+		stmt.run(
+			this.#projectPath,
+			bucket,
+			key,
+			buffer,
+			params?.contentType || 'application/octet-stream',
+			params?.contentEncoding || null,
+			params?.cacheControl || null,
+			params?.contentDisposition || null,
+			params?.contentLanguage || null,
+			metadata,
+			timestamp,
+			timestamp
+		);
+	}
+
+	async delete(bucket: string, key: string): Promise<boolean> {
+		if (!bucket?.trim() || !key?.trim()) {
+			throw new Error('bucket and key are required');
+		}
+
+		const stmt = this.#db.prepare(`
+			DELETE FROM object_storage 
+			WHERE project_path = ? AND bucket = ? AND key = ?
+		`);
+
+		const result = stmt.run(this.#projectPath, bucket, key);
+		return result.changes > 0;
+	}
+
+	async createPublicURL(
+		bucket: string,
+		key: string,
+		_params?: CreatePublicURLParams
+	): Promise<string> {
+		if (!bucket?.trim() || !key?.trim()) {
+			throw new Error('bucket and key are required');
+		}
+
+		// Verify object exists
+		const result = await this.get(bucket, key);
+		if (!result.exists) {
+			throw new Error('Object not found');
+		}
+
+		// Return local HTTP URL
+		// Note: params.expiresDuration is ignored for local implementation
+		return `${this.#serverUrl}/_agentuity/local/object/${encodeURIComponent(bucket)}/${encodeURIComponent(key)}`;
+	}
+}