zl-code 0.0.28

package/dist/BunPtyAdapter-Dv4TIbHu.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import { n as PtySpawnError, o as HostProcessPlatform, t as PtyAdapter } from "./PtyAdapter-CuvX_Afe.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+//#region src/terminal/BunPtyAdapter.ts
+var BunPtyUnsupportedPlatformError = class extends Schema.TaggedErrorClass()("BunPtyUnsupportedPlatformError", { platform: Schema.Literal("win32") }) {
+	get message() {
+		return `Bun PTY terminal support is unavailable on ${this.platform}. Please use Node.js (e.g. by running \`npx zl-code\`) instead.`;
+	}
+};
+var BunPtyOperationUnavailableError = class extends Schema.TaggedErrorClass()("BunPtyOperationUnavailableError", {
+	operation: Schema.Literals(["write", "resize"]),
+	pid: Schema.Number
+}) {
+	get message() {
+		return `Bun PTY ${this.operation} is unavailable for process ${this.pid}.`;
+	}
+};
+var BunPtyProcess = class {
+	dataListeners = /* @__PURE__ */ new Set();
+	exitListeners = /* @__PURE__ */ new Set();
+	decoder = new TextDecoder();
+	process;
+	didExit = false;
+	constructor(process) {
+		this.process = process;
+		this.process.exited.then((exitCode) => {
+			this.emitExit({
+				exitCode: Number.isInteger(exitCode) ? exitCode : 0,
+				signal: typeof this.process.signalCode === "number" ? this.process.signalCode : null
+			});
+		}).catch(() => {
+			this.emitExit({
+				exitCode: 1,
+				signal: null
+			});
+		});
+	}
+	get pid() {
+		return this.process.pid;
+	}
+	write(data) {
+		if (!this.process.terminal) throw new BunPtyOperationUnavailableError({
+			operation: "write",
+			pid: this.pid
+		});
+		this.process.terminal.write(data);
+	}
+	resize(cols, rows) {
+		if (!this.process.terminal?.resize) throw new BunPtyOperationUnavailableError({
+			operation: "resize",
+			pid: this.pid
+		});
+		this.process.terminal.resize(cols, rows);
+	}
+	kill(signal) {
+		if (!signal) {
+			this.process.kill();
+			return;
+		}
+		this.process.kill(signal);
+	}
+	onData(callback) {
+		this.dataListeners.add(callback);
+		return () => {
+			this.dataListeners.delete(callback);
+		};
+	}
+	onExit(callback) {
+		this.exitListeners.add(callback);
+		return () => {
+			this.exitListeners.delete(callback);
+		};
+	}
+	emitData(data) {
+		if (this.didExit) return;
+		const text = this.decoder.decode(data, { stream: true });
+		if (text.length === 0) return;
+		for (const listener of this.dataListeners) listener(text);
+	}
+	emitExit(event) {
+		if (this.didExit) return;
+		this.didExit = true;
+		const remainder = this.decoder.decode();
+		if (remainder.length > 0) for (const listener of this.dataListeners) listener(remainder);
+		for (const listener of this.exitListeners) listener(event);
+	}
+};
+const make = Effect.fn("BunPtyAdapter.make")(function* () {
+	const platform = yield* HostProcessPlatform;
+	if (platform === "win32") return yield* Effect.die(new BunPtyUnsupportedPlatformError({ platform }));
+	return PtyAdapter.of({ spawn: (input) => Effect.try({
+		try: () => {
+			let processHandle = null;
+			const command = [input.shell, ...input.args ?? []];
+			processHandle = new BunPtyProcess(Bun.spawn(command, {
+				cwd: input.cwd,
+				env: input.env,
+				terminal: {
+					cols: input.cols,
+					rows: input.rows,
+					data: (_terminal, data) => {
+						processHandle?.emitData(data);
+					}
+				}
+			}));
+			return processHandle;
+		},
+		catch: (cause) => new PtySpawnError({
+			adapter: "bun",
+			shell: input.shell,
+			cause
+		})
+	}) });
+});
+const layer = Layer.effect(PtyAdapter, make());
+//#endregion
+export { BunPtyOperationUnavailableError, BunPtyUnsupportedPlatformError, layer, make };

