@roj-ai/kompjutr-platform 0.0.0 → 0.2.10

package/src/process.ts

@@ -0,0 +1,28 @@
+/**
+ * `ProcessRunner` for a host with no process table.
+ *
+ * The port is required, because every host the SDK knew until now had one. A
+ * kompjutr workspace does not: it is a filesystem and a git runtime, and the
+ * command lines an agent writes are answered by `platform.shell` instead.
+ *
+ * So both methods fail, and they fail loudly rather than pretending. A caller
+ * that needs a real process is a caller this host cannot serve, and the plugin
+ * profile is what keeps those callers out — not a stub that returns nothing.
+ */
+
+import type { ChildProcess, ExecFileResult, ProcessRunner } from '@roj-ai/sdk/platform'
+
+function unsupported(what: string): Error {
+	return Object.assign(new Error(`${what} is not available: this host has no process table`), { code: 'ENOSYS' })
+}
+
+export function createUnsupportedProcessRunner(): ProcessRunner {
+	return {
+		execFile(file: string): Promise<ExecFileResult> {
+			return Promise.reject(unsupported(`execFile(${file})`))
+		},
+		spawn(command: string): ChildProcess {
+			throw unsupported(`spawn(${command})`)
+		},
+	}
+}

package/src/session-log.ts

@@ -0,0 +1,79 @@
+/**
+ * `session.log` as rows rather than a file in the workspace.
+ *
+ * The workspace filesystem is itself SQLite, so appending a log line means
+ * reading the file's length and writing a range through it, where a bound
+ * INSERT is one statement. The session log is the great majority of the write
+ * operations a turn makes, so the file shape is what a turn spends its I/O on.
+ *
+ * Clustered on `(session_id, seq)` `WITHOUT ROWID`: one session's lines are
+ * contiguous and a tail read is a seek down the key rather than a scan.
+ */
+
+import type { SessionLogPage, SessionLogStore } from '@roj-ai/sdk/platform'
+import type { SqlDatabase } from '@kompjutr/do'
+
+const LOG_TABLE = 'roj_session_log'
+
+export class KompjutrSessionLog implements SessionLogStore {
+	/** Next seq per session, so an append does not re-derive MAX(seq) per line. */
+	readonly #nextSeq = new Map<string, number>()
+
+	constructor(private readonly db: SqlDatabase) {
+		this.db.run(
+			`CREATE TABLE IF NOT EXISTS ${LOG_TABLE} (
+				session_id TEXT NOT NULL,
+				seq INTEGER NOT NULL,
+				line TEXT NOT NULL,
+				PRIMARY KEY (session_id, seq)
+			) WITHOUT ROWID`,
+		)
+	}
+
+	append(sessionId: string, line: string): void {
+		try {
+			const seq = this.#claimSeq(sessionId)
+			this.db.run(`INSERT INTO ${LOG_TABLE} (session_id, seq, line) VALUES (?, ?, ?)`, sessionId, seq, line)
+		} catch {
+			// A dropped line must never fail the caller — nothing awaits logging, and
+			// the file logger swallows a failed append for the same reason. The cached
+			// seq goes with it: if this collided, keeping it would collide forever.
+			this.#nextSeq.delete(sessionId)
+		}
+	}
+
+	async read(sessionId: string, since: number): Promise<SessionLogPage> {
+		const rows = this.db.all<{ seq: number; line: string }>(
+			`SELECT seq, line FROM ${LOG_TABLE} WHERE session_id = ? AND seq > ? ORDER BY seq`,
+			sessionId,
+			since,
+		)
+
+		const last = rows[rows.length - 1]
+		if (last !== undefined) return { lines: rows.map((row) => row.line), offset: last.seq }
+
+		// Nothing after `since`: report the tail, so a cursor left past the end — a
+		// reaped session, a fresh table — rewinds instead of sticking there.
+		return { lines: [], offset: Math.min(since, this.#maxSeq(sessionId)) }
+	}
+
+	async delete(sessionId: string): Promise<number> {
+		const lines = this.db.scalar<number>(`SELECT COUNT(*) FROM ${LOG_TABLE} WHERE session_id = ?`, sessionId) ?? 0
+		this.db.run(`DELETE FROM ${LOG_TABLE} WHERE session_id = ?`, sessionId)
+		// Per-session state; a deleted session must not keep a seq to continue from.
+		this.#nextSeq.delete(sessionId)
+		return lines
+	}
+
+	/** 1-based, so the default `since: 0` includes the very first line. */
+	#claimSeq(sessionId: string): number {
+		const seq = this.#nextSeq.get(sessionId) ?? this.#maxSeq(sessionId) + 1
+		this.#nextSeq.set(sessionId, seq + 1)
+		return seq
+	}
+
+	/** Last stored seq, 0 when the session has none. */
+	#maxSeq(sessionId: string): number {
+		return this.db.scalar<number | null>(`SELECT MAX(seq) FROM ${LOG_TABLE} WHERE session_id = ?`, sessionId) ?? 0
+	}
+}

