ai-remote 0.1.0

package/src/shared/hosts.ts

@@ -0,0 +1,240 @@
+/**
+ * The gateway's own roster of machines, and the networks it is allowed to dial.
+ *
+ * Parsing lives here, with no reference to the Worker environment, so the same
+ * code shapes the list in `VNC_HOSTS`/`RDP_HOSTS` and the list the browser
+ * receives from `/api/hosts`. Reading those variables is the Worker's job --
+ * see `src/worker/config/hosts.ts`.
+ */
+
+import type { RemoteAppLaunch } from './connection';
+import {
+  DEFAULT_PORTS,
+  DEFAULT_SSH_PORT,
+  isRdpSecurity,
+  toPort,
+  toRemoteProtocol,
+  type RdpSecurity,
+  type RemoteProtocol,
+} from './protocol';
+
+/** Optional SSH access to the same machine, which publishes a terminal for it. */
+export interface HostSshAccess {
+  port: number;
+  username?: string;
+}
+
+/** One machine as the gateway's configuration describes it. */
+export interface RemoteHostTarget {
+  id: string;
+  name: string;
+  host: string;
+  port: number;
+  protocol: RemoteProtocol;
+  /** Windows domain or computer name pre-filled in the connect dialog. */
+  domain?: string;
+  security?: RdpSecurity;
+  remoteApp?: RemoteAppLaunch;
+  ssh?: HostSshAccess;
+}
+
+/** Raw JSON entries are whatever the operator typed; nothing is assumed. */
+type RawHostEntry = Record<string, unknown>;
+
+function normalizeRemoteApp(value: unknown): RemoteAppLaunch | undefined {
+  if (typeof value === 'string' && value.trim()) return { program: value.trim() };
+  if (!value || typeof value !== 'object') return undefined;
+
+  const candidate = value as RawHostEntry;
+  const program = String(candidate.program ?? '').trim();
+  if (!program) return undefined;
+
+  return {
+    program,
+    ...(candidate.workingDir ? { workingDir: String(candidate.workingDir) } : {}),
+    ...(candidate.arguments ? { arguments: String(candidate.arguments) } : {}),
+  };
+}
+
+/**
+ * `ssh` accepts `true`, a port number, or an object. Anything else means the
+ * machine has no terminal to offer and no panel is shown for it.
+ */
+function normalizeSsh(value: unknown, fallbackUsername: unknown): HostSshAccess | undefined {
+  const inherited = typeof fallbackUsername === 'string' && fallbackUsername.trim()
+    ? fallbackUsername.trim()
+    : undefined;
+
+  if (value === true) {
+    return { port: DEFAULT_SSH_PORT, ...(inherited ? { username: inherited } : {}) };
+  }
+
+  if (typeof value === 'number' || (typeof value === 'string' && /^\d+$/.test(value.trim()))) {
+    const port = toPort(value, 0);
+    if (!port) return undefined;
+    return { port, ...(inherited ? { username: inherited } : {}) };
+  }
+
+  if (!value || typeof value !== 'object') return undefined;
+
+  const candidate = value as RawHostEntry;
+  if (candidate.enabled === false) return undefined;
+
+  const username = typeof candidate.username === 'string' && candidate.username.trim()
+    ? candidate.username.trim()
+    : inherited;
+
+  return {
+    port: toPort(candidate.port, DEFAULT_SSH_PORT),
+    ...(username ? { username } : {}),
+  };
+}
+
+function parseHostList(
+  hostsJson: string | undefined,
+  defaultProtocol: RemoteProtocol,
+  defaultHost: string,
+  defaultPort: string,
+  idPrefix: string
+): RemoteHostTarget[] {
+  if (!hostsJson) return [];
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(hostsJson);
+  } catch (error) {
+    console.warn(`Failed to parse ${idPrefix.toUpperCase()}_HOSTS JSON, ignoring it:`, error);
+    return [];
+  }
+
+  if (!Array.isArray(parsed) || parsed.length === 0) return [];
+
+  return parsed.map((raw: unknown, index): RemoteHostTarget => {
+    const entry = (raw ?? {}) as RawHostEntry;
+    const protocol = toRemoteProtocol(entry.protocol, defaultProtocol);
+    const remoteApp = protocol === 'rdp' ? normalizeRemoteApp(entry.remoteApp) : undefined;
+    const ssh = normalizeSsh(entry.ssh ?? entry.sshPort, entry.sshUser ?? entry.sshUsername);
+
+    const host = String(entry.host ?? '') || defaultHost;
+    const name = String(entry.name ?? '').trim() || host;
+
+    return {
+      id: String(entry.id ?? '') || `${idPrefix}-${index + 1}`,
+      name,
+      host,
+      port: toPort(entry.port ?? defaultPort, DEFAULT_PORTS[protocol]),
+      protocol,
+      ...(entry.domain ? { domain: String(entry.domain) } : {}),
+      ...(isRdpSecurity(entry.security) ? { security: entry.security } : {}),
+      ...(remoteApp ? { remoteApp } : {}),
+      ...(ssh ? { ssh } : {}),
+    };
+  });
+}
+
+/**
+ * Build the target list offered in the connect dialog. `VNC_HOSTS` and
+ * `RDP_HOSTS` are merged into one list; each entry may override its protocol,
+ * so a single list can carry both kinds of target.
+ */
+export function parseConfiguredHosts(options: {
+  vncHostsJson?: string;
+  rdpHostsJson?: string;
+  defaultHost?: string;
+  defaultPort?: string;
+  defaultRdpHost?: string;
+  defaultRdpPort?: string;
+}): RemoteHostTarget[] {
+  const defaultHost = options.defaultHost || '10.0.0.10';
+  const defaultPort = options.defaultPort || String(DEFAULT_PORTS.vnc);
+
+  const hosts = [
+    ...parseHostList(options.vncHostsJson, 'vnc', defaultHost, defaultPort, 'vnc-host'),
+    ...parseHostList(
+      options.rdpHostsJson,
+      'rdp',
+      options.defaultRdpHost || defaultHost,
+      options.defaultRdpPort || String(DEFAULT_PORTS.rdp),
+      'rdp-host'
+    ),
+  ];
+
+  if (hosts.length > 0) return hosts;
+
+  return [
+    {
+      id: 'default-host',
+      name: 'Primary Host',
+      host: defaultHost,
+      port: toPort(defaultPort, DEFAULT_PORTS.vnc),
+      protocol: 'vnc',
+    },
+  ];
+}
+
+/** One allowed network, as a base address and a mask. */
+export interface Subnet {
+  base: number;
+  mask: number;
+}
+
+/** Dotted-quad to a 32-bit number, or null for anything that is not one. */
+export function ipv4ToInt(value: string): number | null {
+  const parts = String(value).trim().split('.');
+  if (parts.length !== 4) return null;
+
+  let result = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null;
+    const octet = Number.parseInt(part, 10);
+    if (octet > 255) return null;
+    result = (result << 8) | octet;
+  }
+  return result >>> 0;
+}
+
+/**
+ * The networks this gateway may dial, beyond the machines named in the host
+ * lists. Written as `ALLOWED_SUBNETS`, comma-separated:
+ *
+ *   192.168.8.0/24    a CIDR block
+ *   192.168.8.*       the same thing, written the way people say it
+ *   192.168.8.67      a single address
+ *
+ * This is what lets a terminal open on a machine that was never listed. Keep it
+ * to networks you own: anything inside one can be reached on any port by anyone
+ * who gets past the gateway's login.
+ */
+export function parseAllowedSubnets(value?: string): Subnet[] {
+  if (!value) return [];
+
+  const subnets: Subnet[] = [];
+  for (const entry of value.split(',')) {
+    const text = entry.trim();
+    if (!text) continue;
+
+    // `192.168.8.*` is the same shape as `192.168.8.0/24`, one octet per step.
+    const wildcard = text.split('.').findIndex((part) => part === '*');
+    const [address, bits] = wildcard >= 0
+      ? [text.replaceAll('*', '0'), String(wildcard * 8)]
+      : text.split('/');
+
+    const base = ipv4ToInt(address ?? '');
+    if (base === null) continue;
+
+    const width = bits === undefined ? 32 : Number.parseInt(bits, 10);
+    if (!Number.isInteger(width) || width < 0 || width > 32) continue;
+
+    // A /0 would shift by 32, which JavaScript wraps back to no shift at all.
+    const mask = width === 0 ? 0 : (0xffffffff << (32 - width)) >>> 0;
+    subnets.push({ base: (base & mask) >>> 0, mask });
+  }
+  return subnets;
+}
+
+/** Whether a dotted-quad address falls inside one of the allowed networks. */
+export function hostInAllowedSubnets(host: string, value?: string): boolean {
+  const address = ipv4ToInt(host);
+  if (address === null) return false;
+  return parseAllowedSubnets(value).some(({ base, mask }) => ((address & mask) >>> 0) === base);
+}

