@aitty/server 0.1.0

package/dist/server.js

@@ -0,0 +1,234 @@
+import { createSessionToken } from "./cli-token.js";
+import { createNetworkPolicy } from "./network-policy.js";
+import { handleBrowserShellRequest } from "./frontend/browser-shell.js";
+import { createStructuredLogger } from "./logging.js";
+import { createPtySession } from "./runtime/pty-session.js";
+import { createWebSocketTransport } from "./runtime/websocket-transport.js";
+import { readThemeSource } from "./theme-source.js";
+import { createServer } from "node:http";
+import { constants } from "node:os";
+import path from "node:path";
+import { createAittyPortlessIdentity, normalizeAittyPortlessPathname } from "@aitty/protocol";
+//#region src/server.ts
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 0;
+const DEFAULT_PORTLESS_PROJECT = "session";
+async function createAittyServer(options, dependencies, io = {}) {
+	const stderr = io.stderr ?? process.stderr;
+	const token = createSessionToken();
+	const logger = createStructuredLogger({
+		token,
+		verbose: options.verbose,
+		writer: stderr
+	});
+	const sourceTheme = await readThemeSource(options.themeSource).catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.warn(`Failed to read theme source: ${message}`);
+	});
+	const requestState = {};
+	const runtimeKind = options.runtimeKind ?? "pty";
+	const shellOptions = {
+		...options.shell,
+		theme: options.theme ?? sourceTheme ?? options.shell?.theme
+	};
+	const server = createServer((request, response) => {
+		handleBrowserShellRequest(request, response, token, runtimeKind, requestState.networkPolicy, shellOptions).catch((error) => {
+			if (!response.writableEnded) {
+				response.statusCode = 500;
+				response.setHeader("Content-Type", "text/plain; charset=utf-8");
+				response.end("Internal Server Error");
+			}
+			const message = error instanceof Error ? error.message : String(error);
+			logger.error(`Failed to serve browser request: ${message}`);
+		});
+	});
+	await listen(server, options.host ?? DEFAULT_HOST, options.port ?? DEFAULT_PORT);
+	let session;
+	try {
+		session = createPtySession({
+			args: options.args ?? [],
+			bufferSize: options.bufferSize,
+			cwd: options.cwd,
+			env: options.env ?? process.env,
+			file: options.command
+		}, dependencies.nodePty);
+	} catch (error) {
+		await closeServer(server);
+		throw error;
+	}
+	const address = server.address();
+	if (!address || typeof address === "string") {
+		session.kill("SIGTERM");
+		await closeServer(server);
+		throw new Error("Server did not expose a TCP address");
+	}
+	const host = normalizeHost(address, options.host ?? DEFAULT_HOST);
+	const port = address.port;
+	const publicHost = options.publicHost ?? host;
+	const publicOrigin = options.publicOrigin ?? buildAittyOrigin(publicHost, port);
+	const portless = createPortlessIdentity(options, token);
+	const url = buildAittyUrl(publicOrigin, token, portless.path);
+	requestState.networkPolicy = createNetworkPolicy(host, publicHost, port);
+	const websocketTransport = dependencies.WebSocketServer ? createWebSocketTransport({
+		WebSocketServer: dependencies.WebSocketServer,
+		networkPolicy: requestState.networkPolicy,
+		server,
+		session,
+		stderr,
+		themeSource: options.themeSource,
+		token,
+		verbose: options.verbose
+	}) : void 0;
+	let finalized = false;
+	let childExitHandled = false;
+	let requestedShutdownSignal = null;
+	let signalHandlersInstalled = false;
+	let signalDisposers = [];
+	let resolveClosed;
+	const closed = new Promise((resolve) => {
+		resolveClosed = resolve;
+	});
+	const finalize = async (exitCode) => {
+		if (finalized) return closed;
+		finalized = true;
+		exitSubscription.dispose();
+		if (signalHandlersInstalled) {
+			for (const dispose of signalDisposers) dispose();
+			signalDisposers = [];
+			signalHandlersInstalled = false;
+		}
+		await websocketTransport?.close();
+		await closeServer(server);
+		resolveClosed(exitCode);
+		return exitCode;
+	};
+	const handleChildExit = async (event) => {
+		if (childExitHandled) return closed;
+		childExitHandled = true;
+		const presentedExit = applyRequestedShutdownSignal(event, requestedShutdownSignal);
+		logger.info(formatChildExit(presentedExit));
+		try {
+			await websocketTransport?.notifyExit(presentedExit);
+		} catch {}
+		return finalize(resolveProcessExitCode(presentedExit));
+	};
+	const exitSubscription = session.onExit((event) => {
+		handleChildExit(event);
+	});
+	const close = async (signal = "SIGTERM") => {
+		requestedShutdownSignal ??= signal;
+		if (!childExitHandled) await handleChildExit(await session.close(signal));
+		return closed;
+	};
+	if (io.registerSignalHandlers !== false) {
+		signalHandlersInstalled = true;
+		signalDisposers = ["SIGINT", "SIGTERM"].map((signal) => {
+			const handler = () => {
+				close(signal);
+			};
+			process.once(signal, handler);
+			return () => {
+				process.removeListener(signal, handler);
+			};
+		});
+	}
+	logger.info(`startup bind=${host}:${port} public-origin=${publicOrigin}`);
+	logger.debug(`startup command=${options.command} child-pid=${session.pid}`);
+	return {
+		childPid: session.pid,
+		close,
+		closed,
+		host,
+		port,
+		portless,
+		session,
+		token,
+		url
+	};
+}
+function buildAittyUrl(origin, token, pathname) {
+	const url = new URL(normalizeAittyOrigin(origin));
+	url.pathname = normalizePortlessPathname(pathname);
+	url.search = "";
+	url.searchParams.set("t", token);
+	return url.toString();
+}
+function buildAittyOrigin(host, port) {
+	return `http://${formatUrlHost(host)}:${port}`;
+}
+function normalizeHost(address, configuredHost) {
+	if (address.address === "::" || address.address === "0.0.0.0") return configuredHost;
+	return address.address;
+}
+function formatUrlHost(host) {
+	return host.includes(":") ? `[${host}]` : host;
+}
+function createPortlessIdentity(options, token) {
+	return createAittyPortlessIdentity({
+		label: options.portless?.label ?? (path.basename(options.command) || "agent"),
+		labelFallback: "agent",
+		project: options.portless?.project ?? path.basename(options.cwd),
+		projectFallback: DEFAULT_PORTLESS_PROJECT,
+		token
+	});
+}
+function normalizeAittyOrigin(origin) {
+	const candidate = origin.trim();
+	if (!candidate) throw new Error("Aitty URL origin must not be empty");
+	return candidate.endsWith("/") ? candidate : `${candidate}/`;
+}
+const normalizePortlessPathname = normalizeAittyPortlessPathname;
+function applyRequestedShutdownSignal(event, signal) {
+	if (!signal) return event;
+	return {
+		exitCode: event.exitCode,
+		signal: resolveSignalNumber(signal) ?? event.signal
+	};
+}
+function resolveSignalNumber(signal) {
+	const value = constants.signals[signal];
+	return typeof value === "number" ? value : void 0;
+}
+function formatChildExit(event) {
+	const signalName = resolveSignalName(event.signal);
+	if (signalName) return `child exit signal=${signalName}`;
+	return `child exit code=${event.exitCode}`;
+}
+function resolveSignalName(signal) {
+	if (typeof signal !== "number") return null;
+	const signals = constants.signals;
+	for (const [name, value] of Object.entries(signals)) if (value === signal) return name;
+	return null;
+}
+function resolveProcessExitCode(event) {
+	if (event.signal) return 128 + event.signal;
+	return event.exitCode;
+}
+function listen(server, host, port) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(port, host);
+	});
+}
+function closeServer(server) {
+	return new Promise((resolve, reject) => {
+		server.close((error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+//#endregion
+export { buildAittyOrigin, buildAittyUrl, createAittyServer };

package/dist/theme-source.d.ts

@@ -0,0 +1,2 @@
+import { AittyTheme, AittyThemeControlFrame, AittyThemeSource, AittyThemeSubscription, createThemeControlFrame, normalizeTheme, readThemeSource, subscribeThemeSource } from "@aitty/protocol";
+export { type AittyTheme, type AittyThemeControlFrame, type AittyThemeSource, type AittyThemeSubscription, createThemeControlFrame, normalizeTheme, readThemeSource, subscribeThemeSource };

package/dist/theme-source.js

@@ -0,0 +1,2 @@
+import { createThemeControlFrame, normalizeTheme, readThemeSource, subscribeThemeSource } from "@aitty/protocol";
+export { createThemeControlFrame, normalizeTheme, readThemeSource, subscribeThemeSource };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@aitty/server",
+  "version": "0.1.0",
+  "description": "Local PTY, HTTP, and WebSocket server runtime for aitty.",
+  "keywords": [
+    "agent",
+    "ai",
+    "browser",
+    "pty",
+    "server",
+    "terminal",
+    "websocket"
+  ],
+  "homepage": "https://github.com/kingsword09/aitty#readme",
+  "bugs": {
+    "url": "https://github.com/kingsword09/aitty/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "Kingsword kingsword09 <kingsword09@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kingsword09/aitty.git",
+    "directory": "packages/server"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./cli-token": {
+      "types": "./dist/cli-token.d.ts",
+      "default": "./dist/cli-token.js"
+    },
+    "./frontend/*": {
+      "types": "./dist/frontend/*.d.ts",
+      "default": "./dist/frontend/*.js"
+    },
+    "./logging": {
+      "types": "./dist/logging.d.ts",
+      "default": "./dist/logging.js"
+    },
+    "./network-policy": {
+      "types": "./dist/network-policy.d.ts",
+      "default": "./dist/network-policy.js"
+    },
+    "./runtime/*": {
+      "types": "./dist/runtime/*.d.ts",
+      "default": "./dist/runtime/*.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@aitty/protocol": "workspace:*",
+    "node-pty": "1.2.0-beta.12",
+    "open": "^11.0.0",
+    "ws": "^8.20.0"
+  }
+}