@threadlines/server 0.2.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 T3 Tools Inc.
+Copyright (c) 2026 Wilfredo Leon and Threadlines contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @threadlines/server
+
+Threadlines server and CLI package.
+
+Threadlines is a local-first desktop workspace for Codex and Claude Code. This
+package contains the server/CLI used by the desktop app, remote bootstrap flows,
+and advanced local usage.
+
+Most users should install the signed desktop app from GitHub Releases:
+
+https://github.com/Threadlines/threadlines/releases
+
+## Usage
+
+Run without installing:
+
+```bash
+npx @threadlines/server@latest --help
+```
+
+Install globally:
+
+```bash
+npm install --global @threadlines/server
+threadlines --help
+```
+
+Threadlines uses locally installed coding agents. Install and authenticate at
+least one maintained provider before use:
+
+- Codex: install Codex CLI and run `codex login`
+- Claude: install Claude Code and run `claude auth login`
+
+## License
+
+MIT. See `LICENSE`.

package/dist/BunPTY-YfDZS1LK.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import { t as PtyAdapter } from "./PTY-B_NJr7la.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region src/terminal/Layers/BunPTY.ts
+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 Error("Bun PTY terminal handle is unavailable");
+		this.process.terminal.write(data);
+	}
+	resize(cols, rows) {
+		if (!this.process.terminal?.resize) throw new Error("Bun PTY resize is unavailable");
+		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 layer = Layer.effect(PtyAdapter, Effect.gen(function* () {
+	if (process.platform === "win32") return yield* Effect.die("Bun PTY terminal support is unavailable on Windows. Please use Node.js (e.g. by running `threadlines`) instead.");
+	return { spawn: (input) => Effect.sync(() => {
+		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;
+	}) };
+}));
+//#endregion
+export { layer };
+
+//# sourceMappingURL=BunPTY-YfDZS1LK.mjs.map

package/dist/NodePTY-4q2ctg4D.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { n as PtySpawnError, t as PtyAdapter } from "./PTY-B_NJr7la.mjs";
+import { createRequire } from "node:module";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+//#region src/terminal/Layers/NodePTY.ts
+let didEnsureSpawnHelperExecutable = false;
+const resolveNodePtySpawnHelperPath = Effect.gen(function* () {
+	const requireForNodePty = createRequire(import.meta.url);
+	const path = yield* Path.Path;
+	const fs = yield* FileSystem.FileSystem;
+	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", `${process.platform}-${process.arch}`, "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* (explicitPath) {
+	const fs = yield* FileSystem.FileSystem;
+	if (process.platform === "win32") return;
+	if (!explicitPath && didEnsureSpawnHelperExecutable) return;
+	const helperPath = explicitPath ?? (yield* resolveNodePtySpawnHelperPath);
+	if (!helperPath) return;
+	if (!explicitPath) 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 layer = Layer.effect(PtyAdapter, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const nodePty = yield* Effect.promise(() => import("node-pty"));
+	const ensureNodePtySpawnHelperExecutableCached = yield* Effect.cached(ensureNodePtySpawnHelperExecutable().pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.orElseSucceed(() => void 0)));
+	return { spawn: Effect.fn(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: globalThis.process.platform === "win32" ? "xterm-color" : "xterm-256color"
+			}),
+			catch: (cause) => new PtySpawnError({
+				adapter: "node-pty",
+				message: cause instanceof Error ? cause.message : "Failed to spawn PTY process",
+				cause
+			})
+		}));
+	}) };
+}));
+//#endregion
+export { ensureNodePtySpawnHelperExecutable, layer };
+
+//# sourceMappingURL=NodePTY-4q2ctg4D.mjs.map

package/dist/NodeSqliteClient-CroFvdcT.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Stream from "effect/Stream";
+import * as Client from "effect/unstable/sql/SqlClient";
+import * as Config from "effect/Config";
+import { identity } from "effect/Function";
+import * as Cache from "effect/Cache";
+import * as Scope from "effect/Scope";
+import * as Semaphore from "effect/Semaphore";
+import * as Fiber from "effect/Fiber";
+import { DatabaseSync } 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";
+/**
+* SqliteClient - Effect service tag for the sqlite SQL client.
+*/
+const SqliteClient = Context.Service("threadlines/persistence/NodeSqliteClient");
+/**
+* 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(`Node.js ${process.versions.node} is missing required node:sqlite APIs (StatementSync.columns). Upgrade to 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 = openDatabase();
+		yield* Scope.addFinalizer(scope, Effect.sync(() => db.close()));
+		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) => {
+			statement.setReadBigInts(Boolean(Context.get(fiber.context, Client.SafeIntegers)));
+			try {
+				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 runValuesStatement = (statement, params) => 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"
+			}) })
+		});
+		const runValues = (sql, params) => Effect.acquireUseRelease(Cache.get(prepareCache, sql), (statement) => runValuesStatement(statement, params), (statement) => Effect.sync(() => {
+			if (hasRows(statement)) statement.setReturnArrays(false);
+		}));
+		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);
+			},
+			executeValuesUnprepared(sql, params) {
+				return runValuesStatement(db.prepare(sql), params ?? []);
+			},
+			executeUnprepared(sql, params, rowTransform) {
+				const effect = runStatement(db.prepare(sql), params ?? [], false);
+				return rowTransform ? Effect.map(effect, rowTransform) : effect;
+			},
+			executeStream(_sql, _params) {
+				return Stream.die("executeStream not implemented");
+			}
+		});
+	});
+	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 DatabaseSync(options.filename, {
+	readOnly: options.readonly ?? false,
+	allowExtension: options.allowExtension ?? false
+}));
+const makeMemory = (config = {}) => makeWithDatabase({
+	...config,
+	filename: ":memory:",
+	readonly: false
+}, () => {
+	return new DatabaseSync(":memory:", { allowExtension: config.allowExtension ?? false });
+});
+const layerConfig = (config) => Layer.effectContext(Config.unwrap(config).pipe(Effect.flatMap(make), Effect.map((client) => Context.make(SqliteClient, client).pipe(Context.add(Client.SqlClient, client))))).pipe(Layer.provide(Reactivity.layer));
+const layer = (config) => Layer.effectContext(Effect.map(make(config), (client) => Context.make(SqliteClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
+const layerMemory = (config = {}) => Layer.effectContext(Effect.map(makeMemory(config), (client) => Context.make(SqliteClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
+//#endregion
+export { SqliteClient, TypeId, layer, layerConfig, layerMemory };
+
+//# sourceMappingURL=NodeSqliteClient-CroFvdcT.mjs.map

package/dist/PTY-B_NJr7la.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+import "effect/Effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
+//#region src/terminal/Services/PTY.ts
+/**
+* PtyError - Error type for PTY adapter operations.
+*/
+var PtySpawnError = class extends Schema.TaggedErrorClass()("PtySpawnError", {
+	adapter: Schema.String,
+	message: Schema.String,
+	cause: Schema.optional(Schema.Defect())
+}) {};
+/**
+* PtyAdapter - Service tag for PTY process integration.
+*/
+var PtyAdapter = class extends Context.Service()("threadlines/terminal/Services/PTY/PtyAdapter") {};
+//#endregion
+export { PtySpawnError as n, PtyAdapter as t };
+
+//# sourceMappingURL=PTY-B_NJr7la.mjs.map