package/src/shared/icons.ts

@@ -0,0 +1,49 @@
+/**
+ * Icon path data, shared by the server-rendered login page and the React app.
+ *
+ * Each value is the inside of a 24x24 stroked `<svg>`; the wrapper differs
+ * between the two (a string on the Worker, a component in the browser) but the
+ * geometry should not.
+ */
+
+export const ICON_PATHS = {
+  monitor: '<rect x="2" y="3" width="20" height="14" rx="2"/><path d="M8 21h8M12 17v4"/>',
+  link: '<path d="M9 17H7A5 5 0 0 1 7 7h2M15 7h2a5 5 0 1 1 0 10h-2M8 12h8"/>',
+  power: '<path d="M12 2v10"/><path d="M18.4 6.6a9 9 0 1 1-12.8 0"/>',
+  maximize: '<path d="M8 3H5a2 2 0 0 0-2 2v3M21 8V5a2 2 0 0 0-2-2h-3M3 16v3a2 2 0 0 0 2 2h3M16 21h3a2 2 0 0 0 2-2v-3"/>',
+  minimize: '<path d="M8 3v3a2 2 0 0 1-2 2H3M21 8h-3a2 2 0 0 1-2-2V3M3 16h3a2 2 0 0 1 2 2v3M16 21v-3a2 2 0 0 1 2-2h3"/>',
+  keyboard: '<rect x="2" y="4" width="20" height="16" rx="2"/><path d="M6 8h.01M10 8h.01M14 8h.01M18 8h.01M8 12h.01M12 12h.01M16 12h.01M7 16h10"/>',
+  clipboard: '<rect x="8" y="2" width="8" height="4" rx="1"/><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/>',
+  check: '<path d="m5 13 4 4 10-10"/>',
+  camera: '<path d="M14.5 4h-5L7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3l-2.5-3z"/><circle cx="12" cy="13" r="3"/>',
+  eye: '<path d="M2 12s3.5-6 10-6 10 6 10 6-3.5 6-10 6S2 12 2 12z"/><circle cx="12" cy="12" r="3"/>',
+  sliders: '<path d="M4 21v-7M4 10V3M12 21v-9M12 8V3M20 21v-5M20 12V3M2 14h4M10 8h4M18 16h4"/>',
+  expand: '<path d="M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7"/>',
+  shield: '<path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/>',
+  chevron: '<path d="m6 9 6 6 6-6"/>',
+  back: '<path d="m15 18-6-6 6-6"/>',
+  zap: '<path d="M13 2 3 14h9l-1 8 10-12h-9l1-8z"/>',
+  cube: '<path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="m3.3 7 8.7 5 8.7-5M12 22V12"/>',
+  logout: '<path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/>',
+  clock: '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3.5 2"/>',
+  activity: '<path d="M22 12h-4l-3 9L9 3l-3 9H2"/>',
+  transfer: '<path d="m3 16 4 4 4-4M7 20V4M21 8l-4-4-4 4M17 4v16"/>',
+  screen: '<rect x="2" y="5" width="20" height="13" rx="2"/><path d="M7 21h10"/>',
+  command: '<path d="M15 6a3 3 0 1 1 3 3h-3zm0 0v12m0 0a3 3 0 1 0 3-3h-3zM9 6a3 3 0 1 0-3 3h3zm0 0v12m0 0a3 3 0 1 1-3-3h3z"/>',
+  apps: '<rect x="3" y="3" width="7" height="7" rx="1"/><rect x="14" y="3" width="7" height="7" rx="1"/><rect x="3" y="14" width="7" height="7" rx="1"/><rect x="14" y="14" width="7" height="7" rx="1"/>',
+  terminal: '<path d="m4 17 6-6-6-6M12 19h8"/>',
+  folder: '<path d="M3 7h6l2 2h10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/><path d="M3 7V6a2 2 0 0 1 2-2h4l2 3"/>',
+  close: '<path d="M18 6 6 18M6 6l12 12"/>',
+  sparkles: '<path d="m12 3 1.9 5.1L19 10l-5.1 1.9L12 17l-1.9-5.1L5 10l5.1-1.9L12 3z"/><path d="m19 15 .8 2.2 2.2.8-2.2.8L19 21l-.8-2.2-2.2-.8 2.2-.8z"/>',
+  broom: '<path d="M10 10V4a2 2 0 0 1 4 0v6"/><path d="M6 10h12a2 2 0 0 1 2 2v2H4v-2a2 2 0 0 1 2-2Z"/><path d="m5 14-2 7h18l-2-7M9 18l-1 3M15 18l1 3"/>',
+  panel: '<rect x="3" y="4" width="18" height="16" rx="2"/><path d="M14 4v16"/>',
+  menu: '<path d="M4 7h16M4 12h16M4 17h16"/>',
+  plus: '<path d="M12 5v14M5 12h14"/>',
+  star: '<path d="m12 3 2.9 5.9 6.5.9-4.7 4.6 1.1 6.5L12 17.8 6.2 20.9l1.1-6.5L2.6 9.8l6.5-.9L12 3z"/>',
+  trash: '<path d="M3 6h18M8 6V4a1 1 0 0 1 1-1h6a1 1 0 0 1 1 1v2M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/>',
+} as const;
+
+export type IconName = keyof typeof ICON_PATHS;
+
+/** The tab icon: a monitor in Cloudflare orange. */
+export const FAVICON_DATA_URI = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23f38020' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Crect x='2' y='3' width='20' height='14' rx='2'/%3E%3Cpath d='M8 21h8M12 17v4'/%3E%3C/svg%3E";

