pubblue 0.3.0 → 0.4.1

package/dist/chunk-56IKFMJ2.js

@@ -0,0 +1,40 @@
+// src/lib/bridge-protocol.ts
+var CONTROL_CHANNEL = "_control";
+var CHANNELS = {
+  CHAT: "chat",
+  CANVAS: "canvas",
+  AUDIO: "audio",
+  MEDIA: "media",
+  FILE: "file"
+};
+var idCounter = 0;
+function generateMessageId() {
+  const ts = Date.now().toString(36);
+  const seq = (idCounter++).toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${ts}-${seq}-${rand}`;
+}
+function encodeMessage(msg) {
+  return JSON.stringify(msg);
+}
+function decodeMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.id === "string" && typeof parsed.type === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var MAX_TUNNEL_EXPIRY_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_TUNNEL_EXPIRY_MS = 24 * 60 * 60 * 1e3;
+
+export {
+  CONTROL_CHANNEL,
+  CHANNELS,
+  generateMessageId,
+  encodeMessage,
+  decodeMessage
+};

package/dist/chunk-77HFJKLW.js

@@ -0,0 +1,342 @@
+import {
+  CHANNELS,
+  CONTROL_CHANNEL,
+  decodeMessage,
+  encodeMessage
+} from "./chunk-56IKFMJ2.js";
+
+// src/lib/tunnel-daemon.ts
+import * as fs from "fs";
+import * as net from "net";
+import * as path from "path";
+var OFFER_TIMEOUT_MS = 1e4;
+async function startDaemon(config) {
+  const { tunnelId, apiClient, socketPath, infoPath } = config;
+  const ndc = await import("node-datachannel");
+  const buffer = { messages: [] };
+  const startTime = Date.now();
+  let connected = false;
+  let pollingInterval = null;
+  let lastBrowserCandidateCount = 0;
+  let remoteDescriptionApplied = false;
+  const pendingRemoteCandidates = [];
+  const peer = new ndc.PeerConnection("agent", {
+    iceServers: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"]
+  });
+  const channels = /* @__PURE__ */ new Map();
+  const pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
+  function openDataChannel(name) {
+    const existing = channels.get(name);
+    if (existing) return existing;
+    const dc = peer.createDataChannel(name, { ordered: true });
+    setupChannel(name, dc);
+    return dc;
+  }
+  async function waitForChannelOpen(dc, timeoutMs = 5e3) {
+    if (dc.isOpen()) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeout = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        reject(new Error("DataChannel open timed out"));
+      }, timeoutMs);
+      dc.onOpen(() => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+  function setupChannel(name, dc) {
+    channels.set(name, dc);
+    dc.onMessage((data) => {
+      if (typeof data === "string") {
+        const msg = decodeMessage(data);
+        if (msg) {
+          if (msg.type === "binary" && !msg.data) {
+            pendingInboundBinaryMeta.set(name, msg);
+            return;
+          }
+          buffer.messages.push({ channel: name, msg, timestamp: Date.now() });
+        }
+      } else {
+        const pendingMeta = pendingInboundBinaryMeta.get(name);
+        if (pendingMeta) pendingInboundBinaryMeta.delete(name);
+        const binMsg = pendingMeta ? {
+          id: pendingMeta.id,
+          type: "binary",
+          data: data.toString("base64"),
+          meta: { ...pendingMeta.meta, size: data.length }
+        } : {
+          id: `bin-${Date.now()}`,
+          type: "binary",
+          data: data.toString("base64"),
+          meta: { size: data.length }
+        };
+        buffer.messages.push({ channel: name, msg: binMsg, timestamp: Date.now() });
+      }
+    });
+  }
+  openDataChannel(CONTROL_CHANNEL);
+  openDataChannel(CHANNELS.CHAT);
+  openDataChannel(CHANNELS.CANVAS);
+  const localCandidates = [];
+  peer.onLocalCandidate((candidate, mid) => {
+    localCandidates.push(JSON.stringify({ candidate, sdpMid: mid }));
+  });
+  peer.onStateChange((state) => {
+    if (state === "connected") {
+      connected = true;
+      if (pollingInterval) {
+        clearInterval(pollingInterval);
+        pollingInterval = null;
+      }
+    } else if (state === "disconnected" || state === "failed") {
+      connected = false;
+    }
+  });
+  peer.onDataChannel((dc) => {
+    setupChannel(dc.getLabel(), dc);
+  });
+  if (fs.existsSync(socketPath)) {
+    let stale = true;
+    try {
+      const raw = fs.readFileSync(infoPath, "utf-8");
+      const info = JSON.parse(raw);
+      process.kill(info.pid, 0);
+      stale = false;
+    } catch {
+      stale = true;
+    }
+    if (stale) {
+      try {
+        fs.unlinkSync(socketPath);
+      } catch {
+      }
+    } else {
+      throw new Error(`Daemon already running (socket: ${socketPath})`);
+    }
+  }
+  const ipcServer = net.createServer((conn) => {
+    let data = "";
+    conn.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx === -1) return;
+      const line = data.slice(0, newlineIdx);
+      data = data.slice(newlineIdx + 1);
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON" })}
+`);
+        return;
+      }
+      handleIpcRequest(request).then((response) => conn.write(`${JSON.stringify(response)}
+`)).catch((err) => conn.write(`${JSON.stringify({ ok: false, error: String(err) })}
+`));
+    });
+  });
+  ipcServer.listen(socketPath);
+  const infoDir = path.dirname(infoPath);
+  if (!fs.existsSync(infoDir)) fs.mkdirSync(infoDir, { recursive: true });
+  fs.writeFileSync(
+    infoPath,
+    JSON.stringify({ pid: process.pid, tunnelId, socketPath, startedAt: startTime })
+  );
+  async function cleanup() {
+    if (pollingInterval) clearInterval(pollingInterval);
+    for (const dc of channels.values()) dc.close();
+    peer.close();
+    ipcServer.close();
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(infoPath);
+    } catch {
+    }
+    await apiClient.close(tunnelId).catch(() => {
+    });
+  }
+  async function shutdown() {
+    await cleanup();
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+  let offer;
+  try {
+    offer = await generateOffer(peer, OFFER_TIMEOUT_MS);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await cleanup();
+    throw new Error(`Failed to generate WebRTC offer: ${message}`);
+  }
+  await apiClient.signal(tunnelId, { offer });
+  setTimeout(async () => {
+    if (localCandidates.length > 0) {
+      await apiClient.signal(tunnelId, { candidates: localCandidates }).catch(() => {
+      });
+    }
+  }, 1e3);
+  let lastSentCandidateCount = 0;
+  const candidateInterval = setInterval(async () => {
+    if (localCandidates.length > lastSentCandidateCount) {
+      const newOnes = localCandidates.slice(lastSentCandidateCount);
+      lastSentCandidateCount = localCandidates.length;
+      await apiClient.signal(tunnelId, { candidates: newOnes }).catch(() => {
+      });
+    }
+  }, 500);
+  setTimeout(() => clearInterval(candidateInterval), 3e4);
+  pollingInterval = setInterval(async () => {
+    try {
+      const tunnel = await apiClient.get(tunnelId);
+      if (tunnel.browserAnswer && !remoteDescriptionApplied) {
+        try {
+          const answer = JSON.parse(tunnel.browserAnswer);
+          peer.setRemoteDescription(answer.sdp, answer.type);
+          remoteDescriptionApplied = true;
+          while (pendingRemoteCandidates.length > 0) {
+            const next = pendingRemoteCandidates.shift();
+            if (!next) break;
+            try {
+              peer.addRemoteCandidate(next.candidate, next.sdpMid);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      if (tunnel.browserCandidates.length > lastBrowserCandidateCount) {
+        const newCandidates = tunnel.browserCandidates.slice(lastBrowserCandidateCount);
+        lastBrowserCandidateCount = tunnel.browserCandidates.length;
+        for (const c of newCandidates) {
+          try {
+            const parsed = JSON.parse(c);
+            if (typeof parsed.candidate !== "string") continue;
+            const sdpMid = typeof parsed.sdpMid === "string" ? parsed.sdpMid : "0";
+            if (!remoteDescriptionApplied) {
+              pendingRemoteCandidates.push({ candidate: parsed.candidate, sdpMid });
+              continue;
+            }
+            peer.addRemoteCandidate(parsed.candidate, sdpMid);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }, 500);
+  async function handleIpcRequest(req) {
+    switch (req.method) {
+      case "write": {
+        const channel = req.params.channel || CHANNELS.CHAT;
+        const msg = req.params.msg;
+        const binaryBase64 = typeof req.params.binaryBase64 === "string" ? req.params.binaryBase64 : void 0;
+        const dc = channels.get(channel);
+        let targetDc = dc;
+        if (!targetDc) {
+          const newDc = openDataChannel(channel);
+          targetDc = newDc;
+        }
+        try {
+          await waitForChannelOpen(targetDc);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { ok: false, error: `Channel "${channel}" not open: ${message}` };
+        }
+        if (msg.type === "binary" && binaryBase64) {
+          const payload = Buffer.from(binaryBase64, "base64");
+          targetDc.sendMessage(
+            encodeMessage({
+              ...msg,
+              meta: {
+                ...msg.meta || {},
+                size: payload.length
+              }
+            })
+          );
+          targetDc.sendMessageBinary(payload);
+        } else {
+          targetDc.sendMessage(encodeMessage(msg));
+        }
+        return { ok: true };
+      }
+      case "read": {
+        const channel = req.params.channel;
+        let msgs;
+        if (channel) {
+          msgs = buffer.messages.filter((m) => m.channel === channel);
+          buffer.messages = buffer.messages.filter((m) => m.channel !== channel);
+        } else {
+          msgs = [...buffer.messages];
+          buffer.messages = [];
+        }
+        return { ok: true, messages: msgs };
+      }
+      case "channels": {
+        const chList = [...channels.keys()].map((name) => ({
+          name,
+          direction: "bidi"
+        }));
+        return { ok: true, channels: chList };
+      }
+      case "status": {
+        return {
+          ok: true,
+          connected,
+          uptime: Math.floor((Date.now() - startTime) / 1e3),
+          channels: [...channels.keys()],
+          bufferedMessages: buffer.messages.length
+        };
+      }
+      case "close": {
+        void shutdown();
+        return { ok: true };
+      }
+      default:
+        return { ok: false, error: `Unknown method: ${req.method}` };
+    }
+  }
+}
+function generateOffer(peer, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    const done = (sdp, type) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeout);
+      resolve(JSON.stringify({ sdp, type }));
+    };
+    peer.onLocalDescription((sdp, type) => {
+      done(sdp, type);
+    });
+    peer.onGatheringStateChange((state) => {
+      if (state === "complete" && !resolved) {
+        const desc = peer.localDescription();
+        if (desc) done(desc.sdp, desc.type);
+      }
+    });
+    const timeout = setTimeout(() => {
+      if (resolved) return;
+      const desc = peer.localDescription();
+      if (desc) {
+        done(desc.sdp, desc.type);
+      } else {
+        resolved = true;
+        reject(new Error(`Timed out after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+    peer.setLocalDescription();
+  });
+}
+
+export {
+  startDaemon
+};

package/dist/chunk-BV423NLA.js

@@ -0,0 +1,57 @@
+// src/lib/tunnel-api.ts
+var TunnelApiClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async request(path, options = {}) {
+    const url = new URL(path, this.baseUrl);
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...options.headers
+      }
+    });
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      data = {};
+    }
+    if (!res.ok) throw new Error(data.error || `Request failed: ${res.status}`);
+    return data;
+  }
+  async create(opts) {
+    return this.request("/api/v1/tunnels", {
+      method: "POST",
+      body: JSON.stringify(opts)
+    });
+  }
+  async get(tunnelId) {
+    const data = await this.request(
+      `/api/v1/tunnels/${encodeURIComponent(tunnelId)}`
+    );
+    return data.tunnel;
+  }
+  async list() {
+    const data = await this.request("/api/v1/tunnels/");
+    return data.tunnels;
+  }
+  async signal(tunnelId, opts) {
+    await this.request(`/api/v1/tunnels/${encodeURIComponent(tunnelId)}/signal`, {
+      method: "PATCH",
+      body: JSON.stringify(opts)
+    });
+  }
+  async close(tunnelId) {
+    await this.request(`/api/v1/tunnels/${encodeURIComponent(tunnelId)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+export {
+  TunnelApiClient
+};

package/dist/index.js

@@ -1,19 +1,469 @@
 #!/usr/bin/env node
+import {
+  TunnelApiClient
+} from "./chunk-BV423NLA.js";
+import {
+  generateMessageId
+} from "./chunk-56IKFMJ2.js";
 
 // src/index.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import { createInterface } from "readline/promises";
 import { Command } from "commander";
 
+// src/commands/tunnel.ts
+import { fork } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/lib/config.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var DEFAULT_BASE_URL = "https://silent-guanaco-514.convex.site";
+function getConfigDir(homeDir) {
+  const home = homeDir || os.homedir();
+  return path.join(home, ".config", "pubblue");
+}
+function getConfigPath(homeDir) {
+  const dir = getConfigDir(homeDir);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+  return path.join(dir, "config.json");
+}
+function loadConfig(homeDir) {
+  const configPath = getConfigPath(homeDir);
+  if (!fs.existsSync(configPath)) return null;
+  const raw = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(config, homeDir) {
+  const configPath = getConfigPath(homeDir);
+  fs.writeFileSync(configPath, `${JSON.stringify({ apiKey: config.apiKey }, null, 2)}
+`, {
+    mode: 384
+  });
+  try {
+    fs.chmodSync(configPath, 384);
+  } catch {
+  }
+}
+function getConfig(homeDir) {
+  const envKey = process.env.PUBBLUE_API_KEY;
+  const envUrl = process.env.PUBBLUE_URL;
+  const baseUrl = envUrl || DEFAULT_BASE_URL;
+  if (envKey) {
+    return { apiKey: envKey, baseUrl };
+  }
+  const saved = loadConfig(homeDir);
+  if (!saved) {
+    throw new Error(
+      "Not configured. Run `pubblue configure` or set PUBBLUE_API_KEY environment variable."
+    );
+  }
+  return {
+    apiKey: saved.apiKey,
+    baseUrl
+  };
+}
+
+// src/lib/tunnel-ipc.ts
+import * as net from "net";
+function getSocketPath(tunnelId) {
+  return `/tmp/pubblue-${tunnelId}.sock`;
+}
+async function ipcCall(socketPath, request) {
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    let timeoutId = null;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      fn();
+    };
+    const client = net.createConnection(socketPath, () => {
+      client.write(`${JSON.stringify(request)}
+`);
+    });
+    let data = "";
+    client.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx !== -1) {
+        const line = data.slice(0, newlineIdx);
+        client.end();
+        try {
+          finish(() => resolve3(JSON.parse(line)));
+        } catch {
+          finish(() => reject(new Error("Invalid response from daemon")));
+        }
+      }
+    });
+    client.on("error", (err) => {
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+        finish(() => reject(new Error("Daemon not running. Is the tunnel still active?")));
+      } else {
+        finish(() => reject(err));
+      }
+    });
+    client.on("end", () => {
+      if (!data.includes("\n")) {
+        finish(() => reject(new Error("Daemon closed connection unexpectedly")));
+      }
+    });
+    timeoutId = setTimeout(() => {
+      client.destroy();
+      finish(() => reject(new Error("Daemon request timed out")));
+    }, 1e4);
+  });
+}
+
+// src/commands/tunnel.ts
+var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".markdown",
+  ".json",
+  ".csv",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".log"
+]);
+function getMimeType(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  const mimeByExt = {
+    ".html": "text/html; charset=utf-8",
+    ".htm": "text/html; charset=utf-8",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+    ".markdown": "text/markdown; charset=utf-8",
+    ".json": "application/json",
+    ".csv": "text/csv; charset=utf-8",
+    ".xml": "application/xml",
+    ".yaml": "application/x-yaml",
+    ".yml": "application/x-yaml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".mp4": "video/mp4"
+  };
+  return mimeByExt[ext] || "application/octet-stream";
+}
+function tunnelInfoDir() {
+  const dir = path2.join(
+    process.env.HOME || process.env.USERPROFILE || "/tmp",
+    ".config",
+    "pubblue",
+    "tunnels"
+  );
+  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function tunnelInfoPath(tunnelId) {
+  return path2.join(tunnelInfoDir(), `${tunnelId}.json`);
+}
+function createApiClient() {
+  const config = getConfig();
+  return new TunnelApiClient(config.baseUrl, config.apiKey);
+}
+async function ensureNodeDatachannelAvailable() {
+  try {
+    await import("node-datachannel");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("node-datachannel native module is not available.");
+    console.error("Run `pnpm rebuild node-datachannel` in the cli package and retry.");
+    console.error(`Details: ${message}`);
+    process.exit(1);
+  }
+}
+function isDaemonRunning(tunnelId) {
+  const infoPath = tunnelInfoPath(tunnelId);
+  if (!fs2.existsSync(infoPath)) return false;
+  try {
+    const info = JSON.parse(fs2.readFileSync(infoPath, "utf-8"));
+    process.kill(info.pid, 0);
+    return true;
+  } catch {
+    try {
+      fs2.unlinkSync(infoPath);
+    } catch {
+    }
+    return false;
+  }
+}
+function registerTunnelCommands(program2) {
+  const tunnel = program2.command("tunnel").description("P2P encrypted tunnel to browser");
+  tunnel.command("start").description("Start a new tunnel (spawns background daemon)").option("--title <title>", "Tunnel title").option("--expires <duration>", "Auto-close after duration (e.g. 4h, 1d)", "24h").option("--foreground", "Run in foreground (don't fork)").action(async (opts) => {
+    await ensureNodeDatachannelAvailable();
+    const apiClient = createApiClient();
+    const result = await apiClient.create({
+      title: opts.title,
+      expiresIn: opts.expires
+    });
+    const socketPath = getSocketPath(result.tunnelId);
+    const infoPath = tunnelInfoPath(result.tunnelId);
+    if (opts.foreground) {
+      const { startDaemon } = await import("./tunnel-daemon-QBJSX4JM.js");
+      console.log(`Tunnel started: ${result.url}`);
+      console.log(`Tunnel ID: ${result.tunnelId}`);
+      console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
+      console.log("Running in foreground. Press Ctrl+C to stop.");
+      try {
+        await startDaemon({
+          tunnelId: result.tunnelId,
+          apiClient,
+          socketPath,
+          infoPath
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Daemon failed: ${message}`);
+        process.exit(1);
+      }
+    } else {
+      const daemonScript = path2.join(import.meta.dirname, "tunnel-daemon-entry.js");
+      const config = getConfig();
+      const child = fork(daemonScript, [], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          PUBBLUE_DAEMON_TUNNEL_ID: result.tunnelId,
+          PUBBLUE_DAEMON_BASE_URL: config.baseUrl,
+          PUBBLUE_DAEMON_API_KEY: config.apiKey,
+          PUBBLUE_DAEMON_SOCKET: socketPath,
+          PUBBLUE_DAEMON_INFO: infoPath
+        }
+      });
+      child.unref();
+      const ready = await waitForDaemonReady(infoPath, child, 5e3);
+      if (!ready) {
+        console.error("Daemon failed to start. Cleaning up tunnel...");
+        await apiClient.close(result.tunnelId).catch(() => {
+        });
+        process.exit(1);
+      }
+      console.log(`Tunnel started: ${result.url}`);
+      console.log(`Tunnel ID: ${result.tunnelId}`);
+      console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
+    }
+  });
+  tunnel.command("write").description("Write data to a channel").argument("[message]", "Text message (or use --file)").option("-t, --tunnel <tunnelId>", "Tunnel ID (auto-detected if one active)").option("-c, --channel <channel>", "Channel name", "chat").option("-f, --file <file>", "Read content from file").action(
+    async (messageArg, opts) => {
+      let msg;
+      let binaryBase64;
+      if (opts.file) {
+        const filePath = path2.resolve(opts.file);
+        const ext = path2.extname(filePath).toLowerCase();
+        const bytes = fs2.readFileSync(filePath);
+        const filename = path2.basename(filePath);
+        if (ext === ".html" || ext === ".htm") {
+          msg = {
+            id: generateMessageId(),
+            type: "html",
+            data: bytes.toString("utf-8"),
+            meta: { title: filename, filename, mime: getMimeType(filePath), size: bytes.length }
+          };
+        } else if (TEXT_FILE_EXTENSIONS.has(ext)) {
+          msg = {
+            id: generateMessageId(),
+            type: "text",
+            data: bytes.toString("utf-8"),
+            meta: { filename, mime: getMimeType(filePath), size: bytes.length }
+          };
+        } else {
+          msg = {
+            id: generateMessageId(),
+            type: "binary",
+            meta: { filename, mime: getMimeType(filePath), size: bytes.length }
+          };
+          binaryBase64 = bytes.toString("base64");
+        }
+      } else if (messageArg) {
+        msg = {
+          id: generateMessageId(),
+          type: "text",
+          data: messageArg
+        };
+      } else {
+        const chunks = [];
+        for await (const chunk of process.stdin) chunks.push(chunk);
+        msg = {
+          id: generateMessageId(),
+          type: "text",
+          data: Buffer.concat(chunks).toString("utf-8").trim()
+        };
+      }
+      const tunnelId = opts.tunnel || await resolveActiveTunnel();
+      const socketPath = getSocketPath(tunnelId);
+      const response = await ipcCall(socketPath, {
+        method: "write",
+        params: { channel: opts.channel, msg, binaryBase64 }
+      });
+      if (!response.ok) {
+        console.error(`Failed: ${response.error}`);
+        process.exit(1);
+      }
+    }
+  );
+  tunnel.command("read").description("Read buffered messages from channels").argument("[tunnelId]", "Tunnel ID (auto-detected if one active)").option("-c, --channel <channel>", "Filter by channel").option("--follow", "Stream messages continuously").action(
+    async (tunnelIdArg, opts) => {
+      const tunnelId = tunnelIdArg || await resolveActiveTunnel();
+      const socketPath = getSocketPath(tunnelId);
+      if (opts.follow) {
+        while (true) {
+          const response = await ipcCall(socketPath, {
+            method: "read",
+            params: { channel: opts.channel }
+          }).catch(() => null);
+          if (!response) {
+            console.error("Daemon disconnected.");
+            process.exit(1);
+          }
+          if (response.messages && response.messages.length > 0) {
+            for (const m of response.messages) {
+              console.log(JSON.stringify(m));
+            }
+          }
+          await new Promise((r) => setTimeout(r, 1e3));
+        }
+      } else {
+        const response = await ipcCall(socketPath, {
+          method: "read",
+          params: { channel: opts.channel }
+        });
+        if (!response.ok) {
+          console.error(`Failed: ${response.error}`);
+          process.exit(1);
+        }
+        console.log(JSON.stringify(response.messages || [], null, 2));
+      }
+    }
+  );
+  tunnel.command("channels").description("List active channels").argument("[tunnelId]", "Tunnel ID").action(async (tunnelIdArg) => {
+    const tunnelId = tunnelIdArg || await resolveActiveTunnel();
+    const socketPath = getSocketPath(tunnelId);
+    const response = await ipcCall(socketPath, { method: "channels", params: {} });
+    if (response.channels) {
+      for (const ch of response.channels) {
+        console.log(`  ${ch.name}  [${ch.direction}]`);
+      }
+    }
+  });
+  tunnel.command("status").description("Check tunnel connection status").argument("[tunnelId]", "Tunnel ID").action(async (tunnelIdArg) => {
+    const tunnelId = tunnelIdArg || await resolveActiveTunnel();
+    const socketPath = getSocketPath(tunnelId);
+    const response = await ipcCall(socketPath, { method: "status", params: {} });
+    console.log(`  Status: ${response.connected ? "connected" : "waiting"}`);
+    console.log(`  Uptime: ${response.uptime}s`);
+    const chNames = Array.isArray(response.channels) ? response.channels.map((c) => typeof c === "string" ? c : String(c)) : [];
+    console.log(`  Channels: ${chNames.join(", ")}`);
+    console.log(`  Buffered: ${response.bufferedMessages ?? 0} messages`);
+  });
+  tunnel.command("list").description("List active tunnels").action(async () => {
+    const apiClient = createApiClient();
+    const tunnels = await apiClient.list();
+    if (tunnels.length === 0) {
+      console.log("No active tunnels.");
+      return;
+    }
+    for (const t of tunnels) {
+      const age = Math.floor((Date.now() - t.createdAt) / 6e4);
+      const running = isDaemonRunning(t.tunnelId) ? "running" : "no daemon";
+      const conn = t.hasConnection ? "connected" : "waiting";
+      console.log(
+        `  ${t.tunnelId}  ${t.title || "(untitled)"}  ${conn}  ${running}  ${age}m ago`
+      );
+    }
+  });
+  tunnel.command("close").description("Close a tunnel and stop its daemon").argument("<tunnelId>", "Tunnel ID").action(async (tunnelId) => {
+    const socketPath = getSocketPath(tunnelId);
+    let closedByDaemon = false;
+    try {
+      const daemonResult = await ipcCall(socketPath, { method: "close", params: {} });
+      closedByDaemon = daemonResult.ok;
+    } catch {
+      closedByDaemon = false;
+    }
+    if (!closedByDaemon) {
+      const apiClient = createApiClient();
+      try {
+        await apiClient.close(tunnelId);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to close tunnel ${tunnelId}: ${message}`);
+        process.exit(1);
+      }
+    }
+    console.log(`Closed: ${tunnelId}`);
+  });
+}
+async function resolveActiveTunnel() {
+  const dir = tunnelInfoDir();
+  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const active = [];
+  for (const f of files) {
+    const tunnelId = f.replace(".json", "");
+    if (isDaemonRunning(tunnelId)) active.push(tunnelId);
+  }
+  if (active.length === 0) {
+    console.error("No active tunnels. Run `pubblue tunnel start` first.");
+    process.exit(1);
+  }
+  if (active.length === 1) return active[0];
+  console.error(`Multiple active tunnels: ${active.join(", ")}. Specify one.`);
+  process.exit(1);
+}
+function waitForDaemonReady(infoPath, child, timeoutMs) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(poll);
+      clearTimeout(timeout);
+      resolve3(value);
+    };
+    child.on("exit", () => done(false));
+    const poll = setInterval(() => {
+      if (fs2.existsSync(infoPath)) done(true);
+    }, 100);
+    const timeout = setTimeout(() => done(false), timeoutMs);
+  });
+}
+
 // src/lib/api.ts
 var PubApiClient = class {
   constructor(baseUrl, apiKey) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
   }
-  async request(path3, options = {}) {
-    const url = new URL(path3, this.baseUrl);
+  async request(path4, options = {}) {
+    const url = new URL(path4, this.baseUrl);
     const res = await fetch(url, {
       ...options,
       headers: {
@@ -71,60 +521,6 @@ var PubApiClient = class {
   }
 };
 
-// src/lib/config.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-var DEFAULT_BASE_URL = "https://silent-guanaco-514.convex.site";
-function getConfigDir(homeDir) {
-  const home = homeDir || os.homedir();
-  return path.join(home, ".config", "pubblue");
-}
-function getConfigPath(homeDir) {
-  const dir = getConfigDir(homeDir);
-  fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  try {
-    fs.chmodSync(dir, 448);
-  } catch {
-  }
-  return path.join(dir, "config.json");
-}
-function loadConfig(homeDir) {
-  const configPath = getConfigPath(homeDir);
-  if (!fs.existsSync(configPath)) return null;
-  const raw = fs.readFileSync(configPath, "utf-8");
-  return JSON.parse(raw);
-}
-function saveConfig(config, homeDir) {
-  const configPath = getConfigPath(homeDir);
-  fs.writeFileSync(configPath, `${JSON.stringify({ apiKey: config.apiKey }, null, 2)}
-`, {
-    mode: 384
-  });
-  try {
-    fs.chmodSync(configPath, 384);
-  } catch {
-  }
-}
-function getConfig(homeDir) {
-  const envKey = process.env.PUBBLUE_API_KEY;
-  const envUrl = process.env.PUBBLUE_URL;
-  const baseUrl = envUrl || DEFAULT_BASE_URL;
-  if (envKey) {
-    return { apiKey: envKey, baseUrl };
-  }
-  const saved = loadConfig(homeDir);
-  if (!saved) {
-    throw new Error(
-      "Not configured. Run `pubblue configure` or set PUBBLUE_API_KEY environment variable."
-    );
-  }
-  return {
-    apiKey: saved.apiKey,
-    baseUrl
-  };
-}
-
 // src/index.ts
 var program = new Command();
 function createClient() {
@@ -173,17 +569,17 @@ async function resolveConfigureApiKey(opts) {
   return readApiKeyFromPrompt();
 }
 function readFile(filePath) {
-  const resolved = path2.resolve(filePath);
-  if (!fs2.existsSync(resolved)) {
+  const resolved = path3.resolve(filePath);
+  if (!fs3.existsSync(resolved)) {
     console.error(`File not found: ${resolved}`);
     process.exit(1);
   }
   return {
-    content: fs2.readFileSync(resolved, "utf-8"),
-    basename: path2.basename(resolved)
+    content: fs3.readFileSync(resolved, "utf-8"),
+    basename: path3.basename(resolved)
   };
 }
-program.name("pubblue").description("Publish static content and get shareable URLs").version("0.3.0");
+program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.1");
 program.command("configure").description("Configure the CLI with your API key").option("--api-key <key>", "Your API key (less secure: appears in shell history)").option("--api-key-stdin", "Read API key from stdin").action(async (opts) => {
   try {
     const apiKey = await resolveConfigureApiKey(opts);
@@ -195,7 +591,7 @@ program.command("configure").description("Configure the CLI with your API key").
     process.exit(1);
   }
 });
-program.command("create").description("Create a new publication").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--public", "Make the publication public (default: private)").option("--private", "Make the publication private (this is the default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
+program.command("create").description("Create a new publication").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--private", "Make the publication private (default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
   async (fileArg, opts) => {
     const client = createClient();
     let content;
@@ -212,7 +608,7 @@ program.command("create").description("Create a new publication").argument("[fil
       filename,
       title: opts.title,
       slug: opts.slug,
-      isPublic: opts.public ?? false,
+      isPublic: false,
       expiresIn: opts.expires
     });
     console.log(`Created: ${result.url}`);
@@ -237,7 +633,7 @@ program.command("get").description("Get details of a publication").argument("<sl
   console.log(`  Updated: ${new Date(pub.updatedAt).toLocaleDateString()}`);
   console.log(`  Size:    ${pub.content.length} bytes`);
 });
-program.command("update").description("Update a publication's content and/or metadata").argument("<slug>", "Slug of the publication to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--public", "Make the publication public").option("--private", "Make the publication private").option("--slug <newSlug>", "Rename the slug").action(
+program.command("update").description("Update a publication's content and/or metadata").argument("<slug>", "Slug of the publication to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--private", "Make the publication private").option("--slug <newSlug>", "Rename the slug").action(
   async (slug, opts) => {
     const client = createClient();
     let content;
@@ -248,8 +644,7 @@ program.command("update").description("Update a publication's content and/or met
       filename = file.basename;
     }
     let isPublic;
-    if (opts.public) isPublic = true;
-    else if (opts.private) isPublic = false;
+    if (opts.private) isPublic = false;
     const result = await client.update({
       slug,
       content,
@@ -283,4 +678,5 @@ program.command("delete").description("Delete a publication").argument("<slug>",
   await client.remove(slug);
   console.log(`Deleted: ${slug}`);
 });
+registerTunnelCommands(program);
 program.parse();

package/dist/tunnel-daemon-QBJSX4JM.js

@@ -0,0 +1,7 @@
+import {
+  startDaemon
+} from "./chunk-77HFJKLW.js";
+import "./chunk-56IKFMJ2.js";
+export {
+  startDaemon
+};

package/dist/tunnel-daemon-entry.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/tunnel-daemon-entry.js

@@ -0,0 +1,24 @@
+import {
+  TunnelApiClient
+} from "./chunk-BV423NLA.js";
+import {
+  startDaemon
+} from "./chunk-77HFJKLW.js";
+import "./chunk-56IKFMJ2.js";
+
+// src/tunnel-daemon-entry.ts
+var tunnelId = process.env.PUBBLUE_DAEMON_TUNNEL_ID;
+var baseUrl = process.env.PUBBLUE_DAEMON_BASE_URL;
+var apiKey = process.env.PUBBLUE_DAEMON_API_KEY;
+var socketPath = process.env.PUBBLUE_DAEMON_SOCKET;
+var infoPath = process.env.PUBBLUE_DAEMON_INFO;
+if (!tunnelId || !baseUrl || !apiKey || !socketPath || !infoPath) {
+  console.error("Missing required env vars for daemon.");
+  process.exit(1);
+}
+var apiClient = new TunnelApiClient(baseUrl, apiKey);
+void startDaemon({ tunnelId, apiClient, socketPath, infoPath }).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Tunnel daemon failed to start: ${message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "pubblue",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "CLI tool for publishing static content via pub.blue",
   "type": "module",
   "bin": {
     "pubblue": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --watch",
+    "build": "tsup src/index.ts src/tunnel-daemon-entry.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/tunnel-daemon-entry.ts --format esm --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "tsc --noEmit"
   },
   "dependencies": {
-    "commander": "^13.0.0"
+    "commander": "^13.0.0",
+    "node-datachannel": "^0.32.0"
   },
   "devDependencies": {
     "@types/node": "22.10.2",
@@ -35,7 +36,8 @@
   },
   "pnpm": {
     "onlyBuiltDependencies": [
-      "esbuild"
+      "esbuild",
+      "node-datachannel"
     ]
   }
 }