package/src/shell.ts

@@ -0,0 +1,49 @@
+import type { ShellRunner } from '@roj-ai/sdk/platform'
+import type { Filesystem, Git } from '@kompjutr/do'
+import { createGitCommand } from '@kompjutr/do/git-shell'
+import { createShell } from '@kompjutr/do/shell'
+
+export interface KompjutrShellRunnerOptions {
+	filesystem: Filesystem
+	/** Adds the `git` command when the workspace was configured with Git. */
+	git?: Git
+	/** `host` is valid only when this workspace contains one session's files. */
+	confinement?: 'host' | 'none'
+}
+
+function quoteShellWord(value: string): string {
+	return `'${value.replaceAll("'", "'\\''")}'`
+}
+
+export function createKompjutrShellRunner(options: KompjutrShellRunnerOptions): ShellRunner {
+	const commands = options.git === undefined ? undefined : new Map([['git', createGitCommand(options.git)]])
+
+	return {
+		confinement: options.confinement ?? 'none',
+		supportsTimeout: false,
+		async run(runOptions) {
+			if (!runOptions.cwd.startsWith('/')) throw new Error('kompjutr shell requires an absolute cwd')
+			if ((runOptions.grants?.length ?? 0) > 0) {
+				throw new Error('kompjutr shell does not support path grants')
+			}
+
+			// ShellSession caches cwd per instance, even though instances share the default SQL row.
+			const shell = createShell({ fs: options.filesystem, commands })
+			const cwdResult = await shell.run(`cd ${quoteShellWord(runOptions.cwd)}`)
+			const result =
+				cwdResult.exitCode === 0
+					? await shell.run(runOptions.command, {
+							env: runOptions.env,
+							stdin: runOptions.stdin,
+						})
+					: cwdResult
+			return {
+				stdout: result.stdout,
+				stderr: result.stderr,
+				exitCode: result.exitCode,
+				timedOut: false,
+				truncated: result.truncated,
+			}
+		},
+	}
+}

package/src/testing/index.ts

@@ -0,0 +1 @@
+export { BunSqliteStorage, MAX_BIND_PARAMETERS } from './storage.js'

package/src/testing/storage.ts

