@agentuity/runtime 2.0.11 → 3.0.0-alpha.1

package/src/services/local/keyvalue.ts

@@ -1,174 +0,0 @@
-import type { Database } from 'bun:sqlite';
-import type {
-	KeyValueStorage,
-	DataResult,
-	DataResultNotFound,
-	KeyValueStorageSetParams,
-	KeyValueStats,
-	KeyValueItemWithMetadata,
-	CreateNamespaceParams,
-	GetAllStatsParams,
-	KeyValueStatsPaginated,
-} 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') {
-			try {
-				const text = row.value.toString('utf-8');
-				data = JSON.parse(text);
-			} catch {
-				// If JSON parse fails, return the raw buffer as Uint8Array
-				data = new Uint8Array(row.value) as T;
-			}
-		} 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,
-			// Include expiresAt if set (convert from Unix timestamp to ISO string)
-			...(row.expires_at && { expiresAt: new Date(row.expires_at).toISOString() }),
-		};
-	}
-
-	async set<T = unknown>(
-		name: string,
-		key: string,
-		value: T,
-		params?: KeyValueStorageSetParams
-	): Promise<void> {
-		// 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 === 'number' ||
-			typeof value === 'boolean' ||
-			typeof value === 'object'
-		) {
-			// Use JSON for numbers, booleans, and objects to preserve type on round-trip
-			buffer = Buffer.from(JSON.stringify(value), 'utf-8');
-			contentType = 'application/json';
-		} else {
-			// Fallback for other types
-			buffer = Buffer.from(String(value), 'utf-8');
-		}
-
-		// Calculate expiration
-		// TTL handling: null or 0 = no expiration, positive = TTL in seconds
-		// undefined = use default (7 days for consistency with cloud namespace default)
-		let expiresAt: number | null = null;
-		if (params?.ttl === undefined) {
-			// Default to 7 days (matching cloud namespace default behavior)
-			expiresAt = now() + 7 * 24 * 60 * 60 * 1000;
-		} else if (params.ttl !== null && params.ttl > 0) {
-			expiresAt = now() + params.ttl * 1000;
-		}
-		// else: ttl is null or 0, so expiresAt stays null (no expiration)
-		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);
-	}
-
-	async getStats(_name: string): Promise<KeyValueStats> {
-		throw new Error('getStats not implemented for local storage');
-	}
-
-	async getAllStats(
-		_params?: GetAllStatsParams
-	): Promise<Record<string, KeyValueStats> | KeyValueStatsPaginated> {
-		throw new Error('getAllStats not implemented for local storage');
-	}
-
-	async getNamespaces(): Promise<string[]> {
-		throw new Error('getNamespaces not implemented for local storage');
-	}
-
-	async search<T = unknown>(
-		_name: string,
-		_keyword: string
-	): Promise<Record<string, KeyValueItemWithMetadata<T>>> {
-		throw new Error('search not implemented for local storage');
-	}
-
-	async getKeys(_name: string): Promise<string[]> {
-		throw new Error('getKeys not implemented for local storage');
-	}
-
-	async deleteNamespace(_name: string): Promise<void> {
-		throw new Error('deleteNamespace not implemented for local storage');
-	}
-
-	async createNamespace(_name: string, _params?: CreateNamespaceParams): Promise<void> {
-		throw new Error('createNamespace not implemented for local storage');
-	}
-}

package/src/services/local/queue.ts