package/src/shared/protocol.ts

@@ -0,0 +1,55 @@
+/**
+ * The vocabulary both halves of the gateway share.
+ *
+ * The Worker and the browser have to agree on what a "protocol" is, what ports
+ * they default to and how an RDP security layer is named, so those live here
+ * rather than being re-declared on each side and drifting apart.
+ */
+
+/** A remote-desktop protocol the session workspace can display. */
+export const REMOTE_PROTOCOLS = ['vnc', 'rdp'] as const;
+export type RemoteProtocol = (typeof REMOTE_PROTOCOLS)[number];
+
+/** Every protocol the gateway relays, including the terminal side panel. */
+export const TRANSPORT_PROTOCOLS = ['vnc', 'rdp', 'ssh'] as const;
+export type TransportProtocol = (typeof TRANSPORT_PROTOCOLS)[number];
+
+/**
+ * The RDP security layer. `auto` negotiates with the host, which is right for
+ * anything that answers honestly; the rest are for hosts that do not.
+ */
+export const RDP_SECURITY_MODES = ['auto', 'nla', 'tls', 'rdp'] as const;
+export type RdpSecurity = (typeof RDP_SECURITY_MODES)[number];
+
+export const DEFAULT_PORTS: Record<TransportProtocol, number> = {
+  vnc: 5900,
+  rdp: 3389,
+  ssh: 22,
+};
+
+export const DEFAULT_SSH_PORT = DEFAULT_PORTS.ssh;
+
+export function isRemoteProtocol(value: unknown): value is RemoteProtocol {
+  return REMOTE_PROTOCOLS.includes(value as RemoteProtocol);
+}
+
+export function isRdpSecurity(value: unknown): value is RdpSecurity {
+  return RDP_SECURITY_MODES.includes(value as RdpSecurity);
+}
+
+/** Coerce anything to a protocol, falling back to what the caller opens on. */
+export function toRemoteProtocol(value: unknown, fallback: RemoteProtocol = 'vnc'): RemoteProtocol {
+  const wanted = String(value ?? '').toLowerCase();
+  return isRemoteProtocol(wanted) ? wanted : fallback;
+}
+
+export function toRdpSecurity(value: unknown, fallback: RdpSecurity = 'auto'): RdpSecurity {
+  const wanted = String(value ?? '').toLowerCase();
+  return isRdpSecurity(wanted) ? wanted : fallback;
+}
+
+/** A port number, or the protocol's default when the value is not one. */
+export function toPort(value: unknown, fallback: number): number {
+  const port = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : fallback;
+}

