@aitty/server 0.1.0

package/dist/frontend/terminal.css

@@ -0,0 +1,268 @@
+.wterm {
+  --term-fg: #d4d4d4;
+  --term-bg: #1e1e1e;
+  --term-cursor: #aeafad;
+
+  --term-color-0: #1e1e1e;
+  --term-color-1: #f44747;
+  --term-color-2: #6a9955;
+  --term-color-3: #d7ba7d;
+  --term-color-4: #569cd6;
+  --term-color-5: #c586c0;
+  --term-color-6: #4ec9b0;
+  --term-color-7: #d4d4d4;
+  --term-color-8: #808080;
+  --term-color-9: #f44747;
+  --term-color-10: #6a9955;
+  --term-color-11: #d7ba7d;
+  --term-color-12: #569cd6;
+  --term-color-13: #c586c0;
+  --term-color-14: #4ec9b0;
+  --term-color-15: #ffffff;
+
+  --term-font-family: 'Menlo', 'Consolas', 'DejaVu Sans Mono', 'Courier New', monospace;
+  --term-font-size: 14px;
+  --term-line-height: 1.2;
+  --term-row-height: 17px;
+
+  position: relative;
+  background: var(--term-bg);
+  color: var(--term-fg);
+  font-family: var(--term-font-family);
+  font-size: var(--term-font-size);
+  line-height: var(--term-line-height);
+  padding: 12px;
+  border-radius: 8px;
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+  outline: none;
+  overflow: hidden;
+}
+
+.wterm:focus,
+.wterm:focus-visible {
+  outline: none;
+}
+
+.term-grid {
+  display: block;
+  white-space: pre;
+  contain: layout paint style;
+  will-change: contents;
+}
+
+.term-row {
+  display: block;
+  height: var(--term-row-height);
+  line-height: var(--term-row-height);
+  contain: layout style;
+}
+
+.term-row > span {
+  display: inline-block;
+  height: var(--term-row-height);
+  vertical-align: top;
+}
+
+.term-block {
+  width: 1ch;
+  overflow: hidden;
+}
+
+.term-cursor {
+  outline: 1px solid var(--term-cursor);
+  outline-offset: -1px;
+}
+
+.wterm.focused .term-cursor {
+  background: var(--term-cursor);
+  color: var(--term-bg);
+  outline: none;
+}
+
+.wterm.focused.cursor-blink .term-cursor {
+  animation: cursor-blink 1s step-end infinite;
+}
+
+@keyframes cursor-blink {
+  0%, 100% { background: var(--term-cursor); color: var(--term-bg); }
+  50% { background: transparent; color: inherit; }
+}
+
+.wterm.has-scrollback {
+  overflow-y: auto;
+}
+
+.wterm ::selection {
+  background: rgba(86, 156, 214, 0.3);
+}
+
+/* Solarized Dark */
+.wterm.theme-solarized-dark {
+  --term-fg: #839496;
+  --term-bg: #002b36;
+  --term-cursor: #93a1a1;
+  --term-color-0: #073642;
+  --term-color-1: #dc322f;
+  --term-color-2: #859900;
+  --term-color-3: #b58900;
+  --term-color-4: #268bd2;
+  --term-color-5: #d33682;
+  --term-color-6: #2aa198;
+  --term-color-7: #eee8d5;
+  --term-color-8: #586e75;
+  --term-color-9: #cb4b16;
+  --term-color-10: #586e75;
+  --term-color-11: #657b83;
+  --term-color-12: #839496;
+  --term-color-13: #6c71c4;
+  --term-color-14: #93a1a1;
+  --term-color-15: #fdf6e3;
+}
+
+/* Monokai */
+.wterm.theme-monokai {
+  --term-fg: #f8f8f2;
+  --term-bg: #272822;
+  --term-cursor: #f8f8f0;
+  --term-color-0: #272822;
+  --term-color-1: #f92672;
+  --term-color-2: #a6e22e;
+  --term-color-3: #f4bf75;
+  --term-color-4: #66d9ef;
+  --term-color-5: #ae81ff;
+  --term-color-6: #a1efe4;
+  --term-color-7: #f8f8f2;
+  --term-color-8: #75715e;
+  --term-color-9: #f92672;
+  --term-color-10: #a6e22e;
+  --term-color-11: #f4bf75;
+  --term-color-12: #66d9ef;
+  --term-color-13: #ae81ff;
+  --term-color-14: #a1efe4;
+  --term-color-15: #f9f8f5;
+}
+
+/* Light */
+.wterm.theme-light {
+  --term-fg: #383a42;
+  --term-bg: #fafafa;
+  --term-cursor: #526eff;
+  --term-color-0: #383a42;
+  --term-color-1: #e45649;
+  --term-color-2: #50a14f;
+  --term-color-3: #c18401;
+  --term-color-4: #4078f2;
+  --term-color-5: #a626a4;
+  --term-color-6: #0184bc;
+  --term-color-7: #fafafa;
+  --term-color-8: #a0a1a7;
+  --term-color-9: #e45649;
+  --term-color-10: #50a14f;
+  --term-color-11: #c18401;
+  --term-color-12: #4078f2;
+  --term-color-13: #a626a4;
+  --term-color-14: #0184bc;
+  --term-color-15: #ffffff;
+}
+
+.aitty-embed,
+.aitty-shell,
+.aitty-scroll-target,
+.aitty-scroll-viewport {
+  min-width: 0;
+  min-height: 0;
+}
+
+.aitty-embed {
+  height: 100%;
+  min-height: 240px;
+}
+
+.aitty-shell,
+.aitty-scroll-target {
+  height: 100%;
+}
+
+.aitty-scroll-target {
+  overflow: hidden;
+}
+
+.aitty-scroll-viewport {
+  height: 100%;
+  outline: none;
+  overflow-x: hidden;
+  overflow-y: auto;
+}
+
+.aitty-scroll-content {
+  min-height: 100%;
+}
+
+.aitty-terminal-root {
+  position: relative;
+  min-width: 0;
+  min-height: 100%;
+  max-height: none;
+  background: transparent;
+}
+
+.aitty-terminal-root.wterm {
+  --term-bg: var(--theme-term-bg, transparent);
+  --term-fg: var(--theme-term-fg, #edf2ff);
+  --term-cursor: var(--theme-term-cursor, currentColor);
+  --term-color-0: var(--theme-term-color-0, #111724);
+  --term-color-1: var(--theme-term-color-1, #ff7b72);
+  --term-color-2: var(--theme-term-color-2, #8ddb8c);
+  --term-color-3: var(--theme-term-color-3, #ffd580);
+  --term-color-4: var(--theme-term-color-4, #7cc4ff);
+  --term-color-5: var(--theme-term-color-5, #d2a8ff);
+  --term-color-6: var(--theme-term-color-6, #77e0d2);
+  --term-color-7: var(--theme-term-color-7, #edf2ff);
+  --term-color-8: var(--theme-term-color-8, #5f6f86);
+  --term-color-9: var(--theme-term-color-9, #ffa198);
+  --term-color-10: var(--theme-term-color-10, #b0f2af);
+  --term-color-11: var(--theme-term-color-11, #ffe4a8);
+  --term-color-12: var(--theme-term-color-12, #a7d7ff);
+  --term-color-13: var(--theme-term-color-13, #e1c0ff);
+  --term-color-14: var(--theme-term-color-14, #9ff4ea);
+  --term-color-15: var(--theme-term-color-15, #ffffff);
+  --term-font-size: var(--theme-term-font-size, 15px);
+  --term-line-height: var(--theme-term-line-height, 1.28);
+  color: var(--term-fg);
+  padding: 0 0 var(--theme-term-padding-bottom, 24px);
+  border-radius: 0;
+  box-shadow: none;
+  overflow: visible;
+}
+
+.aitty-terminal-root.wterm.has-scrollback {
+  overflow-y: visible;
+}
+
+.aitty-terminal-root[data-session-interactive="false"] .term-cursor {
+  opacity: 0 !important;
+}
+
+.aitty-terminal-root[data-session-interactive="false"] textarea {
+  caret-color: transparent;
+}
+
+.aitty-terminal-root .term-transcript-archive {
+  margin: 0;
+  min-height: 0;
+  padding: 0;
+  color: inherit;
+  font: inherit;
+  line-height: var(--term-row-height);
+  pointer-events: none;
+  white-space: pre;
+}
+
+.aitty-terminal-root .term-transcript-archive:empty {
+  display: none;
+}
+
+.aitty-terminal-root[data-render-mode="screen"] .term-transcript-archive,
+.aitty-terminal-root[data-render-mode="screen"] .term-scrollback-row {
+  display: none;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { createSessionToken } from "./cli-token.js";
+import { NetworkPolicy, createNetworkPolicy, isHostAllowed, isOriginAllowed } from "./network-policy.js";
+import { BrowserShellDocumentOptions, BrowserShellOptions, createBrowserShellHtml } from "./frontend/browser-shell.js";
+import { DEFAULT_COLUMNS, DEFAULT_ROWS, DEFAULT_TERM, Disposable, PtyExitEvent, PtyModule, PtyProcess, PtySession, PtySessionOptions, PtySpawnOptions, createPtySession } from "./runtime/pty-session.js";
+import { AittyTheme, AittyThemeSource, AittyThemeSubscription } from "./theme-source.js";
+import { AittyPortlessIdentity, AittyPortlessOptions, AittyRunningServer, AittyRuntimeDependencies, AittyServerIo, AittyServerOptions, Writer, buildAittyOrigin, buildAittyUrl, createAittyServer } from "./server.js";
+import { RuntimeDependencies, loadRuntimeDependencies } from "./runtime/dependencies.js";
+import { WebSocketTransport, WebSocketTransportOptions, createWebSocketTransport } from "./runtime/websocket-transport.js";
+import { DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES, MAX_OUTPUT_BUFFER_LIMIT_BYTES, MIN_OUTPUT_BUFFER_LIMIT_BYTES, OutputBuffer, createOutputBuffer } from "./runtime/output-buffer.js";
+
+//#region src/index.d.ts
+declare const projectFoundation: Readonly<{
+  name: "aitty";
+  engineRange: ">=20";
+}>;
+//#endregion
+export { type AittyPortlessIdentity, type AittyPortlessOptions, type AittyRunningServer, type AittyRuntimeDependencies, type AittyServerIo, type AittyServerOptions, type AittyTheme, type AittyThemeSource, type AittyThemeSubscription, type BrowserShellDocumentOptions, type BrowserShellOptions, DEFAULT_COLUMNS, DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES, DEFAULT_ROWS, DEFAULT_TERM, type Disposable, MAX_OUTPUT_BUFFER_LIMIT_BYTES, MIN_OUTPUT_BUFFER_LIMIT_BYTES, type NetworkPolicy, type OutputBuffer, type PtyExitEvent, type PtyModule, type PtyProcess, type PtySession, type PtySessionOptions, type PtySpawnOptions, type RuntimeDependencies, type AittyTheme as TerminalTheme, type WebSocketTransport, type WebSocketTransportOptions, type Writer, buildAittyOrigin, buildAittyUrl, createAittyServer, createBrowserShellHtml, createNetworkPolicy, createOutputBuffer, createPtySession, createSessionToken, createWebSocketTransport, isHostAllowed, isOriginAllowed, loadRuntimeDependencies, projectFoundation };

package/dist/index.js

@@ -0,0 +1,15 @@
+import { createSessionToken } from "./cli-token.js";
+import { createNetworkPolicy, isHostAllowed, isOriginAllowed } from "./network-policy.js";
+import { createBrowserShellHtml } from "./frontend/browser-shell.js";
+import { DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES, MAX_OUTPUT_BUFFER_LIMIT_BYTES, MIN_OUTPUT_BUFFER_LIMIT_BYTES, createOutputBuffer } from "./runtime/output-buffer.js";
+import { DEFAULT_COLUMNS, DEFAULT_ROWS, DEFAULT_TERM, createPtySession } from "./runtime/pty-session.js";
+import { createWebSocketTransport } from "./runtime/websocket-transport.js";
+import { buildAittyOrigin, buildAittyUrl, createAittyServer } from "./server.js";
+import { loadRuntimeDependencies } from "./runtime/dependencies.js";
+//#region src/index.ts
+const projectFoundation = Object.freeze({
+	name: "aitty",
+	engineRange: ">=20"
+});
+//#endregion
+export { DEFAULT_COLUMNS, DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES, DEFAULT_ROWS, DEFAULT_TERM, MAX_OUTPUT_BUFFER_LIMIT_BYTES, MIN_OUTPUT_BUFFER_LIMIT_BYTES, buildAittyOrigin, buildAittyUrl, createAittyServer, createBrowserShellHtml, createNetworkPolicy, createOutputBuffer, createPtySession, createSessionToken, createWebSocketTransport, isHostAllowed, isOriginAllowed, loadRuntimeDependencies, projectFoundation };

package/dist/logging.d.ts

@@ -0,0 +1,17 @@
+//#region src/logging.d.ts
+interface LogWriter {
+  write(chunk: string): boolean;
+}
+interface StructuredLogger {
+  debug(message: string): void;
+  error(message: string): void;
+  info(message: string): void;
+  warn(message: string): void;
+}
+declare function createStructuredLogger(options: {
+  token?: string;
+  verbose?: boolean;
+  writer: LogWriter;
+}): StructuredLogger;
+//#endregion
+export { LogWriter, StructuredLogger, createStructuredLogger };

package/dist/logging.js

@@ -0,0 +1,34 @@
+//#region src/logging.ts
+function createStructuredLogger(options) {
+	const redactions = [options.token].filter((value) => typeof value === "string" && value.length > 0);
+	return {
+		debug(message) {
+			if (!options.verbose) return;
+			writeStructuredLog(options.writer, "DEBUG", message, redactions);
+		},
+		error(message) {
+			writeStructuredLog(options.writer, "ERROR", message, redactions);
+		},
+		info(message) {
+			writeStructuredLog(options.writer, "INFO", message, redactions);
+		},
+		warn(message) {
+			writeStructuredLog(options.writer, "WARN", message, redactions);
+		}
+	};
+}
+function writeStructuredLog(writer, level, message, redactions) {
+	for (const line of normalizeLogLines(redactSecrets(message, redactions))) writer.write(`[${level}] ${line}\n`);
+}
+function normalizeLogLines(message) {
+	const lines = message.replace(/\r\n/g, "\n").split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	return lines.length > 0 ? lines : [""];
+}
+function redactSecrets(message, redactions) {
+	let redacted = message;
+	for (const secret of redactions) redacted = redacted.split(secret).join("[REDACTED]");
+	return redacted;
+}
+//#endregion
+export { createStructuredLogger };

package/dist/network-policy.d.ts

@@ -0,0 +1,10 @@
+//#region src/network-policy.d.ts
+interface NetworkPolicy {
+  readonly allowedHosts: ReadonlySet<string>;
+  readonly port: number;
+}
+declare function createNetworkPolicy(bindHost: string, publicHost: string, port: number): NetworkPolicy;
+declare function isHostAllowed(hostHeader: string | string[] | undefined, policy: NetworkPolicy): boolean;
+declare function isOriginAllowed(originHeader: string | string[] | undefined, policy: NetworkPolicy): boolean;
+//#endregion
+export { NetworkPolicy, createNetworkPolicy, isHostAllowed, isOriginAllowed };

package/dist/network-policy.js

@@ -0,0 +1,88 @@
+//#region src/network-policy.ts
+const LOOPBACK_SCHEME = "http:";
+function createNetworkPolicy(bindHost, publicHost, port) {
+	return {
+		allowedHosts: new Set([normalizeHost(bindHost), normalizeHost(publicHost)]),
+		port
+	};
+}
+function isHostAllowed(hostHeader, policy) {
+	const authority = readSingleHeaderValue(hostHeader);
+	if (!authority) return false;
+	const parsed = parseAuthority(authority);
+	if (!parsed) return false;
+	return policy.allowedHosts.has(parsed.host) && (parsed.port === null || parsed.port === policy.port);
+}
+function isOriginAllowed(originHeader, policy) {
+	const origin = readSingleHeaderValue(originHeader);
+	if (!origin) return true;
+	let parsed;
+	try {
+		parsed = new URL(origin);
+	} catch {
+		return false;
+	}
+	if (parsed.protocol !== LOOPBACK_SCHEME) return false;
+	const authority = readAuthority(origin);
+	if (!authority) return false;
+	const originAuthority = parseAuthority(authority);
+	if (!originAuthority || originAuthority.port === null) return false;
+	return isLoopbackHost(originAuthority.host) || policy.allowedHosts.has(originAuthority.host) && originAuthority.port === policy.port;
+}
+function readSingleHeaderValue(value) {
+	if (typeof value !== "string") return null;
+	const candidate = value.trim();
+	return candidate ? candidate : null;
+}
+function parseAuthority(authority) {
+	const candidate = authority.trim();
+	if (!candidate) return null;
+	let hostPart = candidate;
+	let portPart = null;
+	if (candidate.startsWith("[")) {
+		const closingBracketIndex = candidate.indexOf("]");
+		if (closingBracketIndex === -1) return null;
+		hostPart = candidate.slice(1, closingBracketIndex);
+		const remainder = candidate.slice(closingBracketIndex + 1);
+		if (remainder) {
+			if (!remainder.startsWith(":")) return null;
+			portPart = remainder.slice(1);
+		}
+	} else {
+		const firstColonIndex = candidate.indexOf(":");
+		if (firstColonIndex !== candidate.lastIndexOf(":")) return null;
+		if (firstColonIndex !== -1) {
+			hostPart = candidate.slice(0, firstColonIndex);
+			portPart = candidate.slice(firstColonIndex + 1);
+		}
+	}
+	if (!hostPart) return null;
+	if (portPart === null) return {
+		host: normalizeHost(hostPart),
+		port: null
+	};
+	if (!/^\d+$/.test(portPart)) return null;
+	const port = Number.parseInt(portPart, 10);
+	if (port < 0 || port > 65535) return null;
+	return {
+		host: normalizeHost(hostPart),
+		port
+	};
+}
+function readAuthority(url) {
+	const schemeSeparatorIndex = url.indexOf("://");
+	if (schemeSeparatorIndex === -1) return null;
+	const authorityStart = schemeSeparatorIndex + 3;
+	const remainder = url.slice(authorityStart);
+	const authorityLength = remainder.search(/[/?#]/);
+	return (authorityLength === -1 ? remainder : remainder.slice(0, authorityLength)) || null;
+}
+function normalizeHost(host) {
+	return host.replace(/^\[(.*)\]$/, "$1").toLowerCase();
+}
+function isLoopbackHost(host) {
+	const normalizedHost = normalizeHost(host);
+	return normalizedHost === "localhost" || normalizedHost === "::1" || normalizedHost.startsWith("127.");
+}
+//#endregion
+export { createNetworkPolicy, isHostAllowed, isOriginAllowed };

package/dist/runtime/dependencies.d.ts

@@ -0,0 +1,16 @@
+import * as _$ws from "ws";
+import * as _$node_pty0 from "node-pty";
+import * as _$open from "open";
+
+//#region src/runtime/dependencies.d.ts
+interface RuntimeDependencies {
+  nodePty: {
+    spawn: typeof _$node_pty0.spawn;
+  };
+  WebSocket: typeof _$ws.WebSocket;
+  WebSocketServer: typeof _$ws.WebSocketServer;
+  openBrowser: (typeof _$open)["default"];
+}
+declare function loadRuntimeDependencies(): Promise<RuntimeDependencies>;
+//#endregion
+export { RuntimeDependencies, loadRuntimeDependencies };

package/dist/runtime/dependencies.js

@@ -0,0 +1,16 @@
+//#region src/runtime/dependencies.ts
+async function loadRuntimeDependencies() {
+	const [nodePtyModule, wsModule, openModule] = await Promise.all([
+		import("node-pty"),
+		import("ws"),
+		import("open")
+	]);
+	return {
+		nodePty: nodePtyModule,
+		WebSocket: wsModule.WebSocket,
+		WebSocketServer: wsModule.WebSocketServer,
+		openBrowser: openModule.default
+	};
+}
+//#endregion
+export { loadRuntimeDependencies };

package/dist/runtime/output-buffer.d.ts

@@ -0,0 +1,11 @@
+//#region src/runtime/output-buffer.d.ts
+declare const DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES: number;
+declare const MIN_OUTPUT_BUFFER_LIMIT_BYTES = 1024;
+declare const MAX_OUTPUT_BUFFER_LIMIT_BYTES: number;
+interface OutputBuffer {
+  append(chunk: Buffer): void;
+  snapshot(): Buffer | null;
+}
+declare function createOutputBuffer(limitBytes?: number): OutputBuffer;
+//#endregion
+export { DEFAULT_OUTPUT_BUFFER_LIMIT_BYTES, MAX_OUTPUT_BUFFER_LIMIT_BYTES, MIN_OUTPUT_BUFFER_LIMIT_BYTES, OutputBuffer, createOutputBuffer };