shioricode 0.5.2 → 0.5.3

package/README.md

@@ -20,7 +20,28 @@ sudo shioricode doctor
 sudo shioricode link connect --name "Build server"
 ```
 
-`service install` creates a dedicated operating-system account and installs the native background mechanism for the host: systemd on Linux, launchd on macOS, or a startup task on Windows. ShioriCode listens on loopback and keeps a local recovery login.
+`service install` defaults to a dedicated operating-system account and installs the native background mechanism for the host: systemd on Linux, launchd on macOS, or a startup task on Windows. ShioriCode listens on loopback and keeps a local recovery login.
+
+Account selection and service paths are explicit CLI options. Reuse the invoking user when you want the service to inherit that user's provider homes and credentials:
+
+```sh
+shioricode service install --account current --no-recovery-login
+
+# Or customize a dedicated account and service layout.
+sudo shioricode service install \
+  --account dedicated \
+  --user shioricode \
+  --home-dir /var/lib/shioricode \
+  --state-dir /var/lib/shioricode \
+  --workspace-dir /srv/shioricode/workspaces \
+  --log-file /var/log/shioricode/server.log \
+  --service-path /usr/local/bin:/usr/bin:/bin \
+  --port 3773 \
+  --recovery-username owner \
+  --recovery-password-file /root/shioricode-recovery-password
+```
+
+`--account current` installs a per-user systemd service, macOS LaunchAgent, or Windows scheduled task without administrator access. `--account dedicated` installs the system-level service and still requires `sudo`/Administrator. `--no-recovery-login` keeps hosted access GitHub-only; omit it when you also want a direct/Tailscale recovery login. `--recovery-password-file` avoids exposing that password through shell history or the process list. Without either flag, installation generates a recovery password and prints it once. The selected account, paths, and port are persisted so subsequent `service`, `doctor`, `remote`, and `link` commands target the same installation.
 
 The command also stages a private, read-only copy of Node and ShioriCode beneath the service data directory. The daemon therefore keeps working even when the npm installation came from NVM, a macOS user directory, or Windows AppData. After upgrading the global npm package, run `service install` again to atomically switch the background service to the new runtime.
 

package/dist/BunHttpServer-BvXfeDdm.cjs

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+const require_BunServices = require('./BunServices-07vLsX26.cjs');
+
+//#region ../../node_modules/@effect/platform-bun/dist/BunHttpPlatform.js
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const make$1 = /* @__PURE__ */ require_bin.make$1({
+	fileResponse(path, status, statusText, headers, start, end, _contentLength) {
+		let file = Bun.file(path);
+		if (start > 0 || end !== void 0) file = file.slice(start, end);
+		return require_bin.raw(file, {
+			headers,
+			status,
+			statusText
+		});
+	},
+	fileWebResponse(file, status, statusText, headers, _options) {
+		return require_bin.raw(file, {
+			headers,
+			status,
+			statusText
+		});
+	}
+});
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer$1 = /* @__PURE__ */ require_bin.effect(require_bin.HttpPlatform)(make$1).pipe(/* @__PURE__ */ require_bin.provide(require_BunServices.layer$1), /* @__PURE__ */ require_bin.provide(require_bin.layer$1));
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunStream.js
+/**
+* @since 1.0.0
+*/
+/**
+* An optimized version of `Stream.fromReadableStream` that uses the Bun
+* .readMany API to read multiple values at once from a `ReadableStream`.
+*
+* @since 1.0.0
+*/
+const fromReadableStream = (options) => require_bin.fromChannel(require_bin.fromTransform(require_bin.fnUntraced(function* (_, scope) {
+	const reader = options.evaluate().getReader();
+	yield* require_bin.addFinalizer$1(scope, options.releaseLockOnEnd ? require_bin.sync(() => reader.releaseLock()) : require_bin.promise(() => reader.cancel()));
+	const readMany = require_bin.callback((resume) => {
+		const result = reader.readMany();
+		if ("then" in result) result.then((_) => resume(require_bin.succeed(_)), (e) => resume(require_bin.fail$1(options.onError(e))));
+		else resume(require_bin.succeed(result));
+	});
+	return require_bin.flatMap(readMany, function loop({ done: done$1, value }) {
+		if (done$1) return require_bin.done();
+		else if (!require_bin.isReadonlyArrayNonEmpty(value)) return require_bin.flatMap(readMany, loop);
+		return require_bin.succeed(value);
+	});
+})));
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunMultipart.js
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+const stream = (source) => fromReadableStream({
+	evaluate: () => source.body,
+	onError: (cause) => require_bin.MultipartError.fromReason("InternalError", cause)
+}).pipe(require_bin.pipeThroughChannel(require_bin.makeChannel(Object.fromEntries(source.headers))));
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+const persisted = (source) => require_bin.toPersisted(stream(source));
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunHttpServer.js
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+const make = /* @__PURE__ */ require_bin.fnUntraced(function* (options) {
+	const scope$1 = yield* require_bin.scope;
+	const handlerStack = [function(_request, _server) {
+		return new Response("not found", { status: 404 });
+	}];
+	const server = Bun.serve({
+		...options,
+		fetch: handlerStack[0],
+		websocket: {
+			open(ws) {
+				require_bin.doneUnsafe(ws.data.deferred, require_bin.succeed$2(ws));
+			},
+			message(ws, message) {
+				ws.data.run(message);
+			},
+			close(ws, code, closeReason) {
+				code = typeof code === "number" ? code : 1001;
+				require_bin.doneUnsafe(ws.data.closeDeferred, require_bin.defaultCloseCodeIsError(code) ? require_bin.fail$2(new require_bin.SocketError({ reason: new require_bin.SocketCloseError({
+					code,
+					closeReason
+				}) })) : require_bin.void_$1);
+			}
+		}
+	});
+	const shutdown = yield* require_bin.promise(() => server.stop()).pipe(require_bin.cached);
+	const preemptiveShutdown = options.disablePreemptiveShutdown ? require_bin.void_ : require_bin.timeoutOrElse(shutdown, {
+		duration: options.gracefulShutdownTimeout ?? require_bin.seconds(20),
+		orElse: () => require_bin.void_
+	});
+	yield* require_bin.addFinalizer$1(scope$1, shutdown);
+	return require_bin.make({
+		address: {
+			_tag: "TcpAddress",
+			port: server.port,
+			hostname: server.hostname
+		},
+		serve: require_bin.fnUntraced(function* (httpApp, middleware) {
+			const parent = yield* require_bin.fiber;
+			const services = parent.services;
+			const serveScope = require_bin.getUnsafe(services, require_bin.Scope);
+			const scope = require_bin.forkUnsafe(serveScope, "parallel");
+			const httpEffect = require_bin.toHandled(httpApp, (request, response) => require_bin.sync(() => {
+				request.resolve(makeResponse(request, response, services, scope));
+			}), middleware);
+			function handler(request, server) {
+				return new Promise((resolve, _reject) => {
+					const map = new Map(services.mapUnsafe);
+					map.set(require_bin.HttpServerRequest.key, new BunServerRequest(request, resolve, removeHost(request.url), server));
+					const fiber = require_bin.runIn(require_bin.runForkWith(require_bin.makeUnsafe$3(map))(httpEffect), scope);
+					request.signal.addEventListener("abort", () => {
+						fiber.interruptUnsafe(parent.id, require_bin.ClientAbort.annotation);
+					}, { once: true });
+				});
+			}
+			yield* require_bin.addFinalizerExit(serveScope, () => {
+				handlerStack.pop();
+				server.reload({ fetch: handlerStack[handlerStack.length - 1] });
+				return preemptiveShutdown;
+			});
+			handlerStack.push(handler);
+			server.reload({ fetch: handler });
+		})
+	});
+});
+const makeResponse = (request, response, services, scope) => {
+	const fields = {
+		headers: new globalThis.Headers(response.headers),
+		status: response.status
+	};
+	if (!require_bin.isEmpty(response.cookies)) for (const header of require_bin.toSetCookieHeaders(response.cookies)) fields.headers.append("set-cookie", header);
+	if (response.statusText !== void 0) fields.statusText = response.statusText;
+	if (request.method === "HEAD") return new Response(void 0, fields);
+	response = require_bin.scopeTransferToStream(response);
+	const body = response.body;
+	switch (body._tag) {
+		case "Empty": return new Response(void 0, fields);
+		case "Uint8Array":
+		case "Raw":
+			if (body.body instanceof Response) {
+				for (const [key, value] of fields.headers.entries()) body.body.headers.set(key, value);
+				return body.body;
+			}
+			return new Response(body.body, fields);
+		case "FormData": return new Response(body.formData, fields);
+		case "Stream": return new Response(require_bin.toReadableStreamWith(require_bin.unwrap$1(require_bin.withFiber((fiber) => {
+			require_bin.runIn(fiber, scope);
+			return require_bin.succeed(body.stream);
+		})), services), fields);
+	}
+};
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerServer = /* @__PURE__ */ require_bin.flow(make, /* @__PURE__ */ require_bin.effect(require_bin.HttpServer));
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerHttpServices = /* @__PURE__ */ require_bin.mergeAll(layer$1, require_bin.layerWeak, require_BunServices.layer);
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer = (options) => require_bin.mergeAll(layerServer(options), layerHttpServices);
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerTest = /* @__PURE__ */ require_bin.layerTestClient.pipe(/* @__PURE__ */ require_bin.provide(/* @__PURE__ */ require_bin.layer.pipe(/* @__PURE__ */ require_bin.provide(/* @__PURE__ */ require_bin.succeed$1(require_bin.RequestInit)({ keepalive: false })))), /* @__PURE__ */ require_bin.provideMerge(/* @__PURE__ */ layer({ port: 0 })));
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerConfig = (options) => require_bin.mergeAll(require_bin.effect(require_bin.HttpServer)(require_bin.flatMap(require_bin.unwrap(options).asEffect(), make)), layerHttpServices);
+function wsDefaultRun(_) {
+	this.buffer.push(_);
+}
+var BunServerRequest = class BunServerRequest extends require_bin.Class {
+	[require_bin.TypeId];
+	[require_bin.TypeId$3];
+	source;
+	resolve;
+	url;
+	bunServer;
+	headersOverride;
+	remoteAddressOverride;
+	constructor(source, resolve, url, bunServer, headersOverride, remoteAddressOverride) {
+		super();
+		this[require_bin.TypeId] = require_bin.TypeId;
+		this[require_bin.TypeId$3] = require_bin.TypeId$3;
+		this.source = source;
+		this.resolve = resolve;
+		this.url = url;
+		this.bunServer = bunServer;
+		this.headersOverride = headersOverride;
+		this.remoteAddressOverride = remoteAddressOverride;
+	}
+	toJSON() {
+		return require_bin.inspect(this, {
+			_id: "HttpServerRequest",
+			method: this.method,
+			url: this.originalUrl
+		});
+	}
+	modify(options) {
+		return new BunServerRequest(this.source, this.resolve, options.url ?? this.url, this.bunServer, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+	}
+	get method() {
+		return this.source.method.toUpperCase();
+	}
+	get originalUrl() {
+		return this.source.url;
+	}
+	get remoteAddress() {
+		return this.remoteAddressOverride ?? require_bin.fromNullishOr(this.bunServer.requestIP(this.source)?.address);
+	}
+	get headers() {
+		this.headersOverride ??= require_bin.fromInput$1(this.source.headers);
+		return this.headersOverride;
+	}
+	cachedCookies;
+	get cookies() {
+		if (this.cachedCookies) return this.cachedCookies;
+		return this.cachedCookies = require_bin.parseHeader(this.headers.cookie ?? "");
+	}
+	get stream() {
+		return this.source.body ? fromReadableStream({
+			evaluate: () => this.source.body,
+			onError: (cause) => new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+				request: this,
+				cause
+			}) })
+		}) : require_bin.fail(new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+			request: this,
+			description: "can not create stream from empty body"
+		}) }));
+	}
+	textEffect;
+	get text() {
+		if (this.textEffect) return this.textEffect;
+		this.textEffect = require_bin.runSync(require_bin.cached(require_bin.tryPromise({
+			try: () => this.source.text(),
+			catch: (cause) => new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+				request: this,
+				cause
+			}) })
+		})));
+		return this.textEffect;
+	}
+	get json() {
+		return require_bin.flatMap(this.text, (_) => require_bin.try_({
+			try: () => JSON.parse(_),
+			catch: (cause) => new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+				request: this,
+				cause
+			}) })
+		}));
+	}
+	get urlParamsBody() {
+		return require_bin.flatMap(this.text, (_) => require_bin.try_({
+			try: () => require_bin.fromInput(new URLSearchParams(_)),
+			catch: (cause) => new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+				request: this,
+				cause
+			}) })
+		}));
+	}
+	multipartEffect;
+	get multipart() {
+		if (this.multipartEffect) return this.multipartEffect;
+		this.multipartEffect = require_bin.runSync(require_bin.cached(persisted(this.source)));
+		return this.multipartEffect;
+	}
+	get multipartStream() {
+		return stream(this.source);
+	}
+	arrayBufferEffect;
+	get arrayBuffer() {
+		if (this.arrayBufferEffect) return this.arrayBufferEffect;
+		this.arrayBufferEffect = require_bin.runSync(require_bin.cached(require_bin.tryPromise({
+			try: () => this.source.arrayBuffer(),
+			catch: (cause) => new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+				request: this,
+				cause
+			}) })
+		})));
+		return this.arrayBufferEffect;
+	}
+	get upgrade() {
+		return require_bin.callback((resume) => {
+			const deferred = require_bin.makeUnsafe$2();
+			const closeDeferred = require_bin.makeUnsafe$2();
+			const semaphore = require_bin.makeUnsafe(1);
+			if (!this.bunServer.upgrade(this.source, { data: {
+				deferred,
+				closeDeferred,
+				buffer: [],
+				run: wsDefaultRun
+			} })) {
+				resume(require_bin.fail$1(new require_bin.HttpServerError({ reason: new require_bin.RequestParseError({
+					request: this,
+					description: "Not an upgradeable ServerRequest"
+				}) })));
+				return;
+			}
+			resume(require_bin.map$1(require_bin._await(deferred), (ws) => {
+				const write = (chunk) => require_bin.sync(() => {
+					if (typeof chunk === "string") ws.sendText(chunk);
+					else if (require_bin.isCloseEvent(chunk)) ws.close(chunk.code, chunk.reason);
+					else ws.sendBinary(chunk);
+					return true;
+				});
+				const writer = require_bin.succeed(write);
+				const runRaw = require_bin.fnUntraced(function* (handler, opts) {
+					const set = yield* require_bin.make$4();
+					const run = yield* require_bin.runtime(set)();
+					function runRaw(data) {
+						const result = handler(data);
+						if (require_bin.isEffect(result)) run(result);
+					}
+					ws.data.run = runRaw;
+					ws.data.buffer.forEach(runRaw);
+					ws.data.buffer.length = 0;
+					if (opts?.onOpen) yield* opts.onOpen;
+					return yield* require_bin.join(set);
+				}, require_bin.scoped, require_bin.onExit((exit) => require_bin.sync(() => ws.close(exit._tag === "Success" ? 1e3 : 1011))), require_bin.raceFirst(require_bin._await(closeDeferred)), semaphore.withPermits(1));
+				const encoder = new TextEncoder();
+				const run = (handler, opts) => runRaw((data) => typeof data === "string" ? handler(encoder.encode(data)) : handler(data), opts);
+				return require_bin.Socket.of({
+					[require_bin.TypeId$2]: require_bin.TypeId$2,
+					run,
+					runRaw,
+					writer
+				});
+			}));
+		});
+	}
+};
+const removeHost = (url) => {
+	if (url[0] === "/") return url;
+	const index = url.indexOf("/", url.indexOf("//") + 2);
+	return index === -1 ? "/" : url.slice(index);
+};
+
+//#endregion
+exports.layer = layer;
+exports.layerConfig = layerConfig;
+exports.layerHttpServices = layerHttpServices;
+exports.layerServer = layerServer;
+exports.layerTest = layerTest;
+exports.make = make;
+//# sourceMappingURL=BunHttpServer-BvXfeDdm.cjs.map

package/dist/BunPTY-l5TwbZzE.cjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+
+//#region src/terminal/Layers/BunPTY.ts
+var BunPtyProcess = class {
+	dataListeners = /* @__PURE__ */ new Set();
+	exitListeners = /* @__PURE__ */ new Set();
+	decoder = new TextDecoder();
+	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 = require_bin.effect(require_bin.PtyAdapter, require_bin.gen(function* () {
+	if (process.platform === "win32") return yield* require_bin.die$1("Bun PTY terminal support is unavailable on Windows. Please use Node.js (e.g. by running `npx t3`) instead.");
+	return { spawn: (input) => require_bin.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
+exports.layer = layer;
+//# sourceMappingURL=BunPTY-l5TwbZzE.cjs.map

package/dist/BunServices-07vLsX26.cjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+
+//#region ../../node_modules/@effect/platform-bun/dist/BunFileSystem.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layer$4 = require_bin.layer$8;
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunPath.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layer$3 = require_bin.layer$6;
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layerPosix = require_bin.layerPosix;
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layerWin32 = require_bin.layerWin32;
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunStdio.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layer$2 = require_bin.layer$5;
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunTerminal.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const make = require_bin.make$6;
+/**
+* @since 1.0.0
+* @category layers
+*/
+const layer$1 = require_bin.layer$4;
+
+//#endregion
+//#region ../../node_modules/@effect/platform-bun/dist/BunServices.js
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layer = /* @__PURE__ */ require_bin.layer$9.pipe(/* @__PURE__ */ require_bin.provideMerge(/* @__PURE__ */ require_bin.mergeAll(layer$4, layer$3, layer$2, layer$1)));
+
+//#endregion
+exports.layer = layer;
+exports.layer$1 = layer$4;
+//# sourceMappingURL=BunServices-07vLsX26.cjs.map