package/dist/NodePtyAdapter-BD2yuv0S.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+import { n as PtySpawnError, o as HostProcessPlatform, r as HostProcessArchitecture, t as PtyAdapter } from "./PtyAdapter-CuvX_Afe.mjs";
+import * as NodeModule from "node:module";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+//#region src/terminal/NodePtyAdapter.ts
+var NodePtyModuleLoadError = class extends Schema.TaggedErrorClass()("NodePtyModuleLoadError", {
+	platform: Schema.String,
+	architecture: Schema.String,
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Failed to load node-pty for ${this.platform}-${this.architecture}.`;
+	}
+};
+let didEnsureSpawnHelperExecutable = false;
+const resolveNodePtySpawnHelperPath = Effect.gen(function* () {
+	const requireForNodePty = NodeModule.createRequire(import.meta.url);
+	const path = yield* Path.Path;
+	const fs = yield* FileSystem.FileSystem;
+	const platform = yield* HostProcessPlatform;
+	const architecture = yield* HostProcessArchitecture;
+	const packageJsonPath = requireForNodePty.resolve("node-pty/package.json");
+	const packageDir = path.dirname(packageJsonPath);
+	const candidates = [
+		path.join(packageDir, "build", "Release", "spawn-helper"),
+		path.join(packageDir, "build", "Debug", "spawn-helper"),
+		path.join(packageDir, "prebuilds", `${platform}-${architecture}`, "spawn-helper")
+	];
+	for (const candidate of candidates) if (yield* fs.exists(candidate)) return candidate;
+	return null;
+}).pipe(Effect.orElseSucceed(() => null));
+const ensureNodePtySpawnHelperExecutable = Effect.fn(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	if ((yield* HostProcessPlatform) === "win32") return;
+	if (didEnsureSpawnHelperExecutable) return;
+	const helperPath = yield* resolveNodePtySpawnHelperPath;
+	if (!helperPath) return;
+	didEnsureSpawnHelperExecutable = true;
+	if (!(yield* fs.exists(helperPath))) return;
+	yield* fs.chmod(helperPath, 493).pipe(Effect.orElseSucceed(() => void 0));
+});
+var NodePtyProcess = class {
+	process;
+	constructor(process) {
+		this.process = process;
+	}
+	get pid() {
+		return this.process.pid;
+	}
+	write(data) {
+		this.process.write(data);
+	}
+	resize(cols, rows) {
+		this.process.resize(cols, rows);
+	}
+	kill(signal) {
+		this.process.kill(signal);
+	}
+	onData(callback) {
+		const disposable = this.process.onData(callback);
+		return () => {
+			disposable.dispose();
+		};
+	}
+	onExit(callback) {
+		const disposable = this.process.onExit((event) => {
+			callback({
+				exitCode: event.exitCode,
+				signal: event.signal ?? null
+			});
+		});
+		return () => {
+			disposable.dispose();
+		};
+	}
+};
+const make = Effect.fn("NodePtyAdapter.make")(function* (loadNodePtyModule = () => import("node-pty")) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const platform = yield* HostProcessPlatform;
+	const architecture = yield* HostProcessArchitecture;
+	const nodePty = yield* Effect.tryPromise({
+		try: loadNodePtyModule,
+		catch: (cause) => new NodePtyModuleLoadError({
+			platform,
+			architecture,
+			cause
+		})
+	}).pipe(Effect.orDie);
+	const ensureNodePtySpawnHelperExecutableCached = yield* Effect.cached(ensureNodePtySpawnHelperExecutable().pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.provideService(HostProcessPlatform, platform), Effect.provideService(HostProcessArchitecture, architecture), Effect.orElseSucceed(() => void 0)));
+	return PtyAdapter.of({ spawn: Effect.fn("NodePtyAdapter.spawn")(function* (input) {
+		yield* ensureNodePtySpawnHelperExecutableCached;
+		return new NodePtyProcess(yield* Effect.try({
+			try: () => nodePty.spawn(input.shell, input.args ?? [], {
+				cwd: input.cwd,
+				cols: input.cols,
+				rows: input.rows,
+				env: input.env,
+				name: platform === "win32" ? "xterm-color" : "xterm-256color"
+			}),
+			catch: (cause) => new PtySpawnError({
+				adapter: "node-pty",
+				shell: input.shell,
+				cause
+			})
+		}));
+	}) });
+});
+const layer = Layer.effect(PtyAdapter, make());
+//#endregion
+export { NodePtyModuleLoadError, layer, make };

package/dist/NodeSqliteClient-Di95o_wK.mjs

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
+import * as Duration from "effect/Duration";
+import * as Config from "effect/Config";
+import * as Stream from "effect/Stream";
+import * as Client from "effect/unstable/sql/SqlClient";
+import * as Semaphore from "effect/Semaphore";
+import * as Scope from "effect/Scope";
+import { identity } from "effect/Function";
+import * as Cache from "effect/Cache";
+import * as Fiber from "effect/Fiber";
+import * as NodeSqlite from "node:sqlite";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { SqlError, classifySqliteError } from "effect/unstable/sql/SqlError";
+import * as Statement from "effect/unstable/sql/Statement";
+//#region src/persistence/NodeSqliteClient.ts
+/**
+* Port of `@effect/sql-sqlite-node` that uses the native `node:sqlite`
+* bindings instead of `better-sqlite3`.
+*
+* @module SqliteClient
+*/
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const TypeId = "~local/sqlite-node/SqliteClient";
+var UnsupportedNodeSqliteVersionError = class extends Schema.TaggedErrorClass()("UnsupportedNodeSqliteVersionError", {
+	nodeVersion: Schema.String,
+	requirement: Schema.String
+}) {
+	get message() {
+		return `Node.js ${this.nodeVersion} is missing required node:sqlite APIs. Upgrade to ${this.requirement}.`;
+	}
+};
+var UnsupportedNodeSqliteOperationError = class extends Schema.TaggedErrorClass()("UnsupportedNodeSqliteOperationError", {}) {
+	get message() {
+		return "Node SQLite does not support executeStream.";
+	}
+};
+/**
+* Verify that the current Node.js version includes the `node:sqlite` APIs
+* used by `NodeSqliteClient` — specifically `StatementSync.columns()` (added
+* in Node 22.16.0 / 23.11.0).
+*
+* @see https://github.com/nodejs/node/pull/57490
+*/
+const checkNodeSqliteCompat = () => {
+	const parts = process.versions.node.split(".").map(Number);
+	const major = parts[0] ?? 0;
+	const minor = parts[1] ?? 0;
+	if (!(major === 22 && minor >= 16 || major === 23 && minor >= 11 || major >= 24)) return Effect.die(new UnsupportedNodeSqliteVersionError({
+		nodeVersion: process.versions.node,
+		requirement: "Node.js >=22.16, >=23.11, or >=24"
+	}));
+	return Effect.void;
+};
+const makeWithDatabase = Effect.fn("makeWithDatabase")(function* (options, openDatabase) {
+	yield* checkNodeSqliteCompat();
+	const compiler = Statement.makeCompilerSqlite(options.transformQueryNames);
+	const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : void 0;
+	const makeConnection = Effect.gen(function* () {
+		const scope = yield* Effect.scope;
+		const db = yield* Effect.try({
+			try: openDatabase,
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to open database",
+				operation: "open"
+			}) })
+		});
+		yield* Scope.addFinalizer(scope, Effect.try({
+			try: () => db.close(),
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to close database",
+				operation: "close"
+			}) })
+		}).pipe(Effect.orDie));
+		const statementReaderCache = /* @__PURE__ */ new WeakMap();
+		const hasRows = (statement) => {
+			const cached = statementReaderCache.get(statement);
+			if (cached !== void 0) return cached;
+			const value = statement.columns().length > 0;
+			statementReaderCache.set(statement, value);
+			return value;
+		};
+		const prepareCache = yield* Cache.make({
+			capacity: options.prepareCacheSize ?? 200,
+			timeToLive: options.prepareCacheTTL ?? Duration.minutes(10),
+			lookup: (sql) => Effect.try({
+				try: () => db.prepare(sql),
+				catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+					message: "Failed to prepare statement",
+					operation: "prepare"
+				}) })
+			})
+		});
+		const runStatement = (statement, params, raw) => Effect.withFiber((fiber) => {
+			try {
+				statement.setReadBigInts(Boolean(Context.get(fiber.context, Client.SafeIntegers)));
+				if (hasRows(statement)) return Effect.succeed(statement.all(...params));
+				const result = statement.run(...params);
+				return Effect.succeed(raw ? result : []);
+			} catch (cause) {
+				return Effect.fail(new SqlError({ reason: classifySqliteError(cause, {
+					message: "Failed to execute statement",
+					operation: "execute"
+				}) }));
+			}
+		});
+		const run = (sql, params, raw = false) => Effect.flatMap(Cache.get(prepareCache, sql), (s) => runStatement(s, params, raw));
+		const runValues = (sql, params) => Effect.acquireUseRelease(Cache.get(prepareCache, sql), (statement) => Effect.try({
+			try: () => {
+				if (hasRows(statement)) {
+					statement.setReturnArrays(true);
+					return statement.all(...params);
+				}
+				statement.run(...params);
+				return [];
+			},
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to execute statement",
+				operation: "execute"
+			}) })
+		}), (statement) => Effect.try({
+			try: () => {
+				if (hasRows(statement)) statement.setReturnArrays(false);
+			},
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to reset statement result mode",
+				operation: "resetResultMode"
+			}) })
+		}).pipe(Effect.orDie));
+		return identity({
+			execute(sql, params, rowTransform) {
+				return rowTransform ? Effect.map(run(sql, params), rowTransform) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params, true);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeUnprepared(sql, params, rowTransform) {
+				const effect = Effect.try({
+					try: () => db.prepare(sql),
+					catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+						message: "Failed to prepare statement",
+						operation: "prepare"
+					}) })
+				}).pipe(Effect.flatMap((statement) => runStatement(statement, params ?? [], false)));
+				return rowTransform ? Effect.map(effect, rowTransform) : effect;
+			},
+			executeStream(_sql, _params) {
+				return Stream.die(new UnsupportedNodeSqliteOperationError());
+			}
+		});
+	});
+	const semaphore = yield* Semaphore.make(1);
+	const connection = yield* makeConnection;
+	const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
+	const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+		const fiber = Fiber.getCurrent();
+		const scope = Context.getUnsafe(fiber.context, Scope.Scope);
+		return Effect.as(Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))), connection);
+	});
+	return yield* Client.make({
+		acquirer,
+		compiler,
+		transactionAcquirer,
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	});
+});
+const make = (options) => makeWithDatabase(options, () => new NodeSqlite.DatabaseSync(options.filename, {
+	readOnly: options.readonly ?? false,
+	allowExtension: options.allowExtension ?? false
+}));
+const makeMemory = (config = {}) => makeWithDatabase({
+	...config,
+	filename: ":memory:",
+	readonly: false
+}, () => {
+	return new NodeSqlite.DatabaseSync(":memory:", { allowExtension: config.allowExtension ?? false });
+});
+const layerConfig = (config) => Layer.effect(Client.SqlClient, Config.unwrap(config).pipe(Effect.flatMap(make))).pipe(Layer.provide(Reactivity.layer));
+const layer = (config) => Layer.effect(Client.SqlClient, make(config)).pipe(Layer.provide(Reactivity.layer));
+const layerMemory = (config = {}) => Layer.effect(Client.SqlClient, makeMemory(config)).pipe(Layer.provide(Reactivity.layer));
+//#endregion
+export { TypeId, UnsupportedNodeSqliteOperationError, UnsupportedNodeSqliteVersionError, layer, layerConfig, layerMemory };

package/dist/PtyAdapter-CuvX_Afe.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
+import * as NodeOS from "node:os";
+//#region ../../packages/shared/src/hostProcess.ts
+const HostProcessPlatform = Context.Reference("@zl-tools/shared/hostProcess/HostProcessPlatform", { defaultValue: () => process.platform });
+const HostProcessArchitecture = Context.Reference("@zl-tools/shared/hostProcess/HostProcessArchitecture", { defaultValue: () => process.arch });
+const HostProcessHostname = Context.Reference("@zl-tools/shared/hostProcess/HostProcessHostname", { defaultValue: () => NodeOS.hostname() });
+const HostProcessEnvironment = Context.Reference("@zl-tools/shared/hostProcess/HostProcessEnvironment", { defaultValue: () => process.env });
+Effect.map(HostProcessPlatform, (platform) => platform === "win32");
+//#endregion
+//#region src/terminal/PtyAdapter.ts
+/**
+* PtyAdapter - Terminal PTY adapter service contract.
+*
+* Defines the process primitives required by terminal session management
+* without binding to a specific PTY implementation.
+*
+* @module PtyAdapter
+*/
+/**
+* PtySpawnError - Error type for PTY spawn failures.
+*/
+var PtySpawnError = class extends Schema.TaggedErrorClass()("PtySpawnError", {
+	adapter: Schema.String,
+	shell: Schema.optional(Schema.String),
+	attemptedShells: Schema.optional(Schema.Array(Schema.String)),
+	cause: Schema.optional(Schema.Defect())
+}) {
+	get message() {
+		const shell = this.shell === void 0 ? "" : ` '${this.shell}'`;
+		const attemptedShells = this.attemptedShells === void 0 || this.attemptedShells.length === 0 ? "" : ` Tried shells: ${this.attemptedShells.join(", ")}.`;
+		return `Failed to spawn PTY process${shell} with ${this.adapter}.${attemptedShells}`;
+	}
+};
+/**
+* PtyAdapter - Service tag for PTY process integration.
+*/
+var PtyAdapter = class extends Context.Service()("@zl-tools/server/terminal/PtyAdapter") {};
+//#endregion
+export { HostProcessHostname as a, HostProcessEnvironment as i, PtySpawnError as n, HostProcessPlatform as o, HostProcessArchitecture as r, PtyAdapter as t };