@das-org/dascode 0.0.31

package/dist/service-launcher.mjs

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+
+import * as NodeChildProcess from "node:child_process";
+import * as NodeCrypto from "node:crypto";
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath from "node:path";
+const SERVICE_LAUNCHER_CONTEXT_ENV = "DASCODE_SERVICE_LAUNCHER_CONTEXT";
+const SERVICE_STATE_FILE = "service-state.json";
+const SEMVER_NUMBER = "(?:0|[1-9]\\d*)";
+const SEMVER_PRERELEASE = `(?:${SEMVER_NUMBER}|[0-9]*[A-Za-z-][0-9A-Za-z-]*)`;
+const EXACT_SERVICE_VERSION = new RegExp(`^${SEMVER_NUMBER}\\.${SEMVER_NUMBER}\\.${SEMVER_NUMBER}(?:-${SEMVER_PRERELEASE}(?:\\.${SEMVER_PRERELEASE})*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`);
+/** Accepts exact SemVer only: never dist-tags or ranges passed to npm or filesystem paths. */
+const isExactServiceVersion = (version) => EXACT_SERVICE_VERSION.test(version);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function decodeServiceUpdate(value) {
+	if (!isRecord(value)) return void 0;
+	const { id, fromVersion, targetVersion, status } = value;
+	if (typeof id !== "string" || id.trim() === "" || typeof fromVersion !== "string" || !isExactServiceVersion(fromVersion) || typeof targetVersion !== "string" || !isExactServiceVersion(targetVersion)) return;
+	if (status === "pending") return {
+		id,
+		fromVersion,
+		targetVersion,
+		status
+	};
+	if ((status === "committed" || status === "rolled-back" || status === "failed") && (value.reason === void 0 || typeof value.reason === "string" && value.reason.trim() !== "")) return {
+		id,
+		fromVersion,
+		targetVersion,
+		status,
+		...typeof value.reason === "string" ? { reason: value.reason } : {}
+	};
+}
+/** SemVer precedence for exact versions. Build metadata is ignored. */
+function compareExactServiceVersions(left, right) {
+	const parse = (version) => {
+		const withoutBuild = version.split("+", 1)[0] ?? version;
+		const separator = withoutBuild.indexOf("-");
+		const core = separator === -1 ? withoutBuild : withoutBuild.slice(0, separator);
+		const prerelease = separator === -1 ? void 0 : withoutBuild.slice(separator + 1);
+		const [major = "0", minor = "0", patch = "0"] = core.split(".");
+		return {
+			core: [
+				BigInt(major),
+				BigInt(minor),
+				BigInt(patch)
+			],
+			prerelease: prerelease?.split(".") ?? []
+		};
+	};
+	const a = parse(left);
+	const b = parse(right);
+	for (let index = 0; index < 3; index += 1) {
+		const x = a.core[index] ?? 0n;
+		const y = b.core[index] ?? 0n;
+		if (x !== y) return x < y ? -1 : 1;
+	}
+	if (a.prerelease.length === 0 || b.prerelease.length === 0) return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length === 0 ? 1 : -1;
+	const count = Math.max(a.prerelease.length, b.prerelease.length);
+	for (let index = 0; index < count; index += 1) {
+		const x = a.prerelease[index];
+		const y = b.prerelease[index];
+		if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+		if (x === y) continue;
+		const xNumeric = /^\d+$/.test(x);
+		const yNumeric = /^\d+$/.test(y);
+		if (xNumeric && yNumeric) return BigInt(x) < BigInt(y) ? -1 : 1;
+		if (xNumeric !== yNumeric) return xNumeric ? -1 : 1;
+		return x < y ? -1 : 1;
+	}
+	return 0;
+}
+function decodeServiceState(value) {
+	if (!isRecord(value)) return void 0;
+	const update = value.update === void 0 ? void 0 : decodeServiceUpdate(value.update);
+	if (value.protocol !== 1 || typeof value.activeVersion !== "string" || !isExactServiceVersion(value.activeVersion) || value.update !== void 0 && update === void 0 || update !== void 0 && compareExactServiceVersions(update.targetVersion, update.fromVersion) <= 0 || update?.status === "pending" && update.fromVersion !== value.activeVersion || update?.status === "committed" && update.targetVersion !== value.activeVersion || (update?.status === "rolled-back" || update?.status === "failed") && update.fromVersion !== value.activeVersion) return;
+	return {
+		protocol: 1,
+		activeVersion: value.activeVersion,
+		...update === void 0 ? {} : { update }
+	};
+}
+function parseServiceState(value) {
+	try {
+		return decodeServiceState(JSON.parse(value));
+	} catch {
+		return;
+	}
+}
+function decodeServiceLauncherChildMessage(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.type === "request-update" && typeof value.targetVersion === "string") return {
+		type: value.type,
+		targetVersion: value.targetVersion
+	};
+	return value.type === "prepared" && typeof value.updateId === "string" ? {
+		type: value.type,
+		updateId: value.updateId
+	} : void 0;
+}
+//#endregion
+//#region src/serviceLauncher.ts
+const HANDOFF_DELAY_MS = 2e3;
+const PREPARED_TIMEOUT_MS = 12e4;
+const TERMINATE_GRACE_MS = 5e3;
+const runtimePaths = (baseDir, version) => {
+	const versionDir = NodePath.join(baseDir, "runtime", "versions", version);
+	return {
+		versionDir,
+		entryPath: NodePath.join(versionDir, "node_modules", "@das-org", "dascode", "dist", "bin.mjs"),
+		sentinelPath: NodePath.join(versionDir, ".install-complete")
+	};
+};
+async function readServiceState(filePath) {
+	const state = parseServiceState(await NodeFSP.readFile(filePath, "utf8"));
+	if (state === void 0) throw new Error("Service state is invalid or unsupported.");
+	return state;
+}
+/** Durable same-directory replacement used for every runtime state transition. */
+async function writeServiceState(filePath, state) {
+	const directory = NodePath.dirname(filePath);
+	await NodeFSP.mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const tempPath = NodePath.join(directory, `.${NodePath.basename(filePath)}.${process.pid}.${NodeCrypto.randomUUID()}`);
+	let handle;
+	try {
+		handle = await NodeFSP.open(tempPath, "wx", 384);
+		await handle.writeFile(`${JSON.stringify(state, null, 2)}\n`, "utf8");
+		await handle.sync();
+		await handle.close();
+		handle = void 0;
+		await NodeFSP.rename(tempPath, filePath);
+		const directoryHandle = await NodeFSP.open(directory, "r");
+		try {
+			await directoryHandle.sync();
+		} finally {
+			await directoryHandle.close();
+		}
+	} finally {
+		await handle?.close().catch(() => void 0);
+		await NodeFSP.rm(tempPath, { force: true }).catch(() => void 0);
+	}
+}
+async function runtimeExists(baseDir, version) {
+	const paths = runtimePaths(baseDir, version);
+	try {
+		const [entry, sentinel] = await Promise.all([NodeFSP.stat(paths.entryPath), NodeFSP.readFile(paths.sentinelPath, "utf8")]);
+		return entry.isFile() && sentinel.trim() === version;
+	} catch {
+		return false;
+	}
+}
+function terminalUpdate(input) {
+	return {
+		id: input.pending.id,
+		fromVersion: input.pending.fromVersion,
+		targetVersion: input.pending.targetVersion,
+		status: input.status,
+		...input.reason === void 0 ? {} : { reason: input.reason }
+	};
+}
+function sendMessage(child, message) {
+	return new Promise((resolve, reject) => {
+		if (!child.connected || child.send === void 0) {
+			reject(/* @__PURE__ */ new Error("service child IPC is disconnected."));
+			return;
+		}
+		child.send(message, (error) => error === null ? resolve() : reject(error));
+	});
+}
+function waitForExit(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
+	return new Promise((resolve) => child.once("exit", () => resolve()));
+}
+async function terminateChild(child, signal = "SIGTERM") {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	child.kill(signal);
+	const force = setTimeout(() => child.kill("SIGKILL"), TERMINATE_GRACE_MS);
+	try {
+		await waitForExit(child);
+	} finally {
+		clearTimeout(force);
+	}
+}
+var Launcher = class {
+	#baseDir;
+	#statePath;
+	#state;
+	#child = null;
+	#timer;
+	#transitions = Promise.resolve();
+	#stopping = false;
+	#done = false;
+	#completion = Promise.withResolvers();
+	constructor(baseDir, state) {
+		this.#baseDir = baseDir;
+		this.#statePath = NodePath.join(baseDir, "runtime", SERVICE_STATE_FILE);
+		this.#state = state;
+	}
+	async run() {
+		const onSigterm = () => void this.stop("SIGTERM");
+		const onSigint = () => void this.stop("SIGINT");
+		process.once("SIGTERM", onSigterm);
+		process.once("SIGINT", onSigint);
+		try {
+			this.#enqueue(() => this.#recover());
+			await this.#completion.promise;
+		} finally {
+			process.off("SIGTERM", onSigterm);
+			process.off("SIGINT", onSigint);
+		}
+	}
+	#enqueue(transition) {
+		this.#transitions = this.#transitions.then(transition, transition).catch((cause) => this.#fatal(cause instanceof Error ? cause : new Error(String(cause))));
+	}
+	async #fatal(error) {
+		if (this.#done) return;
+		this.#done = true;
+		this.#stopping = true;
+		this.#clearTimer();
+		const child = this.#child?.process;
+		this.#child = null;
+		if (child !== void 0) await terminateChild(child);
+		this.#completion.reject(error);
+	}
+	async stop(signal) {
+		if (this.#stopping) {
+			await this.#completion.promise.catch(() => void 0);
+			return;
+		}
+		this.#stopping = true;
+		this.#clearTimer();
+		this.#enqueue(async () => {
+			const child = this.#child?.process;
+			this.#child = null;
+			if (child !== void 0) await terminateChild(child, signal);
+			this.#done = true;
+			this.#completion.resolve();
+		});
+		await this.#completion.promise.catch(() => void 0);
+	}
+	#clearTimer() {
+		clearTimeout(this.#timer);
+		this.#timer = void 0;
+	}
+	async #recover() {
+		const update = this.#state.update;
+		if (update?.status !== "pending") {
+			await this.#startChild(this.#state.activeVersion, "active", update);
+			return;
+		}
+		if (!await runtimeExists(this.#baseDir, update.targetVersion)) {
+			await this.#returnToPrevious(update, "failed", "target-runtime-missing");
+			return;
+		}
+		await this.#startTrial(update);
+	}
+	async #startTrial(pending) {
+		try {
+			await this.#startChild(pending.targetVersion, "trial", pending);
+		} catch {
+			await this.#returnToPrevious(pending, "failed", "candidate-start-failed");
+		}
+	}
+	async #startChild(version, role, update) {
+		if (this.#stopping) return;
+		if (!await runtimeExists(this.#baseDir, version)) throw new Error(`Selected @das-org/dascode@${version} runtime is missing or incomplete.`);
+		if (this.#stopping) return;
+		const paths = runtimePaths(this.#baseDir, version);
+		const context = {
+			protocol: 1,
+			childVersion: version,
+			...update === void 0 ? {} : { update }
+		};
+		const child = NodeChildProcess.spawn(process.execPath, [paths.entryPath, "serve"], {
+			env: {
+				...process.env,
+				[SERVICE_LAUNCHER_CONTEXT_ENV]: JSON.stringify(context)
+			},
+			stdio: [
+				"inherit",
+				"inherit",
+				"inherit",
+				"ipc"
+			]
+		});
+		await new Promise((resolve, reject) => {
+			const onError = (error) => reject(error);
+			child.once("error", onError);
+			child.once("spawn", () => {
+				child.removeListener("error", onError);
+				child.on("error", (error) => this.#enqueue(() => Promise.reject(error)));
+				resolve();
+			});
+		});
+		if (this.#stopping) {
+			await terminateChild(child);
+			return;
+		}
+		const managed = {
+			version,
+			role,
+			process: child
+		};
+		this.#child = managed;
+		child.on("message", (value) => {
+			const message = decodeServiceLauncherChildMessage(value);
+			if (message !== void 0) this.#enqueue(() => this.#handleMessage(managed, message));
+		});
+		child.once("exit", (code, signal) => this.#enqueue(() => this.#handleExit(managed, code, signal)));
+		if (role === "trial") this.#timer = setTimeout(() => this.#enqueue(() => this.#handlePreparedTimeout(managed)), PREPARED_TIMEOUT_MS);
+	}
+	async #handleMessage(child, message) {
+		if (this.#child !== child || this.#stopping) return;
+		if (message.type === "request-update") {
+			await this.#handleUpdateRequest(child, message);
+			return;
+		}
+		await this.#handlePrepared(child, message.updateId);
+	}
+	async #handleUpdateRequest(child, message) {
+		const reject = (reason) => sendMessage(child.process, {
+			type: "update-rejected",
+			reason
+		});
+		if (child.role !== "active") {
+			await reject("Only the active server can request an update.");
+			return;
+		}
+		if (child.version !== this.#state.activeVersion) {
+			await reject("The requesting server is not the selected active version.");
+			return;
+		}
+		if (this.#state.update?.status === "pending") {
+			await reject("Another server update is already pending.");
+			return;
+		}
+		if (!isExactServiceVersion(message.targetVersion)) {
+			await reject("The requested target is not an exact version.");
+			return;
+		}
+		if (compareExactServiceVersions(message.targetVersion, child.version) <= 0) {
+			await reject("Remote updates must select a newer server version.");
+			return;
+		}
+		if (!await runtimeExists(this.#baseDir, message.targetVersion)) {
+			await reject("The requested target runtime is missing or incomplete.");
+			return;
+		}
+		const pending = {
+			id: NodeCrypto.randomUUID(),
+			fromVersion: child.version,
+			targetVersion: message.targetVersion,
+			status: "pending"
+		};
+		const next = {
+			...this.#state,
+			update: pending
+		};
+		await writeServiceState(this.#statePath, next);
+		this.#state = next;
+		await sendMessage(child.process, {
+			type: "update-accepted",
+			updateId: pending.id
+		});
+		this.#timer = setTimeout(() => this.#enqueue(() => this.#beginTrial(child)), HANDOFF_DELAY_MS);
+	}
+	async #beginTrial(child) {
+		const pending = this.#state.update;
+		if (this.#child !== child || child.role !== "active" || pending?.status !== "pending") return;
+		this.#timer = void 0;
+		this.#child = null;
+		await terminateChild(child.process);
+		await this.#startTrial(pending);
+	}
+	async #handlePrepared(child, updateId) {
+		const pending = this.#state.update;
+		if (child.role !== "trial" || pending?.status !== "pending" || pending.id !== updateId || pending.targetVersion !== child.version) {
+			if (child.role === "trial" && pending?.status === "pending") {
+				await this.#returnToPrevious(pending, "rolled-back", "invalid-prepared", child);
+				return;
+			}
+			throw new Error("Trial child reported prepared for an unexpected update.");
+		}
+		this.#clearTimer();
+		const committed = terminalUpdate({
+			pending,
+			status: "committed"
+		});
+		const next = {
+			...this.#state,
+			activeVersion: pending.targetVersion,
+			update: committed
+		};
+		await writeServiceState(this.#statePath, next);
+		this.#state = next;
+		child.role = "active";
+		await sendMessage(child.process, {
+			type: "committed",
+			updateId: committed.id
+		});
+	}
+	async #handlePreparedTimeout(child) {
+		const pending = this.#state.update;
+		if (this.#child !== child || child.role !== "trial" || pending?.status !== "pending") return;
+		this.#timer = void 0;
+		await this.#returnToPrevious(pending, "rolled-back", "prepared-timeout", child);
+	}
+	async #handleExit(child, code, signal) {
+		if (this.#child !== child || this.#stopping) return;
+		this.#child = null;
+		if (child.role === "trial") {
+			this.#clearTimer();
+			const pending = this.#state.update;
+			if (pending?.status !== "pending") throw new Error("Trial child exited without matching pending state.");
+			await this.#returnToPrevious(pending, "rolled-back", `candidate-exited:${String(code ?? signal ?? "unknown")}`);
+			return;
+		}
+		this.#clearTimer();
+		const pending = this.#state.update;
+		if (pending?.status === "pending") {
+			await this.#startTrial(pending);
+			return;
+		}
+		throw new Error(`Active child exited unexpectedly (${String(code ?? signal ?? "unknown")}).`);
+	}
+	async #returnToPrevious(pending, status, reason, child) {
+		const outcome = terminalUpdate({
+			pending,
+			status,
+			reason
+		});
+		const next = {
+			...this.#state,
+			activeVersion: pending.fromVersion,
+			update: outcome
+		};
+		await writeServiceState(this.#statePath, next);
+		this.#state = next;
+		if (child !== void 0) {
+			this.#child = null;
+			await terminateChild(child.process);
+		}
+		await this.#startChild(next.activeVersion, "active", outcome);
+	}
+};
+async function main() {
+	const baseDir = process.env.T3CODE_HOME?.trim();
+	if (baseDir === void 0 || baseDir === "") throw new Error("T3CODE_HOME is required by the DasCode service launcher.");
+	await new Launcher(baseDir, await readServiceState(NodePath.join(baseDir, "runtime", SERVICE_STATE_FILE))).run();
+}
+if (import.meta.main) main().catch((cause) => {
+	const error = cause instanceof Error ? cause : new Error(String(cause));
+	process.stderr.write(`[service-launcher] ${error.message}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=service-launcher.mjs.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@das-org/dascode",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/B-DasApp/DasCode",
+    "directory": "apps/server"
+  },
+  "bin": {
+    "dascode": "./dist/bin.mjs"
+  },
+  "type": "module",
+  "version": "0.0.31",
+  "engines": {
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@effect/platform-bun": "4.0.0-beta.102",
+    "@effect/platform-node": "4.0.0-beta.102",
+    "@effect/platform-node-shared": "4.0.0-beta.102",
+    "@effect/sql-sqlite-bun": "4.0.0-beta.102",
+    "@ff-labs/fff-node": "0.9.4",
+    "@opencode-ai/sdk": "^1.3.15",
+    "@pierre/diffs": "1.3.0-beta.10",
+    "effect": "4.0.0-beta.102",
+    "node-pty": "^1.1.0",
+    "yaml": "^2.9.0"
+  },
+  "overrides": {
+    "@clerk/backend": "3.14.0",
+    "@clerk/clerk-js": "6.25.12",
+    "@clerk/electron": "0.0.24",
+    "@clerk/electron-passkeys": "0.0.3",
+    "@clerk/react": "6.12.9",
+    "@clerk/shared": "4.25.9",
+    "@effect/atom-react": "4.0.0-beta.102",
+    "@effect/platform-bun": "4.0.0-beta.102",
+    "@effect/platform-node": "4.0.0-beta.102",
+    "@effect/platform-node-shared": "4.0.0-beta.102",
+    "@effect/sql-pg": "4.0.0-beta.102",
+    "@effect/sql-sqlite-bun": "4.0.0-beta.102",
+    "@effect/vitest": "4.0.0-beta.102",
+    "@types/node": "24.12.4",
+    "effect": "4.0.0-beta.102",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "yaml": "^2.9.0"
+  }
+}