package/src/shared/signals.ts

@@ -0,0 +1,67 @@
+/**
+ * Control frames the browser and the gateway exchange on the WebSocket that
+ * carries a remote-desktop stream.
+ *
+ * They are plain strings precisely so they can never be confused with the
+ * binary protocol payload flowing in either direction, and both sides import
+ * these same literals so the two halves cannot drift apart.
+ */
+
+/** Browser -> gateway: "my WebSocket is open, you may start reading the host". */
+export const GATEWAY_READY_SIGNAL = 'VNC_GATEWAY_READY_v1';
+
+/**
+ * Browser -> gateway: keep the edge from idling out a silent session.
+ * Cloudflare closes a WebSocket with no traffic in either direction for 100s,
+ * and an untouched desktop transmits nothing at all.
+ */
+export const GATEWAY_KEEPALIVE_SIGNAL = 'VNC_GATEWAY_KEEPALIVE_v1';
+
+/**
+ * How often the browser nudges the transport. Well inside the edge's 100s
+ * window, so a session that is merely being looked at is never torn down
+ * without a close frame -- which is what a bare WebSocket 1006 used to mean.
+ */
+export const KEEPALIVE_INTERVAL_MS = 25_000;
+
+export const MAX_CLOSE_REASON_BYTES = 123;
+
+/** Whether a live desktop ended for a transient transport reason worth retrying. */
+export function isRetryableDisconnect(diagnostic: {
+  close: { code: number; reason: string } | null;
+  established: boolean;
+}): boolean {
+  if (!diagnostic.established || !diagnostic.close) return false;
+  if (diagnostic.close.code === 1006) return true;
+  return diagnostic.close.code === 1011
+    && /tcp|socket|network|host closed/i.test(diagnostic.close.reason);
+}
+
+/** WebSocket close reasons are capped at 123 bytes; trim without splitting a code point. */
+export function websocketCloseReason(reason: string): string {
+  const encoder = new TextEncoder();
+  if (encoder.encode(reason).byteLength <= MAX_CLOSE_REASON_BYTES) return reason;
+
+  let shortened = '';
+  for (const character of reason) {
+    if (encoder.encode(`${shortened}${character}…`).byteLength > MAX_CLOSE_REASON_BYTES) break;
+    shortened += character;
+  }
+  return `${shortened}…`;
+}
+
+/** 1005/1006/1015 are reserved and cannot be transmitted in a close frame. */
+export function sendableCloseCode(code: number): number {
+  return code === 1005 || code === 1006 || code === 1015 ? 1011 : code;
+}
+
+/** Normalize any WebSocket message payload to bytes. */
+export async function messageToBytes(data: unknown): Promise<Uint8Array | null> {
+  if (typeof data === 'string') return new TextEncoder().encode(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return null;
+}