@@ -1,145 +0,0 @@
-import type { Database } from 'bun:sqlite';
-import type {
-	QueueService,
-	QueuePublishParams,
-	QueuePublishResult,
-	QueueCreateParams,
-	QueueCreateResult,
-} from '@agentuity/core';
-
-export class LocalQueueStorage implements QueueService {
-	#db: Database;
-	#projectPath: string;
-
-	constructor(db: Database, projectPath: string) {
-		this.#db = db;
-		this.#projectPath = projectPath;
-		this.#initializeTable();
-	}
-
-	#initializeTable(): void {
-		this.#db.run(`
-			CREATE TABLE IF NOT EXISTS queue_messages (
-				id TEXT PRIMARY KEY,
-				project_path TEXT NOT NULL,
-				queue_name TEXT NOT NULL,
-				offset INTEGER NOT NULL,
-				payload TEXT NOT NULL,
-				metadata TEXT,
-				partition_key TEXT,
-				idempotency_key TEXT,
-				ttl_seconds INTEGER,
-				expires_at TEXT,
-				state TEXT NOT NULL DEFAULT 'pending',
-				created_at TEXT NOT NULL,
-				published_at TEXT NOT NULL
-			)
-		`);
-
-		this.#db.run(`
-			CREATE INDEX IF NOT EXISTS idx_queue_name 
-			ON queue_messages(project_path, queue_name)
-		`);
-
-		this.#db.run(`
-			CREATE UNIQUE INDEX IF NOT EXISTS idx_queue_idempotency_unique
-			ON queue_messages(project_path, queue_name, idempotency_key)
-			WHERE idempotency_key IS NOT NULL
-		`);
-	}
-
-	async publish(
-		queueName: string,
-		payload: string | object,
-		params?: QueuePublishParams
-	): Promise<QueuePublishResult> {
-		const id = crypto.randomUUID();
-		const timestamp = new Date().toISOString();
-		const payloadStr = typeof payload === 'string' ? payload : JSON.stringify(payload);
-		const metadataStr = params?.metadata ? JSON.stringify(params.metadata) : null;
-		const ttlSeconds = params?.ttl ?? null;
-		const expiresAt = ttlSeconds ? new Date(Date.now() + ttlSeconds * 1000).toISOString() : null;
-
-		const publishInTransaction = this.#db.transaction(() => {
-			if (params?.idempotencyKey) {
-				const existing = this.#db
-					.query(
-						`
-					SELECT id, offset, published_at 
-					FROM queue_messages 
-					WHERE project_path = ? AND queue_name = ? AND idempotency_key = ?
-				`
-					)
-					.get(this.#projectPath, queueName, params.idempotencyKey) as {
-					id: string;
-					offset: number;
-					published_at: string;
-				} | null;
-
-				if (existing) {
-					return {
-						id: existing.id,
-						offset: existing.offset,
-						publishedAt: existing.published_at,
-					};
-				}
-			}
-
-			const offsetResult = this.#db
-				.query(
-					`
-				SELECT COALESCE(MAX(offset), -1) + 1 as next_offset 
-				FROM queue_messages 
-				WHERE project_path = ? AND queue_name = ?
-			`
-				)
-				.get(this.#projectPath, queueName) as { next_offset: number };
-
-			const offset = offsetResult.next_offset;
-
-			this.#db
-				.prepare(
-					`
-				INSERT INTO queue_messages (
-					id, project_path, queue_name, offset, payload, metadata, 
-					partition_key, idempotency_key, ttl_seconds, expires_at, state, created_at, published_at
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)
-			`
-				)
-				.run(
-					id,
-					this.#projectPath,
-					queueName,
-					offset,
-					payloadStr,
-					metadataStr,
-					params?.partitionKey ?? null,
-					params?.idempotencyKey ?? null,
-					ttlSeconds,
-					expiresAt,
-					timestamp,
-					timestamp
-				);
-
-			return {
-				id,
-				offset,
-				publishedAt: timestamp,
-			};
-		});
-
-		return publishInTransaction.immediate();
-	}
-
-	async createQueue(queueName: string, params?: QueueCreateParams): Promise<QueueCreateResult> {
-		console.debug(`[local] createQueue: ${queueName}`);
-		return {
-			name: queueName,
-			queueType: params?.queueType ?? 'worker',
-		};
-	}
-
-	async deleteQueue(_queueName: string): Promise<void> {
-		// No-op in local mode — queues don't need provisioning locally
-	}
-}

package/src/services/local/stream.ts

@@ -1,358 +0,0 @@
-import type { Database } from 'bun:sqlite';
-import type {
-	StreamStorage,
-	Stream,
-	CreateStreamProps,
-	ListStreamsParams,
-	ListStreamsResponse,
-	StreamInfo,
-} from '@agentuity/core';
-import { now } from './_util';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { mkdirSync, existsSync, unlinkSync } from 'node:fs';
-import { openSync, writeSync, closeSync, readFileSync } from 'node:fs';
-
-export class LocalStreamStorage implements StreamStorage {
-	#db: Database;
-	#projectPath: string;
-	#serverUrl: string;
-	#tempDir: string;
-
-	constructor(db: Database, projectPath: string, serverUrl: string) {
-		this.#db = db;
-		this.#projectPath = projectPath;
-		this.#serverUrl = serverUrl;
-
-		// Create temp directory for stream buffering
-		this.#tempDir = join(homedir(), '.config', 'agentuity', 'streams');
-		if (!existsSync(this.#tempDir)) {
-			mkdirSync(this.#tempDir, { recursive: true });
-		}
-	}
-
-	async create(namespace: string, props?: CreateStreamProps): Promise<Stream> {
-		if (!namespace || namespace.length < 1 || namespace.length > 254) {
-			throw new Error('Stream namespace must be between 1 and 254 characters');
-		}
-
-		const id = randomUUID();
-		const timestamp = now();
-		const metadata = props?.metadata ? JSON.stringify(props.metadata) : null;
-
-		// Insert stream record with NULL data
-		const stmt = this.#db.prepare(`
-			INSERT INTO stream_storage (
-				project_path, id, name, metadata, content_type, created_at
-			)
-			VALUES (?, ?, ?, ?, ?, ?)
-		`);
-
-		stmt.run(
-			this.#projectPath,
-			id,
-			namespace,
-			metadata,
-			props?.contentType || 'application/octet-stream',
-			timestamp
-		);
-
-		const url = `${this.#serverUrl}/_agentuity/local/stream/${id}`;
-
-		return new LocalStream(
-			id,
-			url,
-			this.#db,
-			this.#projectPath,
-			this.#tempDir,
-			props?.compress ?? false
-		);
-	}
-
-	async list(params?: ListStreamsParams): Promise<ListStreamsResponse> {
-		if (params?.limit && (params.limit <= 0 || params.limit > 1000)) {
-			throw new Error('limit must be between 1 and 1000');
-		}
-
-		let query = `
-			SELECT id, name, metadata, size_bytes 
-			FROM stream_storage 
-			WHERE project_path = ?
-		`;
-		const queryParams: (string | number)[] = [this.#projectPath];
-
-		// Add filters (map namespace to name for the database)
-		if (params?.namespace) {
-			query += ` AND name = ?`;
-			queryParams.push(params.namespace);
-		}
-
-		if (params?.metadata) {
-			// Simple JSON matching - check if metadata contains all key-value pairs
-			for (const [key, value] of Object.entries(params.metadata)) {
-				query += ` AND metadata LIKE ?`;
-				queryParams.push(`%"${key}":"${value}"%`);
-			}
-		}
-
-		// Get total count
-		const countQuery = this.#db.query(
-			query.replace('SELECT id, name, metadata, size_bytes', 'SELECT COUNT(*) as count')
-		);
-		const { count } = countQuery.get(...queryParams) as { count: number };
-
-		// Add pagination
-		query += ` ORDER BY created_at DESC`;
-		if (params?.limit) {
-			query += ` LIMIT ${params.limit}`;
-		}
-		if (params?.offset) {
-			query += ` OFFSET ${params.offset}`;
-		}
-
-		const stmt = this.#db.query(query);
-		const rows = stmt.all(...queryParams) as Array<{
-			id: string;
-			name: string;
-			metadata: string | null;
-			size_bytes: number;
-		}>;
-
-		// Map name to namespace for the SDK interface
-		const streams: StreamInfo[] = rows.map((row) => ({
-			id: row.id,
-			namespace: row.name,
-			metadata: row.metadata ? JSON.parse(row.metadata) : {},
-			url: `${this.#serverUrl}/_agentuity/local/stream/${row.id}`,
-			sizeBytes: row.size_bytes,
-			expiresAt: null,
-		}));
-
-		return {
-			success: true,
-			streams,
-			total: count,
-		};
-	}
-
-	async get(id: string): Promise<StreamInfo> {
-		if (!id?.trim()) {
-			throw new Error('Stream id is required');
-		}
-
-		const stmt = this.#db.query<
-			{ id: string; name: string; metadata: string | null; size_bytes: number },
-			[string, string]
-		>(`
-			SELECT id, name, metadata, size_bytes
-			FROM stream_storage
-			WHERE project_path = ? AND id = ?
-		`);
-
-		const row = stmt.get(this.#projectPath, id);
-
-		if (!row) {
-			throw new Error(`Stream not found: ${id}`);
-		}
-
-		const metadata = row.metadata ? JSON.parse(row.metadata) : {};
-		const url = `${this.#serverUrl}/_agentuity/local/stream/${id}`;
-
-		// Map name to namespace for the SDK interface
-		return {
-			id: row.id,
-			namespace: row.name,
-			metadata,
-			url,
-			sizeBytes: row.size_bytes,
-			expiresAt: null,
-		};
-	}
-
-	async download(id: string): Promise<ReadableStream<Uint8Array>> {
-		if (!id?.trim()) {
-			throw new Error('Stream id is required');
-		}
-
-		const stmt = this.#db.query<{ data: Buffer | null }, [string, string]>(`
-			SELECT data FROM stream_storage
-			WHERE project_path = ? AND id = ?
-		`);
-
-		const row = stmt.get(this.#projectPath, id);
-
-		if (!row || !row.data) {
-			throw new Error(`Stream not found or empty: ${id}`);
-		}
-
-		// Convert Buffer to ReadableStream
-		const buffer = row.data;
-		return new ReadableStream({
-			start(controller) {
-				controller.enqueue(new Uint8Array(buffer));
-				controller.close();
-			},
-		});
-	}
-
-	async delete(id: string): Promise<void> {
-		if (!id?.trim()) {
-			throw new Error('Stream id is required');
-		}
-
-		const stmt = this.#db.prepare(`
-			DELETE FROM stream_storage 
-			WHERE project_path = ? AND id = ?
-		`);
-
-		stmt.run(this.#projectPath, id);
-	}
-}
-
-class LocalStream extends WritableStream implements Stream {
-	public readonly id: string;
-	public readonly url: string;
-
-	#db: Database;
-	#projectPath: string;
-	#compressed: boolean;
-	#tempFilePath: string;
-	#fileHandle: number | null = null;
-	#bytesWritten = 0;
-	#closed = false;
-
-	constructor(
-		id: string,
-		url: string,
-		db: Database,
-		projectPath: string,
-		tempDir: string,
-		compressed: boolean
-	) {
-		super({
-			write: async (chunk: Uint8Array) => {
-				await this.#writeToFile(chunk);
-			},
-			close: async () => {
-				await this.#persist();
-			},
-		});
-
-		this.id = id;
-		this.url = url;
-		this.#db = db;
-		this.#projectPath = projectPath;
-		this.#compressed = compressed;
-		this.#tempFilePath = join(tempDir, `${id}.tmp`);
-
-		// Open file for writing
-		this.#fileHandle = openSync(this.#tempFilePath, 'w');
-	}
-
-	get bytesWritten(): number {
-		return this.#bytesWritten;
-	}
-
-	get compressed(): boolean {
-		return this.#compressed;
-	}
-
-	async write(chunk: string | Uint8Array | ArrayBuffer | Buffer | object): Promise<void> {
-		if (this.#closed) {
-			throw new Error('Stream is closed');
-		}
-
-		let binary: Uint8Array;
-		if (chunk instanceof Uint8Array) {
-			binary = chunk;
-		} else if (typeof chunk === 'string') {
-			binary = new TextEncoder().encode(chunk);
-		} else if (chunk instanceof ArrayBuffer) {
-			binary = new Uint8Array(chunk);
-		} else if (typeof chunk === 'object') {
-			binary = new TextEncoder().encode(JSON.stringify(chunk));
-		} else {
-			binary = new TextEncoder().encode(String(chunk));
-		}
-
-		await this.#writeToFile(binary);
-	}
-
-	override async close(): Promise<void> {
-		if (this.#closed) {
-			return;
-		}
-
-		this.#closed = true;
-
-		// Close file handle if open
-		if (this.#fileHandle !== null) {
-			closeSync(this.#fileHandle);
-			this.#fileHandle = null;
-		}
-
-		await this.#persist();
-	}
-
-	getReader(): ReadableStream<Uint8Array> {
-		const db = this.#db;
-		const projectPath = this.#projectPath;
-		const id = this.id;
-
-		return new ReadableStream({
-			start(controller) {
-				const query = db.query(`
-					SELECT data FROM stream_storage 
-					WHERE project_path = ? AND id = ?
-				`);
-
-				const row = query.get(projectPath, id) as { data: Buffer | null } | null;
-
-				if (!row || !row.data) {
-					controller.error(new Error('Stream not found or not finalized'));
-					return;
-				}
-
-				controller.enqueue(new Uint8Array(row.data));
-				controller.close();
-			},
-		});
-	}
-
-	async #writeToFile(chunk: Uint8Array): Promise<void> {
-		if (this.#fileHandle === null) {
-			throw new Error('File handle is closed');
-		}
-
-		const written = writeSync(this.#fileHandle, chunk);
-		this.#bytesWritten += written;
-	}
-
-	async #persist(): Promise<void> {
-		// Read buffered file
-		let data: Buffer = readFileSync(this.#tempFilePath);
-
-		// Optional: Apply compression if enabled
-		if (this.#compressed) {
-			const { gzipSync } = await import('node:zlib');
-			data = gzipSync(data) as Buffer;
-		}
-
-		// Update DB with finalized data
-		const stmt = this.#db.prepare(`
-			UPDATE stream_storage 
-			SET data = ?, size_bytes = ? 
-			WHERE project_path = ? AND id = ?
-		`);
-
-		stmt.run(data, this.#bytesWritten, this.#projectPath, this.id);
-
-		// Clean up temp file
-		try {
-			unlinkSync(this.#tempFilePath);
-		} catch {
-			// Ignore cleanup errors
-		}
-	}
-}