pubblue 0.2.0 → 0.4.0

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-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/chunk-OLY5PC4A.js

@@ -0,0 +1,311 @@
+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";
+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);
+  });
+  const offer = await new Promise((resolve) => {
+    peer.onLocalDescription((sdp, type) => {
+      resolve(JSON.stringify({ sdp, type }));
+    });
+    peer.setLocalDescription();
+  });
+  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);
+  if (fs.existsSync(socketPath)) {
+    const infoFile = infoPath;
+    let stale = true;
+    try {
+      const raw = fs.readFileSync(infoFile, "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);
+  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}` };
+    }
+  }
+  async function shutdown() {
+    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(() => {
+    });
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+  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
+    })
+  );
+}
+
+export {
+  startDaemon
+};

package/dist/index.js

@@ -1,60 +1,21 @@
 #!/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/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);
-    const res = await fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...options.headers
-      }
-    });
-    const data = await res.json();
-    if (!res.ok) {
-      throw new Error(data.error || `Request failed with status ${res.status}`);
-    }
-    return data;
-  }
-  async create(opts) {
-    return this.request("/api/v1/publications", {
-      method: "POST",
-      body: JSON.stringify(opts)
-    });
-  }
-  async get(slug) {
-    const data = await this.request(`/api/v1/publications/${encodeURIComponent(slug)}`);
-    return data.publication;
-  }
-  async list() {
-    const data = await this.request("/api/v1/publications");
-    return data.publications;
-  }
-  async update(opts) {
-    const { slug, ...body } = opts;
-    return this.request(`/api/v1/publications/${encodeURIComponent(slug)}`, {
-      method: "PATCH",
-      body: JSON.stringify(body)
-    });
-  }
-  async remove(slug) {
-    await this.request(`/api/v1/publications/${encodeURIComponent(slug)}`, {
-      method: "DELETE"
-    });
-  }
-};
+// 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";
@@ -110,6 +71,426 @@ function getConfig(homeDir) {
   };
 }
 
+// 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-CHNV373I.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.");
+      await startDaemon({
+        tunnelId: result.tunnelId,
+        apiClient,
+        socketPath,
+        infoPath
+      });
+    } 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();
+      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);
+}
+
+// src/lib/api.ts
+var PubApiClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async request(path4, options = {}) {
+    const url = new URL(path4, this.baseUrl);
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...options.headers
+      }
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data.error || `Request failed with status ${res.status}`);
+    }
+    return data;
+  }
+  async create(opts) {
+    return this.request("/api/v1/publications", {
+      method: "POST",
+      body: JSON.stringify(opts)
+    });
+  }
+  async get(slug) {
+    const data = await this.request(`/api/v1/publications/${encodeURIComponent(slug)}`);
+    return data.publication;
+  }
+  async listPage(cursor, limit) {
+    const params = new URLSearchParams();
+    if (cursor) params.set("cursor", cursor);
+    if (limit) params.set("limit", String(limit));
+    const qs = params.toString();
+    return this.request(`/api/v1/publications${qs ? `?${qs}` : ""}`);
+  }
+  async list() {
+    const all = [];
+    let cursor;
+    do {
+      const result = await this.listPage(cursor, 100);
+      all.push(...result.publications);
+      cursor = result.hasMore ? result.cursor : void 0;
+    } while (cursor);
+    return all;
+  }
+  async update(opts) {
+    const { slug, newSlug, ...rest } = opts;
+    const body = { ...rest };
+    if (newSlug) body.slug = newSlug;
+    return this.request(`/api/v1/publications/${encodeURIComponent(slug)}`, {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    });
+  }
+  async remove(slug) {
+    await this.request(`/api/v1/publications/${encodeURIComponent(slug)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
 // src/index.ts
 var program = new Command();
 function createClient() {
@@ -158,17 +539,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.2.0");
+program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.0");
 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);
@@ -180,14 +561,13 @@ 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)").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();
-    const filePath = fileArg;
     let content;
     let filename;
-    if (filePath) {
-      const file = readFile(filePath);
+    if (fileArg) {
+      const file = readFile(fileArg);
       content = file.content;
       filename = file.basename;
     } else {
@@ -198,9 +578,13 @@ 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}`);
+    if (result.expiresAt) {
+      console.log(`  Expires: ${new Date(result.expiresAt).toISOString()}`);
+    }
   }
 );
 program.command("get").description("Get details of a publication").argument("<slug>", "Slug of the publication").option("--content", "Output raw content to stdout (no metadata, pipeable)").action(async (slug, opts) => {
@@ -214,11 +598,12 @@ program.command("get").description("Get details of a publication").argument("<sl
   console.log(`  Type:    ${pub.contentType}`);
   if (pub.title) console.log(`  Title:   ${pub.title}`);
   console.log(`  Status:  ${formatVisibility(pub.isPublic)}`);
+  if (pub.expiresAt) console.log(`  Expires: ${new Date(pub.expiresAt).toISOString()}`);
   console.log(`  Created: ${new Date(pub.createdAt).toLocaleDateString()}`);
   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").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;
@@ -229,9 +614,15 @@ 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;
-    const result = await client.update({ slug, content, filename, title: opts.title, isPublic });
+    if (opts.private) isPublic = false;
+    const result = await client.update({
+      slug,
+      content,
+      filename,
+      title: opts.title,
+      isPublic,
+      newSlug: opts.slug
+    });
     console.log(`Updated: ${result.slug}`);
     if (result.title) console.log(`  Title:  ${result.title}`);
     console.log(`  Status: ${formatVisibility(result.isPublic)}`);
@@ -246,8 +637,9 @@ program.command("list").description("List your publications").action(async () =>
   }
   for (const pub of pubs) {
     const date = new Date(pub.createdAt).toLocaleDateString();
+    const expires = pub.expiresAt ? ` expires:${new Date(pub.expiresAt).toISOString()}` : "";
     console.log(
-      `  ${pub.slug}  [${pub.contentType}]  ${formatVisibility(pub.isPublic)}  ${date}`
+      `  ${pub.slug}  [${pub.contentType}]  ${formatVisibility(pub.isPublic)}  ${date}${expires}`
     );
   }
 });
@@ -256,4 +648,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-CHNV373I.js

@@ -0,0 +1,7 @@
+import {
+  startDaemon
+} from "./chunk-OLY5PC4A.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-OLY5PC4A.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.2.0",
+  "version": "0.4.0",
   "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"
     ]
   }
 }