@@ -0,0 +1,141 @@
+/**
+ * `bun:sqlite` standing in for Durable Object SQL storage, so the adapter can
+ * be driven by `bun test` without a Worker runtime.
+ *
+ * It is deliberately *stricter* than its backing engine on one point. A Durable
+ * Object binds at most 100 parameters per statement; bun:sqlite binds far more,
+ * and an earlier attempt at this port shipped a batch insert that passed every
+ * test and failed in production for exactly that reason. A fake that is more
+ * permissive than the thing it stands for hides the bugs worth catching, so the
+ * limit is enforced here rather than discovered on a deploy.
+ */
+
+import { Database as BunDatabase, type SQLQueryBindings } from 'bun:sqlite'
+import type { DurableObjectStorageLike, SQLCursorLike, SQLStorageLike } from '@kompjutr/do'
+
+/** What a Durable Object binds per statement. The 101st raises, as workerd does. */
+export const MAX_BIND_PARAMETERS = 100
+
+/** SQLite takes bytes, numbers, strings and null; everything else is converted or refused. */
+function toBinding(value: unknown): SQLQueryBindings {
+	if (value === undefined || value === null) return null
+	if (typeof value === 'boolean') return value ? 1 : 0
+	if (value instanceof ArrayBuffer) return new Uint8Array(value)
+	if (ArrayBuffer.isView(value) && !(value instanceof Uint8Array)) {
+		return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+	}
+	if (typeof value === 'number' || typeof value === 'bigint' || typeof value === 'string' || value instanceof Uint8Array) {
+		return value
+	}
+	throw new TypeError(`unsupported SQLite binding: ${typeof value}`)
+}
+
+/**
+ * Rows arrive lazily, because `Filesystem.scan` pages a range scan and a cursor
+ * that materialised would turn every page into the whole table.
+ *
+ * One step is taken up front all the same: a statement nobody iterates is a
+ * statement bun:sqlite never runs, and a `CREATE TABLE` has no rows to pull.
+ */
+class Cursor<Row extends object> implements SQLCursorLike<Row>, IterableIterator<Row> {
+	#rows: Iterator<Row>
+	#prefetched: IteratorResult<Row> | null
+	#done = false
+
+	constructor(
+		rows: Iterator<Row>,
+		private readonly onRow: () => void,
+	) {
+		this.#rows = rows
+		this.#prefetched = this.#pull()
+	}
+
+	#pull(): IteratorResult<Row> {
+		const step = this.#rows.next()
+		if (step.done === true) this.#done = true
+		else this.onRow()
+		return step
+	}
+
+	next(): IteratorResult<Row> {
+		if (this.#prefetched !== null) {
+			const first = this.#prefetched
+			this.#prefetched = null
+			return first
+		}
+		if (this.#done) return { done: true, value: undefined }
+		return this.#pull()
+	}
+
+	return(): IteratorResult<Row> {
+		if (!this.#done) {
+			this.#rows.return?.()
+			this.#done = true
+		}
+		this.#prefetched = null
+		return { done: true, value: undefined }
+	}
+
+	[Symbol.iterator](): IterableIterator<Row> {
+		return this
+	}
+
+	toArray(): Row[] {
+		return Array.from(this)
+	}
+}
+
+export class BunSqliteStorage implements DurableObjectStorageLike {
+	readonly db: BunDatabase
+	readonly sql: SQLStorageLike
+
+	/** Statements executed since the last reset — what a cost test asserts on. */
+	statementCount = 0
+	/** Rows the caller actually pulled. Approximate: a cursor abandoned early stops counting. */
+	rowCount = 0
+
+	#depth = 0
+
+	constructor(path = ':memory:') {
+		this.db = new BunDatabase(path, { create: true })
+		this.db.run('PRAGMA journal_mode = WAL')
+		this.sql = {
+			exec: <Row extends object>(query: string, ...bindings: unknown[]): SQLCursorLike<Row> => {
+				if (bindings.length > MAX_BIND_PARAMETERS) {
+					throw new Error(`too many SQL variables: ${bindings.length} exceeds the ${MAX_BIND_PARAMETERS} a Durable Object binds`)
+				}
+				this.statementCount++
+				const statement = this.db.query<Row, SQLQueryBindings[]>(query)
+				const rows = statement.iterate(...bindings.map(toBinding))
+				return new Cursor<Row>(rows, () => {
+					this.rowCount++
+				})
+			},
+		}
+	}
+
+	transactionSync<T>(closure: () => T): T {
+		if (this.#depth > 0) return closure()
+		this.#depth++
+		this.db.run('BEGIN')
+		try {
+			const result = closure()
+			this.db.run('COMMIT')
+			return result
+		} catch (error) {
+			this.db.run('ROLLBACK')
+			throw error
+		} finally {
+			this.#depth--
+		}
+	}
+
+	resetCounters(): void {
+		this.statementCount = 0
+		this.rowCount = 0
+	}
+
+	close(): void {
+		this.db.close()
+	}
+}