airloom 0.1.0

package/dist/index.js

@@ -0,0 +1,1433 @@
+#!/usr/bin/env node
+
+// ../../packages/channel/src/channel.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// ../../packages/protocol/src/codec.ts
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function fromBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(str, "base64"));
+  }
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function encodeChannelMessage(msg) {
+  return new TextEncoder().encode(JSON.stringify(msg));
+}
+function decodeChannelMessage(data) {
+  const msg = JSON.parse(new TextDecoder().decode(data));
+  if (!msg || typeof msg !== "object" || typeof msg.type !== "string" || typeof msg.id !== "string") {
+    throw new Error("Invalid channel message: missing type or id field");
+  }
+  return msg;
+}
+function encodePairingData(data) {
+  return JSON.stringify(data);
+}
+function randomCode(length) {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  const limit = 256 - 256 % chars.length;
+  const result = [];
+  while (result.length < length) {
+    const bytes = getRandomBytes(length - result.length + 8);
+    for (const b of bytes) {
+      if (b >= limit) continue;
+      result.push(chars[b % chars.length]);
+      if (result.length === length) break;
+    }
+  }
+  return result.join("");
+}
+function getRandomBytes(length) {
+  const bytes = new Uint8Array(length);
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+    return bytes;
+  }
+  throw new Error("No crypto implementation available. Requires Node.js >= 18 or a browser with Web Crypto API.");
+}
+
+// ../../packages/crypto/src/keypair.ts
+import nacl from "tweetnacl";
+function generateKeyPair() {
+  return nacl.box.keyPair();
+}
+
+// ../../packages/crypto/src/encrypt.ts
+import nacl2 from "tweetnacl";
+var NONCE_LENGTH = 24;
+var TAG_LENGTH = 16;
+function encrypt(plaintext, key) {
+  const nonce = nacl2.randomBytes(NONCE_LENGTH);
+  const ciphertext = nacl2.secretbox(plaintext, nonce, key);
+  const sealed = new Uint8Array(NONCE_LENGTH + ciphertext.length);
+  sealed.set(nonce);
+  sealed.set(ciphertext, NONCE_LENGTH);
+  return sealed;
+}
+function decrypt(sealed, key) {
+  if (sealed.length < NONCE_LENGTH + TAG_LENGTH) {
+    throw new Error("Sealed data too short");
+  }
+  const nonce = sealed.slice(0, NONCE_LENGTH);
+  const ciphertext = sealed.slice(NONCE_LENGTH);
+  const plaintext = nacl2.secretbox.open(ciphertext, nonce, key);
+  if (!plaintext) {
+    throw new Error("Decryption failed - data may be tampered with");
+  }
+  return plaintext;
+}
+
+// ../../packages/crypto/src/pairing.ts
+import { sha256 } from "@noble/hashes/sha256";
+import { hkdf } from "@noble/hashes/hkdf";
+function createSession(relayUrl) {
+  const keyPair = generateKeyPair();
+  const pairingCode = randomCode(8);
+  const sessionToken = deriveSessionToken(pairingCode);
+  const pairingData = {
+    relay: relayUrl,
+    session: sessionToken,
+    pub: toBase64(keyPair.publicKey),
+    v: 1
+  };
+  return {
+    sessionToken,
+    pairingCode,
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.secretKey,
+    pairingData
+  };
+}
+function deriveSessionToken(pairingCode) {
+  const hash = sha256(new TextEncoder().encode(`airloom-session:${pairingCode}`));
+  return Array.from(hash.slice(0, 16), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function deriveEncryptionKey(sharedSecret, salt) {
+  const defaultSalt = new TextEncoder().encode("airloom-v1");
+  return hkdf(sha256, sharedSecret, salt ?? defaultSalt, "airloom-encryption", 32);
+}
+function formatPairingCode(code) {
+  if (code.length <= 4) return code;
+  return `${code.slice(0, 4)}-${code.slice(4)}`;
+}
+
+// ../../packages/channel/src/stream.ts
+import { EventEmitter } from "events";
+var WriteStream = class {
+  constructor(id, sendFn, meta) {
+    this.id = id;
+    this.sendFn = sendFn;
+    this.meta = meta;
+  }
+  _ended = false;
+  write(data) {
+    if (this._ended) throw new Error("Cannot write after stream has ended");
+    this.sendFn({ type: "stream_chunk", id: this.id, data });
+  }
+  end() {
+    if (this._ended) return;
+    this._ended = true;
+    this.sendFn({ type: "stream_end", id: this.id });
+  }
+  get ended() {
+    return this._ended;
+  }
+};
+var ReadStream = class extends EventEmitter {
+  id;
+  meta;
+  _ended = false;
+  constructor(id, meta) {
+    super();
+    this.id = id;
+    this.meta = meta;
+  }
+  /** @internal Called when a chunk arrives */
+  _pushChunk(data) {
+    if (!this._ended) this.emit("data", data);
+  }
+  /** @internal Called when the stream ends */
+  _end() {
+    if (this._ended) return;
+    this._ended = true;
+    this.emit("end");
+  }
+  get ended() {
+    return this._ended;
+  }
+};
+
+// ../../packages/channel/src/channel.ts
+var Channel = class extends EventEmitter2 {
+  adapter;
+  encryptionKey;
+  role;
+  streams = /* @__PURE__ */ new Map();
+  _ready = false;
+  msgCounter = 0;
+  constructor(opts) {
+    super();
+    this.adapter = opts.adapter;
+    this.encryptionKey = opts.encryptionKey ?? null;
+    this.role = opts.role;
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.adapter.onMessage((payload) => {
+      this.handlePayload(payload);
+    });
+    this.adapter.onPeerJoined(() => {
+      if (this.encryptionKey) {
+        this._ready = true;
+        this.emit("ready");
+      }
+    });
+    this.adapter.onPeerLeft(() => {
+      this._ready = false;
+      this.emit("peer_left");
+    });
+    this.adapter.onError((err) => this.emit("error", err));
+    this.adapter.onDisconnect(() => this.emit("disconnect"));
+  }
+  handlePayload(base64Payload) {
+    try {
+      if (!this.encryptionKey) {
+        this.emit("error", new Error("Received data but no encryption key"));
+        return;
+      }
+      const sealed = fromBase64(base64Payload);
+      const plaintext = decrypt(sealed, this.encryptionKey);
+      const msg = decodeChannelMessage(plaintext);
+      this.handleMessage(msg);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "message":
+        this.emit("message", msg.data);
+        break;
+      case "stream_start": {
+        const stream = new ReadStream(msg.id, msg.meta);
+        this.streams.set(msg.id, stream);
+        this.emit("stream", stream);
+        break;
+      }
+      case "stream_chunk": {
+        const stream = this.streams.get(msg.id);
+        if (stream) stream._pushChunk(msg.data);
+        break;
+      }
+      case "stream_end": {
+        const stream = this.streams.get(msg.id);
+        if (stream) {
+          stream._end();
+          this.streams.delete(msg.id);
+        }
+        break;
+      }
+    }
+  }
+  sendRaw(msg) {
+    if (!this.encryptionKey) throw new Error("No encryption key established");
+    const plaintext = encodeChannelMessage(msg);
+    const sealed = encrypt(plaintext, this.encryptionKey);
+    this.adapter.send(toBase64(sealed));
+  }
+  send(data) {
+    const id = `msg-${++this.msgCounter}`;
+    this.sendRaw({ type: "message", id, data });
+  }
+  createStream(meta) {
+    const id = `stream-${++this.msgCounter}`;
+    this.sendRaw({ type: "stream_start", id, meta });
+    return new WriteStream(id, (msg) => this.sendRaw(msg), meta);
+  }
+  async connect(sessionToken) {
+    await this.adapter.connect(sessionToken, this.role);
+  }
+  get ready() {
+    return this._ready;
+  }
+  waitForReady(timeoutMs = 3e4) {
+    if (this._ready) return Promise.resolve();
+    return new Promise((resolve2, reject) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.removeListener("ready", onReady);
+        this.removeListener("error", onError);
+        this.removeListener("disconnect", onDisconnect);
+      };
+      const onReady = () => {
+        cleanup();
+        resolve2();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const onDisconnect = () => {
+        cleanup();
+        reject(new Error("Disconnected before ready"));
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("Timed out waiting for peer"));
+      }, timeoutMs);
+      this.once("ready", onReady);
+      this.once("error", onError);
+      this.once("disconnect", onDisconnect);
+    });
+  }
+  close() {
+    for (const stream of this.streams.values()) stream._end();
+    this.streams.clear();
+    this.adapter.close();
+    this.removeAllListeners();
+  }
+};
+
+// ../../packages/channel/src/batcher.ts
+var Batcher = class {
+  buffer = "";
+  timer = null;
+  flushFn;
+  interval;
+  maxBytes;
+  _destroyed = false;
+  constructor(opts) {
+    this.interval = opts.interval ?? 500;
+    this.maxBytes = opts.maxBytes ?? 4096;
+    this.flushFn = opts.onFlush;
+  }
+  write(data) {
+    if (this._destroyed) return;
+    this.buffer += data;
+    if (this.buffer.length >= this.maxBytes) {
+      this.flush();
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => this.flush(), this.interval);
+    }
+  }
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer) {
+      const data = this.buffer;
+      this.buffer = "";
+      this.flushFn(data);
+    }
+  }
+  destroy() {
+    this._destroyed = true;
+    this.flush();
+  }
+};
+
+// ../../packages/channel/src/adapters/websocket.ts
+var WebSocketAdapter = class {
+  ws = null;
+  url;
+  _connected = false;
+  messageHandlers = [];
+  peerJoinedHandlers = [];
+  peerLeftHandlers = [];
+  errorHandlers = [];
+  disconnectHandlers = [];
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectTimer = null;
+  shouldReconnect = false;
+  sessionToken = null;
+  role = null;
+  constructor(url) {
+    this.url = url;
+  }
+  get connected() {
+    return this._connected;
+  }
+  async connect(sessionToken, role) {
+    this.sessionToken = sessionToken;
+    this.role = role;
+    return this.doConnect();
+  }
+  async doConnect() {
+    const ws = await this.createWebSocket(this.url);
+    return new Promise((resolve2, reject) => {
+      ws.onopen = () => {
+        this._connected = true;
+        this.shouldReconnect = true;
+        this.reconnectAttempts = 0;
+        const msg = this.role === "host" ? { type: "create", sessionToken: this.sessionToken } : { type: "join", sessionToken: this.sessionToken };
+        ws.send(JSON.stringify(msg));
+        resolve2();
+      };
+      ws.onmessage = (event) => {
+        const raw = event.data;
+        const data = typeof raw === "string" ? raw : typeof Buffer !== "undefined" && Buffer.isBuffer(raw) ? raw.toString("utf-8") : new TextDecoder().decode(raw);
+        try {
+          const msg = JSON.parse(data);
+          switch (msg.type) {
+            case "created":
+            case "joined":
+              break;
+            case "peer_joined":
+              this.peerJoinedHandlers.forEach((h) => h());
+              break;
+            case "peer_left":
+              this.peerLeftHandlers.forEach((h) => h());
+              break;
+            case "forward":
+              this.messageHandlers.forEach((h) => h(msg.payload));
+              break;
+            case "error":
+              this.errorHandlers.forEach((h) => h(new Error(msg.message)));
+              break;
+          }
+        } catch (err) {
+          this.errorHandlers.forEach((h) => h(err instanceof Error ? err : new Error(String(err))));
+        }
+      };
+      ws.onclose = () => {
+        const wasConnected = this._connected;
+        this._connected = false;
+        if (wasConnected) {
+          this.disconnectHandlers.forEach((h) => h());
+        }
+        if (this.shouldReconnect && !this.reconnectTimer) this.attemptReconnect();
+      };
+      ws.onerror = (err) => {
+        const error = err instanceof Error ? err : new Error("WebSocket error");
+        this.errorHandlers.forEach((h) => h(error));
+        if (!this._connected) {
+          this.shouldReconnect = false;
+          reject(error);
+        }
+      };
+      this.ws = ws;
+    });
+  }
+  async createWebSocket(url) {
+    if (typeof globalThis.WebSocket !== "undefined") {
+      return new globalThis.WebSocket(url);
+    }
+    try {
+      const { default: WS } = await import("ws");
+      return new WS(url);
+    } catch {
+      throw new Error('No WebSocket implementation available. Install the "ws" package for Node.js.');
+    }
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) return;
+    if (!this.sessionToken || !this.role) return;
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.doConnect().catch(() => {
+      });
+    }, delay);
+  }
+  send(payload) {
+    if (!this.ws || !this._connected) return;
+    this.ws.send(JSON.stringify({ type: "forward", payload }));
+  }
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  onPeerJoined(handler) {
+    this.peerJoinedHandlers.push(handler);
+  }
+  onPeerLeft(handler) {
+    this.peerLeftHandlers.push(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.push(handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  close() {
+    this.shouldReconnect = false;
+    this.maxReconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+    this.ws = null;
+    this._connected = false;
+  }
+};
+
+// ../../packages/channel/src/adapters/ably.ts
+import { Realtime } from "ably";
+var AblyAdapter = class {
+  ably = null;
+  channel = null;
+  opts;
+  _connected = false;
+  clientId = null;
+  messageHandlers = [];
+  peerJoinedHandlers = [];
+  peerLeftHandlers = [];
+  errorHandlers = [];
+  disconnectHandlers = [];
+  constructor(opts) {
+    if (!opts.key && !opts.token) throw new Error("Ably API key or token is required");
+    this.opts = opts;
+  }
+  get connected() {
+    return this._connected;
+  }
+  async connect(sessionToken, role) {
+    this.clientId = `airloom-${role}-${Date.now()}`;
+    const clientOpts = { clientId: this.clientId };
+    if (this.opts.key) {
+      clientOpts.key = this.opts.key;
+    } else {
+      clientOpts.token = this.opts.token;
+    }
+    this.ably = new Realtime(clientOpts);
+    await new Promise((resolve2, reject) => {
+      this.ably.connection.once("connected", () => resolve2());
+      this.ably.connection.once("failed", (stateChange) => {
+        reject(new Error(stateChange?.reason?.message ?? "Ably connection failed"));
+      });
+    });
+    this._connected = true;
+    this.ably.connection.on("disconnected", () => {
+      this._connected = false;
+      this.disconnectHandlers.forEach((h) => h());
+    });
+    this.ably.connection.on("connected", () => {
+      this._connected = true;
+      if (this.channel) {
+        this.channel.presence.get().then((members2) => {
+          const hasPeer2 = members2.some((m) => m.clientId !== this.clientId);
+          if (hasPeer2) this.peerJoinedHandlers.forEach((h) => h());
+        }).catch(() => {
+        });
+      }
+    });
+    this.ably.connection.on("failed", (stateChange) => {
+      this._connected = false;
+      const err = new Error(stateChange?.reason?.message ?? "Ably connection failed");
+      this.errorHandlers.forEach((h) => h(err));
+    });
+    this.channel = this.ably.channels.get(`airloom:${sessionToken}`);
+    this.channel.subscribe("forward", (msg) => {
+      if (msg.clientId === this.clientId) return;
+      if (typeof msg.data === "string") {
+        this.messageHandlers.forEach((h) => h(msg.data));
+      }
+    });
+    this.channel.presence.subscribe("enter", (member) => {
+      if (member.clientId !== this.clientId) {
+        this.peerJoinedHandlers.forEach((h) => h());
+      }
+    });
+    this.channel.presence.subscribe("leave", (member) => {
+      if (member.clientId !== this.clientId) {
+        this.peerLeftHandlers.forEach((h) => h());
+      }
+    });
+    await this.channel.presence.enter({ role });
+    const members = await this.channel.presence.get();
+    const hasPeer = members.some((m) => m.clientId !== this.clientId);
+    if (hasPeer) {
+      this.peerJoinedHandlers.forEach((h) => h());
+    }
+  }
+  send(payload) {
+    if (!this.channel || !this._connected) return;
+    this.channel.publish("forward", payload);
+  }
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  onPeerJoined(handler) {
+    this.peerJoinedHandlers.push(handler);
+  }
+  onPeerLeft(handler) {
+    this.peerLeftHandlers.push(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.push(handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  close() {
+    this.channel?.presence.leave().catch(() => {
+    });
+    this.channel?.detach().catch(() => {
+    });
+    try {
+      this.ably?.close();
+    } catch {
+    }
+    this.channel = null;
+    this.ably = null;
+    this._connected = false;
+  }
+};
+
+// src/index.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+import { networkInterfaces } from "os";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
+import QRCode from "qrcode";
+
+// src/server.ts
+import express from "express";
+import { createServer } from "http";
+import { existsSync } from "fs";
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/adapters/anthropic.ts
+var AnthropicAdapter = class {
+  name = "anthropic";
+  model;
+  apiKey;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("API key is required for Anthropic adapter");
+    this.apiKey = config.apiKey;
+    this.model = config.model || "claude-sonnet-4-20250514";
+  }
+  async streamResponse(messages, stream) {
+    const systemMsg = messages.find((m) => m.role === "system")?.content;
+    const chatMsgs = messages.filter((m) => m.role !== "system");
+    const body = {
+      model: this.model,
+      max_tokens: 4096,
+      stream: true,
+      messages: chatMsgs
+    };
+    if (systemMsg) body.system = systemMsg;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      stream.write(`[Error: ${response.status} ${error}]`);
+      stream.end();
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      stream.write("[Error: No response body]");
+      stream.end();
+      return;
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          try {
+            const event = JSON.parse(data);
+            if (event.type === "content_block_delta" && event.delta?.text) {
+              stream.write(event.delta.text);
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      stream.end();
+    }
+  }
+};
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class {
+  name = "openai";
+  model;
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("API key is required for OpenAI adapter");
+    this.apiKey = config.apiKey;
+    this.model = config.model || "gpt-4o";
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+  }
+  async streamResponse(messages, stream) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({ model: this.model, stream: true, messages })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      stream.write(`[Error: ${response.status} ${error}]`);
+      stream.end();
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      stream.write("[Error: No response body]");
+      stream.end();
+      return;
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          try {
+            const event = JSON.parse(data);
+            const content = event.choices?.[0]?.delta?.content;
+            if (content) stream.write(content);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      stream.end();
+    }
+  }
+};
+
+// src/adapters/cli.ts
+import { spawn } from "child_process";
+var CLI_PRESETS = [
+  {
+    id: "devin",
+    name: "Devin",
+    command: "devin --permission-mode dangerous -p --",
+    description: "Devin CLI in non-interactive print mode"
+  },
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    command: "claude -p --output-format text",
+    description: "Claude Code in print mode"
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    command: "codex exec --full-auto",
+    description: "OpenAI Codex CLI in non-interactive exec mode"
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    command: "aider --yes --no-auto-commits --message",
+    description: "Aider in scripting mode (prompt via --message)"
+  },
+  {
+    id: "custom",
+    name: "Custom",
+    command: "",
+    description: "Custom command \u2014 prompt appended as last argument"
+  }
+];
+var CLIAdapter = class {
+  name = "cli";
+  model;
+  command;
+  args;
+  constructor(config) {
+    if (!config.command) throw new Error("Command is required for CLI adapter");
+    const parts = config.command.split(" ");
+    this.command = parts[0];
+    this.args = parts.slice(1);
+    this.model = config.model || config.command;
+  }
+  async streamResponse(messages, stream) {
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+    if (!lastUserMsg) {
+      stream.write("[No user message provided]");
+      stream.end();
+      return;
+    }
+    return new Promise((resolve2) => {
+      const args = [...this.args, lastUserMsg.content];
+      const proc = spawn(this.command, args, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+      proc.stdin.end();
+      proc.stdout.on("data", (data) => stream.write(stripAnsi(data.toString())));
+      proc.stderr.on("data", (data) => stream.write(stripAnsi(data.toString())));
+      proc.on("close", () => {
+        stream.end();
+        resolve2();
+      });
+      proc.on("error", (err) => {
+        stream.write(`[Error: ${err.message}]`);
+        stream.end();
+        resolve2();
+      });
+    });
+  }
+};
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "airloom");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data.type) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  } catch (err) {
+    console.error("[config] Failed to save:", err.message);
+  }
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+// src/server.ts
+var MAX_MESSAGES = 200;
+function trimMessages(messages) {
+  if (messages.length > MAX_MESSAGES) messages.splice(0, messages.length - MAX_MESSAGES);
+}
+var aiLock = Promise.resolve();
+function enqueueAIResponse(channel, adapter, state, broadcast) {
+  aiLock = aiLock.then(() => handleAIResponse(channel, adapter, state, broadcast)).catch((err) => console.error("[host] AI response error:", err));
+}
+function createHostServer(opts) {
+  const app = express();
+  const server = createServer(app);
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  const uiClients = /* @__PURE__ */ new Set();
+  app.use(express.json());
+  app.get("/", (_req, res) => {
+    res.type("html").send(HOST_HTML);
+  });
+  if (opts.viewerDir && existsSync(opts.viewerDir)) {
+    app.use("/viewer", express.static(opts.viewerDir));
+  }
+  app.get("/api/status", (_req, res) => {
+    res.json({
+      connected: opts.state.connected,
+      pairingCode: opts.state.pairingCode,
+      pairingQR: opts.state.pairingQR,
+      relayUrl: opts.state.relayUrl,
+      adapter: opts.state.adapter ? { name: opts.state.adapter.name, model: opts.state.adapter.model } : null,
+      messages: opts.state.messages
+    });
+  });
+  app.get("/api/cli-presets", (_req, res) => {
+    res.json(CLI_PRESETS);
+  });
+  app.get("/api/config", (_req, res) => {
+    const saved = loadConfig();
+    res.json({
+      saved,
+      envKeys: {
+        anthropic: !!process.env.ANTHROPIC_API_KEY,
+        openai: !!process.env.OPENAI_API_KEY
+      }
+    });
+  });
+  app.post("/api/configure", (req, res) => {
+    const { type, apiKey, model, command, preset } = req.body;
+    try {
+      switch (type) {
+        case "anthropic": {
+          const key = apiKey || process.env.ANTHROPIC_API_KEY;
+          if (!key) {
+            res.status(400).json({ error: "API key required (or set ANTHROPIC_API_KEY env var)" });
+            return;
+          }
+          opts.state.adapter = new AnthropicAdapter({ apiKey: key, model });
+          break;
+        }
+        case "openai": {
+          const key = apiKey || process.env.OPENAI_API_KEY;
+          if (!key) {
+            res.status(400).json({ error: "API key required (or set OPENAI_API_KEY env var)" });
+            return;
+          }
+          opts.state.adapter = new OpenAIAdapter({ apiKey: key, model });
+          break;
+        }
+        case "cli": {
+          const cmd = command || process.env.AIRLOOM_CLI_COMMAND;
+          if (!cmd) {
+            res.status(400).json({ error: "CLI adapter requires a command (or set AIRLOOM_CLI_COMMAND env var)" });
+            return;
+          }
+          opts.state.adapter = new CLIAdapter({ command: cmd, model });
+          break;
+        }
+        default:
+          res.status(400).json({ error: "Unknown adapter type" });
+          return;
+      }
+      const cfg = { type };
+      if (model) cfg.model = model;
+      if (type === "cli") {
+        cfg.command = command;
+        cfg.preset = preset;
+      }
+      saveConfig(cfg);
+      broadcast({ type: "configured", adapter: { name: opts.state.adapter.name, model: opts.state.adapter.model } });
+      res.json({ ok: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Configuration failed";
+      res.status(400).json({ error: message });
+    }
+  });
+  app.post("/api/send", async (req, res) => {
+    const { content } = req.body;
+    if (!content) {
+      res.status(400).json({ error: "No content" });
+      return;
+    }
+    opts.state.messages.push({ role: "user", content, timestamp: Date.now() });
+    trimMessages(opts.state.messages);
+    broadcast({ type: "message", role: "user", content });
+    if (opts.state.adapter && opts.state.channel) {
+      enqueueAIResponse(opts.state.channel, opts.state.adapter, opts.state, broadcast);
+    }
+    res.json({ ok: true });
+  });
+  wss.on("connection", (ws) => {
+    uiClients.add(ws);
+    ws.on("close", () => uiClients.delete(ws));
+  });
+  function broadcast(data) {
+    const msg = JSON.stringify(data);
+    for (const ws of uiClients) {
+      if (ws.readyState === WebSocket.OPEN) ws.send(msg);
+    }
+  }
+  return new Promise((resolve2) => {
+    server.listen(opts.port, "0.0.0.0", () => {
+      const addr = server.address();
+      const actualPort = typeof addr === "object" && addr ? addr.port : opts.port;
+      resolve2({ server, broadcast, port: actualPort });
+    });
+    server.on("error", (err) => {
+      console.error(`[host] Server error: ${err.message}`);
+      process.exit(1);
+    });
+  });
+}
+async function handleAIResponse(channel, adapter, state, broadcast) {
+  const stream = channel.createStream({ model: adapter.model });
+  let fullResponse = "";
+  const batcher = new Batcher({
+    interval: 100,
+    onFlush: (data) => broadcast({ type: "stream_chunk", data })
+  });
+  const origWrite = stream.write.bind(stream);
+  stream.write = (data) => {
+    fullResponse += data;
+    batcher.write(data);
+    origWrite(data);
+  };
+  const origEnd = stream.end.bind(stream);
+  stream.end = () => {
+    batcher.flush();
+    broadcast({ type: "stream_end" });
+    state.messages.push({ role: "assistant", content: fullResponse, timestamp: Date.now() });
+    trimMessages(state.messages);
+    origEnd();
+  };
+  try {
+    await adapter.streamResponse(state.messages, stream);
+  } catch (err) {
+    if (!stream.ended) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      stream.write(`[Error: ${message}]`);
+      stream.end();
+    }
+    batcher.destroy();
+  }
+}
+var HOST_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Airloom - Host</title>
+<style>
+  *{margin:0;padding:0;box-sizing:border-box}
+  body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;background:#0a0a0a;color:#e0e0e0;min-height:100vh}
+  .container{max-width:800px;margin:0 auto;padding:20px}
+  .page-header{display:flex;align-items:center;gap:12px;margin-bottom:20px}
+  .page-header svg{width:36px;height:36px;flex-shrink:0}
+  .page-header h1{font-size:1.5rem;color:#7c8aff}
+  h2{font-size:1.1rem;margin-bottom:12px;color:#a0a0a0}
+  .card{background:#1a1a1a;border:1px solid #2a2a2a;border-radius:12px;padding:20px;margin-bottom:16px}
+  .status{display:flex;align-items:center;gap:8px;margin-bottom:8px}
+  .dot{width:8px;height:8px;border-radius:50%}
+  .dot.on{background:#4caf50} .dot.off{background:#f44336} .dot.wait{background:#ff9800;animation:pulse 1.5s infinite}
+  @keyframes pulse{0%,100%{opacity:1}50%{opacity:.4}}
+  .pairing{text-align:center}
+  .pairing img{max-width:200px;margin:16px auto;display:block;border-radius:8px}
+  .pairing-code{font-family:monospace;font-size:2rem;letter-spacing:4px;color:#7c8aff;margin:12px 0}
+  .config-form{display:flex;flex-direction:column;gap:12px}
+  select,input,button{padding:10px 14px;border-radius:8px;border:1px solid #333;background:#111;color:#e0e0e0;font-size:.95rem}
+  select:focus,input:focus{outline:none;border-color:#7c8aff}
+  button{background:#7c8aff;color:#fff;border:none;cursor:pointer;font-weight:600}
+  button:hover{background:#6b79ee}
+  .messages{max-height:400px;overflow-y:auto;display:flex;flex-direction:column;gap:8px;margin-bottom:12px}
+  .msg{padding:10px 14px;border-radius:10px;max-width:85%;word-break:break-word;font-size:.9rem;line-height:1.5}
+  .msg.user{background:#2a3a6a;align-self:flex-end;white-space:pre-wrap}
+  .msg.assistant{background:#1e1e1e;border:1px solid #2a2a2a;align-self:flex-start}
+  .msg.assistant p{margin:0 0 .5em}.msg.assistant p:last-child{margin-bottom:0}
+  .msg.assistant h1,.msg.assistant h2,.msg.assistant h3,.msg.assistant h4,.msg.assistant h5,.msg.assistant h6{font-size:.95rem;font-weight:600;margin:.6em 0 .3em;color:#e0e0e0}
+  .msg.assistant h1{font-size:1.05rem}.msg.assistant h2{font-size:1rem}
+  .msg.assistant ul,.msg.assistant ol{margin:.3em 0;padding-left:1.4em}.msg.assistant li{margin:.15em 0}
+  .msg.assistant a{color:#7c8aff;text-decoration:underline}
+  .msg.assistant code{font-family:'SF Mono',Menlo,Consolas,monospace;font-size:.82rem;background:rgba(255,255,255,.07);padding:1px 5px;border-radius:4px}
+  .msg.assistant pre{margin:.5em 0;padding:10px 12px;border-radius:8px;background:#111;overflow-x:auto}
+  .msg.assistant pre code{background:none;padding:0;font-size:.8rem;line-height:1.5;white-space:pre;display:block}
+  .msg.assistant blockquote{margin:.4em 0;padding:4px 12px;border-left:3px solid #2a2a2a;color:#888}
+  .msg.assistant table{border-collapse:collapse;margin:.4em 0;font-size:.82rem}
+  .msg.assistant th,.msg.assistant td{border:1px solid #2a2a2a;padding:4px 8px}
+  .msg.assistant th{background:rgba(255,255,255,.05)}
+  .msg.assistant hr{border:none;border-top:1px solid #2a2a2a;margin:.5em 0}
+  .msg.typing{display:flex;align-items:center;gap:5px;padding:14px 18px}
+  .msg.typing .dot{width:7px;height:7px;border-radius:50%;background:#888;animation:dot-pulse 1.4s ease-in-out infinite}
+  .msg.typing .dot:nth-child(2){animation-delay:.2s}
+  .msg.typing .dot:nth-child(3){animation-delay:.4s}
+  @keyframes dot-pulse{0%,80%,100%{opacity:.25;transform:scale(.8)}40%{opacity:1;transform:scale(1)}}
+  .input-area{display:flex;gap:8px}
+  .input-area textarea{flex:1;resize:none;min-height:44px;max-height:120px;padding:10px 14px;border-radius:8px;border:1px solid #333;background:#111;color:#e0e0e0;font-family:inherit;font-size:.9rem}
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="page-header">
+    <svg viewBox="0 0 100 100" fill="none"><defs><linearGradient id="lg" x1=".3" y1="0" x2=".7" y2="1"><stop stop-color="#a0aaff"/><stop offset="1" stop-color="#6070ef"/></linearGradient></defs><g stroke="url(#lg)" stroke-width="6" stroke-linecap="round"><line x1="22" y1="88" x2="31" y2="64"/><line x1="36" y1="52" x2="50" y2="15"/><line x1="9" y1="58" x2="59.5" y2="58"/><line x1="73.5" y1="58" x2="91" y2="58"/><line x1="50" y1="15" x2="78" y2="88"/></g></svg>
+    <h1>Airloom</h1>
+  </div>
+  <div class="card">
+    <div class="status"><div class="dot wait" id="dot"></div><span id="statusText">Initializing...</span></div>
+  </div>
+  <div class="card" id="configCard">
+    <h2>AI Configuration</h2>
+    <div class="config-form">
+      <select id="adapterType"><option value="anthropic">Anthropic (Claude)</option><option value="openai">OpenAI (GPT)</option><option value="cli">CLI Tool</option></select>
+      <input type="password" id="apiKey" placeholder="API Key"/>
+      <input type="text" id="model" placeholder="Model (optional)"/>
+      <div id="cliConfig" style="display:none">
+        <select id="cliPreset" style="margin-bottom:8px"></select>
+        <input type="text" id="command" placeholder="CLI command (prompt appended as last arg)"/>
+        <p style="color:#666;font-size:.8rem;margin-top:4px" id="presetDesc"></p>
+      </div>
+      <button onclick="configure()">Configure</button>
+    </div>
+  </div>
+  <div class="card pairing" id="pairingCard" style="display:none">
+    <h2>Connect Your Phone</h2>
+    <img id="qrCode" alt="QR Code"/>
+    <div class="pairing-code" id="pairingCode"></div>
+    <p style="color:#888;font-size:.85rem">Scan QR or enter code in viewer</p>
+  </div>
+  <div class="card" id="chatCard" style="display:none">
+    <h2>Conversation</h2>
+    <div class="messages" id="messages"></div>
+    <div class="input-area">
+      <textarea id="msgInput" placeholder="Type a message..." onkeydown="if(event.key==='Enter'&&!event.shiftKey){event.preventDefault();sendMsg()}"></textarea>
+      <button onclick="sendMsg()">Send</button>
+    </div>
+  </div>
+</div>
+<script src="https://cdn.jsdelivr.net/npm/marked@15/marked.min.js"></script>
+<script>
+if(typeof marked!=='undefined'){marked.setOptions({gfm:true,breaks:true})}
+function renderMd(t){try{return typeof marked!=='undefined'?marked.parse(t):'<pre>'+t.replace(/</g,'&lt;')+'</pre>'}catch{return '<pre>'+t.replace(/</g,'&lt;')+'</pre>'}}
+const ws=new WebSocket((location.protocol==='https:'?'wss://':'ws://')+location.host+'/ws');
+let curResp='',streamEl=null,cliPresets=[];
+// Load CLI presets
+fetch('/api/cli-presets').then(r=>r.json()).then(presets=>{
+  cliPresets=presets;
+  const sel=document.getElementById('cliPreset');
+  presets.forEach(p=>{const o=document.createElement('option');o.value=p.id;o.textContent=p.name;sel.appendChild(o)});
+  sel.addEventListener('change',()=>{
+    const p=cliPresets.find(x=>x.id===sel.value);
+    if(p){document.getElementById('command').value=p.command;document.getElementById('presetDesc').textContent=p.description;document.getElementById('command').style.display=p.id==='custom'?'':''}
+  });
+  if(presets.length){sel.dispatchEvent(new Event('change'))}
+  // After presets are loaded, restore saved config
+  return fetch('/api/config').then(r=>r.json());
+}).then(cfg=>{
+  if(!cfg) return;
+  const {saved,envKeys}=cfg;
+  if(saved){
+    document.getElementById('adapterType').value=saved.type;
+    document.getElementById('adapterType').dispatchEvent(new Event('change'));
+    if(saved.model) document.getElementById('model').value=saved.model;
+    if(saved.type==='cli'){
+      if(saved.preset){document.getElementById('cliPreset').value=saved.preset;document.getElementById('cliPreset').dispatchEvent(new Event('change'))}
+      if(saved.command) document.getElementById('command').value=saved.command;
+    }
+  }
+  // Show hints for env-var API keys
+  if(envKeys.anthropic) document.getElementById('apiKey').placeholder='API Key (ANTHROPIC_API_KEY set)';
+  if(envKeys.openai&&(!saved||saved.type==='openai')) document.getElementById('apiKey').placeholder='API Key (OPENAI_API_KEY set)';
+}).catch(()=>{});
+document.getElementById('adapterType').addEventListener('change',e=>{
+  const cli=e.target.value==='cli';
+  document.getElementById('apiKey').style.display=cli?'none':'';
+  document.getElementById('model').style.display=cli?'none':'';
+  document.getElementById('cliConfig').style.display=cli?'':'none';
+});
+ws.onmessage=e=>{
+  const d=JSON.parse(e.data);
+  if(d.type==='message'){addMsg(d.role,d.content);if(d.role==='user'){streamEl=addMsg('assistant','');streamEl.classList.add('typing');streamEl.innerHTML='<span class="dot"></span><span class="dot"></span><span class="dot"></span>';curResp=''}}
+  else if(d.type==='stream_chunk'){if(!streamEl){streamEl=addMsg('assistant','');streamEl.classList.add('typing');streamEl.innerHTML='<span class="dot"></span><span class="dot"></span><span class="dot"></span>'}curResp+=d.data;const trimmed=curResp.trimStart();if(trimmed){if(streamEl.classList.contains('typing'))streamEl.classList.remove('typing');streamEl.innerHTML=renderMd(trimmed)}streamEl.scrollIntoView({block:'end'})}
+  else if(d.type==='stream_end'){streamEl=null;curResp=''}
+  else if(d.type==='configured'){document.getElementById('statusText').textContent='Configured: '+d.adapter.name+' ('+d.adapter.model+')'}
+  else if(d.type==='peer_connected'){document.getElementById('dot').className='dot on';document.getElementById('statusText').textContent='Phone connected';document.getElementById('chatCard').style.display=''}
+  else if(d.type==='peer_disconnected'){document.getElementById('dot').className='dot wait';document.getElementById('statusText').textContent='Phone disconnected'}
+};
+fetch('/api/status').then(r=>r.json()).then(d=>{
+  if(d.pairingCode){document.getElementById('pairingCard').style.display='';document.getElementById('pairingCode').textContent=d.pairingCode;if(d.pairingQR)document.getElementById('qrCode').src=d.pairingQR}
+  if(d.connected){document.getElementById('dot').className='dot on';document.getElementById('statusText').textContent='Phone connected';document.getElementById('chatCard').style.display=''}
+  else{document.getElementById('dot').className='dot wait';document.getElementById('statusText').textContent='Waiting for phone...'}
+  if(d.adapter)document.getElementById('statusText').textContent+=' | '+d.adapter.name;
+  if(d.messages)d.messages.forEach(m=>addMsg(m.role,m.content));
+});
+async function configure(){
+  const r=await fetch('/api/configure',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({type:document.getElementById('adapterType').value,apiKey:document.getElementById('apiKey').value,model:document.getElementById('model').value,command:document.getElementById('command').value,preset:document.getElementById('cliPreset').value})});
+  const d=await r.json();if(d.error)alert(d.error);
+}
+async function sendMsg(){
+  const el=document.getElementById('msgInput'),c=el.value.trim();if(!c)return;el.value='';
+  await fetch('/api/send',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({content:c})});
+}
+function addMsg(role,content){const el=document.createElement('div');el.className='msg '+role;if(role==='user'||!content){el.textContent=content}else{el.innerHTML=renderMd(content)}document.getElementById('messages').appendChild(el);el.scrollIntoView({block:'end'});return el}
+</script>
+</body>
+</html>`;
+
+// src/index.ts
+function parseArgs(argv) {
+  const args = {};
+  const rest = argv.slice(2);
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--help" || a === "-h") {
+      args.help = true;
+    } else if (a === "--cli" && i + 1 < rest.length) {
+      args.cli = rest[++i];
+    } else if (a === "--preset" && i + 1 < rest.length) {
+      args.preset = rest[++i];
+    } else if (a === "--port" && i + 1 < rest.length) {
+      args.port = parseInt(rest[++i], 10);
+    } else if (a.startsWith("--cli=")) {
+      args.cli = a.slice(6);
+    } else if (a.startsWith("--preset=")) {
+      args.preset = a.slice(9);
+    } else if (a.startsWith("--port=")) {
+      args.port = parseInt(a.slice(7), 10);
+    }
+  }
+  return args;
+}
+function printHelp() {
+  const presetList = CLI_PRESETS.filter((p) => p.id !== "custom").map((p) => `    ${p.id.padEnd(14)} ${p.command}`).join("\n");
+  console.log(`
+Airloom \u2014 Run AI on your computer, control it from your phone.
+
+Usage:
+  airloom [options]
+
+Options:
+  --cli <command>     CLI command to use as the AI adapter.
+                      The user's message is appended as the last argument.
+                      Example: airloom --cli "devin -p --"
+
+  --preset <name>     Use a built-in CLI preset instead of --cli.
+                      Available presets:
+${presetList}
+
+  --port <number>     Port for the host web UI (default: auto-select).
+
+  -h, --help          Show this help message.
+
+Environment variables:
+  ANTHROPIC_API_KEY   API key for the Anthropic adapter.
+  OPENAI_API_KEY      API key for the OpenAI adapter.
+  ABLY_API_KEY        Your own Ably key (overrides default community relay).
+  RELAY_URL           Self-hosted WebSocket relay URL (disables Ably).
+  HOST_PORT           Same as --port (CLI flag takes precedence).
+`.trimStart());
+}
+var cliArgs = parseArgs(process.argv);
+if (cliArgs.help) {
+  printHelp();
+  process.exit(0);
+}
+var DEFAULT_ABLY_KEY = "SfHSAQ.IRTOQQ:FBbi9a7ZV6jIu0Gdo_UeYhIN4rzpMrud5-LldURNh9s";
+var RELAY_URL = process.env.RELAY_URL;
+var ABLY_API_KEY = process.env.ABLY_API_KEY ?? (RELAY_URL ? void 0 : DEFAULT_ABLY_KEY);
+var ABLY_TOKEN_TTL = parseInt(process.env.ABLY_TOKEN_TTL ?? String(24 * 60 * 60 * 1e3), 10);
+var HOST_PORT = cliArgs.port ?? parseInt(process.env.HOST_PORT ?? "0", 10);
+var useAbly = !!ABLY_API_KEY;
+var isDefaultKey = useAbly && ABLY_API_KEY === DEFAULT_ABLY_KEY;
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getLanIP() {
+  for (const ifaces of Object.values(networkInterfaces())) {
+    for (const iface of ifaces ?? []) {
+      if (iface.family === "IPv4" && !iface.internal) return iface.address;
+    }
+  }
+  return void 0;
+}
+function resolveViewerDir() {
+  const prod = resolve(__dirname, "viewer");
+  if (existsSync2(prod)) return prod;
+  const dev = resolve(__dirname, "../../viewer/dist");
+  if (existsSync2(dev)) return dev;
+  return void 0;
+}
+async function main() {
+  console.log("Airloom - Host");
+  console.log("==============\n");
+  if (useAbly) {
+    if (isDefaultKey) {
+      console.log("Transport: Ably (community relay \u2014 shared quota)");
+      console.log("  Set ABLY_API_KEY for your own quota, or RELAY_URL for self-hosted.\n");
+    } else {
+      console.log("Transport: Ably (your key)");
+    }
+  } else {
+    console.log(`Transport: WebSocket (self-hosted relay at ${RELAY_URL})`);
+  }
+  const session = createSession(useAbly ? "ably" : RELAY_URL);
+  const displayCode = formatPairingCode(session.pairingCode);
+  let pairingData;
+  if (useAbly) {
+    const { Rest } = await import("ably");
+    const rest = new Rest({ key: ABLY_API_KEY });
+    const channelName = `airloom:${session.sessionToken}`;
+    const tokenDetails = await rest.auth.requestToken({
+      clientId: "*",
+      // viewer picks its own clientId
+      capability: { [channelName]: ["publish", "subscribe", "presence"] },
+      ttl: ABLY_TOKEN_TTL
+    });
+    console.log(`[ably] Scoped token issued (TTL: ${Math.round(ABLY_TOKEN_TTL / 6e4)}min, channel: ${channelName})`);
+    pairingData = {
+      ...session.pairingData,
+      transport: "ably",
+      token: tokenDetails.token
+    };
+  } else {
+    pairingData = { ...session.pairingData };
+  }
+  const pairingJSON = encodePairingData(pairingData);
+  const keyMaterial = sha2562(new TextEncoder().encode("airloom-key:" + session.sessionToken));
+  const encryptionKey = deriveEncryptionKey(keyMaterial);
+  let adapter;
+  if (useAbly) {
+    adapter = new AblyAdapter({ key: ABLY_API_KEY });
+  } else {
+    adapter = new WebSocketAdapter(RELAY_URL);
+  }
+  const channel = new Channel({
+    adapter,
+    role: "host",
+    encryptionKey
+  });
+  await channel.connect(session.sessionToken);
+  console.log("[host] Connected to relay, waiting for phone...");
+  const state = {
+    channel,
+    adapter: null,
+    pairingCode: displayCode,
+    pairingQR: "",
+    // set after server starts
+    relayUrl: useAbly ? "ably" : RELAY_URL,
+    connected: false,
+    messages: []
+  };
+  if (cliArgs.cli || cliArgs.preset) {
+    let command = cliArgs.cli;
+    if (!command && cliArgs.preset) {
+      const preset = CLI_PRESETS.find((p) => p.id === cliArgs.preset);
+      if (!preset) {
+        console.error(`[host] Unknown preset "${cliArgs.preset}". Available: ${CLI_PRESETS.map((p) => p.id).join(", ")}`);
+        process.exit(1);
+      }
+      command = preset.command;
+    }
+    if (command) {
+      state.adapter = new CLIAdapter({ command });
+      console.log(`[host] CLI adapter: ${command}`);
+    }
+  } else {
+    const saved = loadConfig();
+    if (saved) {
+      try {
+        switch (saved.type) {
+          case "anthropic": {
+            const key = process.env.ANTHROPIC_API_KEY;
+            if (key) {
+              state.adapter = new AnthropicAdapter({ apiKey: key, model: saved.model });
+            }
+            break;
+          }
+          case "openai": {
+            const key = process.env.OPENAI_API_KEY;
+            if (key) {
+              state.adapter = new OpenAIAdapter({ apiKey: key, model: saved.model });
+            }
+            break;
+          }
+          case "cli": {
+            const cmd = saved.command || process.env.AIRLOOM_CLI_COMMAND;
+            if (cmd) {
+              state.adapter = new CLIAdapter({ command: cmd, model: saved.model });
+            }
+            break;
+          }
+        }
+        if (state.adapter) {
+          console.log(`[host] Auto-configured: ${state.adapter.name} (${state.adapter.model})`);
+          console.log(`  Loaded from ${getConfigPath()}`);
+        }
+      } catch (err) {
+        console.error("[host] Auto-configure failed:", err.message);
+      }
+    }
+  }
+  const viewerDir = resolveViewerDir();
+  if (viewerDir) {
+    console.log(`[host] Viewer files: ${viewerDir}`);
+  } else {
+    console.log("[host] Viewer dist not found \u2014 QR will open raw JSON fallback");
+  }
+  const { server, broadcast, port } = await createHostServer({ port: HOST_PORT, state, viewerDir });
+  const lanIP = getLanIP();
+  const host = lanIP ?? "localhost";
+  const baseUrl = `http://${host}:${port}`;
+  let qrContent;
+  if (viewerDir) {
+    const pairingBase64 = Buffer.from(pairingJSON).toString("base64url");
+    qrContent = `${baseUrl}/viewer/#${pairingBase64}`;
+  } else {
+    qrContent = pairingJSON;
+  }
+  const qrDataUrl = await QRCode.toDataURL(qrContent, { width: 300, margin: 2 });
+  const qrTerminal = await QRCode.toString(qrContent, { type: "terminal", small: true });
+  state.pairingQR = qrDataUrl;
+  console.log("\nPairing QR Code:");
+  console.log(qrTerminal);
+  console.log(`Pairing Code: ${displayCode}`);
+  if (viewerDir && lanIP) {
+    console.log(`Viewer URL: ${qrContent}`);
+  }
+  if (!useAbly) console.log(`Relay: ${RELAY_URL}`);
+  const localUrl = `http://localhost:${port}`;
+  console.log(`[host] Web UI at ${localUrl}
+`);
+  import("child_process").then(({ exec }) => {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    exec(`${cmd} ${localUrl}`);
+  }).catch(() => {
+  });
+  channel.on("ready", () => {
+    console.log("[host] Phone connected! Channel ready.");
+    state.connected = true;
+    broadcast({ type: "peer_connected" });
+  });
+  channel.on("peer_left", () => {
+    console.log("[host] Phone disconnected.");
+    state.connected = false;
+    broadcast({ type: "peer_disconnected" });
+  });
+  channel.on("message", (data) => {
+    if (typeof data === "object" && data !== null && "type" in data && "content" in data) {
+      const msg = data;
+      if (msg.type === "chat" && typeof msg.content === "string") {
+        console.log(`[phone] ${msg.content}`);
+        state.messages.push({ role: "user", content: msg.content, timestamp: Date.now() });
+        broadcast({ type: "message", role: "user", content: msg.content });
+        if (state.adapter) {
+          enqueueAIResponse(channel, state.adapter, state, broadcast);
+        }
+      }
+    }
+  });
+  channel.on("error", (err) => console.error("[host] Channel error:", err.message));
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log("\n[host] Shutting down...");
+    try {
+      channel.close();
+    } catch {
+    }
+    server.close(() => process.exit(0));
+    setTimeout(() => process.exit(0), 1e3).unref();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});