pubblue 0.6.1 → 0.6.8

package/dist/index.js

@@ -6,32 +6,28 @@ import {
   TEXT_FILE_EXTENSIONS,
   buildBridgeProcessEnv,
   buildDaemonForkStdio,
-  createApiClient,
   ensureNodeDatachannelAvailable,
+  errorMessage,
   failCli,
   formatApiError,
   generateMessageId,
   getAgentSocketPath,
-  getConfig,
   getFollowReadDelayMs,
   getMimeType,
-  getTelegramMiniAppUrl,
   ipcCall,
   isDaemonRunning,
   liveInfoPath,
   liveLogPath,
-  loadConfig,
   messageContainsPong,
   parsePositiveIntegerOption,
   readLogTail,
   resolveActiveSlug,
   resolveBridgeMode,
-  saveConfig,
   stopOtherDaemons,
   toCliFailure,
   waitForDaemonReady,
   writeLatestCliVersion
-} from "./chunk-BBJOOZHS.js";
+} from "./chunk-AZQD654L.js";
 
 // src/program.ts
 import { Command } from "commander";
@@ -39,11 +35,71 @@ import { Command } from "commander";
 // src/commands/configure.ts
 import { createInterface } from "readline/promises";
 
-// src/commands/shared.ts
+// src/lib/config.ts
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
-function createClient() {
-  const config = getConfig();
+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 readConfig(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(config, 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;
+  const saved = readConfig(homeDir);
+  if (envKey) {
+    return { apiKey: envKey, baseUrl, bridge: saved?.bridge };
+  }
+  if (!saved) {
+    throw new Error(
+      "Not configured. Run `pubblue configure` or set PUBBLUE_API_KEY environment variable."
+    );
+  }
+  return {
+    apiKey: saved.apiKey,
+    baseUrl,
+    bridge: saved.bridge
+  };
+}
+function getTelegramMiniAppUrl(slug) {
+  const saved = readConfig();
+  if (!saved?.telegram?.botUsername) return null;
+  return `https://t.me/${saved.telegram.botUsername}?startapp=${slug}`;
+}
+
+// src/commands/shared.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function createClient(configOverride) {
+  const config = configOverride || getConfig();
   return new PubApiClient(config.baseUrl, config.apiKey);
 }
 async function readFromStdin() {
@@ -65,13 +121,13 @@ function resolveVisibilityFlags(opts) {
   return void 0;
 }
 function readFile(filePath) {
-  const resolved = path.resolve(filePath);
-  if (!fs.existsSync(resolved)) {
+  const resolved = path2.resolve(filePath);
+  if (!fs2.existsSync(resolved)) {
     failCli(`File not found: ${resolved}`);
   }
   return {
-    content: fs.readFileSync(resolved, "utf-8"),
-    basename: path.basename(resolved)
+    content: fs2.readFileSync(resolved, "utf-8"),
+    basename: path2.basename(resolved)
   };
 }
 
@@ -133,103 +189,78 @@ function parsePositiveInteger(raw, key) {
   }
   return parsed;
 }
-var SUPPORTED_KEYS = [
-  "openclaw.path",
-  "openclaw.sessionId",
-  "openclaw.threadId",
-  "openclaw.canvasReminderEvery",
-  "openclaw.deliver",
-  "openclaw.deliverChannel",
-  "openclaw.replyTo",
-  "openclaw.deliverTimeoutMs",
-  "openclaw.attachmentDir",
-  "openclaw.attachmentMaxBytes",
-  "telegram.botToken"
-];
+var CONFIG_KEY_REGISTRY = {
+  "openclaw.path": { target: "bridge", field: "openclawPath", type: "string" },
+  "openclaw.stateDir": { target: "bridge", field: "openclawStateDir", type: "string" },
+  "openclaw.sessionId": { target: "bridge", field: "sessionId", type: "string" },
+  "openclaw.threadId": { target: "bridge", field: "threadId", type: "string" },
+  "openclaw.canvasReminderEvery": {
+    target: "bridge",
+    field: "canvasReminderEvery",
+    type: "integer"
+  },
+  "openclaw.deliver": { target: "bridge", field: "deliver", type: "boolean" },
+  "openclaw.deliverChannel": { target: "bridge", field: "deliverChannel", type: "string" },
+  "openclaw.replyTo": { target: "bridge", field: "replyTo", type: "string" },
+  "openclaw.deliverTimeoutMs": { target: "bridge", field: "deliverTimeoutMs", type: "integer" },
+  "openclaw.attachmentDir": { target: "bridge", field: "attachmentDir", type: "string" },
+  "openclaw.attachmentMaxBytes": { target: "bridge", field: "attachmentMaxBytes", type: "integer" },
+  "claude-code.path": { target: "bridge", field: "claudeCodePath", type: "string" },
+  "claude-code.model": { target: "bridge", field: "claudeCodeModel", type: "string" },
+  "claude-code.allowedTools": { target: "bridge", field: "claudeCodeAllowedTools", type: "string" },
+  "claude-code.appendSystemPrompt": {
+    target: "bridge",
+    field: "claudeCodeAppendSystemPrompt",
+    type: "string",
+    displayAs: "set-only"
+  },
+  "claude-code.maxTurns": { target: "bridge", field: "claudeCodeMaxTurns", type: "integer" },
+  "claude-code.cwd": { target: "bridge", field: "claudeCodeCwd", type: "string" },
+  "telegram.botToken": {
+    target: "telegram",
+    field: "botToken",
+    type: "string",
+    cascadeUnset: ["botUsername", "hasMainWebApp"]
+  }
+};
+var SUPPORTED_KEYS = Object.keys(CONFIG_KEY_REGISTRY);
+function coerceValue(raw, type, key) {
+  if (type === "integer") return parsePositiveInteger(raw, key);
+  if (type === "boolean") return parseBooleanValue(raw, key);
+  return raw;
+}
 function applyConfigSet(bridge, telegram, key, value) {
-  switch (key) {
-    case "openclaw.path":
-      bridge.openclawPath = value;
-      return;
-    case "openclaw.sessionId":
-      bridge.sessionId = value;
-      return;
-    case "openclaw.threadId":
-      bridge.threadId = value;
-      return;
-    case "openclaw.canvasReminderEvery":
-      bridge.canvasReminderEvery = parsePositiveInteger(value, key);
-      return;
-    case "openclaw.deliver":
-      bridge.deliver = parseBooleanValue(value, key);
-      return;
-    case "openclaw.deliverChannel":
-      bridge.deliverChannel = value;
-      return;
-    case "openclaw.replyTo":
-      bridge.replyTo = value;
-      return;
-    case "openclaw.deliverTimeoutMs":
-      bridge.deliverTimeoutMs = parsePositiveInteger(value, key);
-      return;
-    case "openclaw.attachmentDir":
-      bridge.attachmentDir = value;
-      return;
-    case "openclaw.attachmentMaxBytes":
-      bridge.attachmentMaxBytes = parsePositiveInteger(value, key);
-      return;
-    case "telegram.botToken":
-      telegram.botToken = value;
-      return;
-    default:
-      throw new Error(
-        [
-          `Unknown config key: ${key}`,
-          "Supported keys:",
-          ...SUPPORTED_KEYS.map((k) => `  ${k}`)
-        ].join("\n")
-      );
+  const def = CONFIG_KEY_REGISTRY[key];
+  if (!def) {
+    throw new Error(
+      [
+        `Unknown config key: ${key}`,
+        "Supported keys:",
+        ...SUPPORTED_KEYS.map((k) => `  ${k}`)
+      ].join("\n")
+    );
+  }
+  const coerced = coerceValue(value, def.type, key);
+  if (def.target === "bridge") {
+    Object.assign(bridge, { [def.field]: coerced });
+  } else {
+    Object.assign(telegram, { [def.field]: coerced });
   }
 }
 function applyConfigUnset(bridge, telegram, key) {
-  switch (key) {
-    case "openclaw.path":
-      delete bridge.openclawPath;
-      return;
-    case "openclaw.sessionId":
-      delete bridge.sessionId;
-      return;
-    case "openclaw.threadId":
-      delete bridge.threadId;
-      return;
-    case "openclaw.canvasReminderEvery":
-      delete bridge.canvasReminderEvery;
-      return;
-    case "openclaw.deliver":
-      delete bridge.deliver;
-      return;
-    case "openclaw.deliverChannel":
-      delete bridge.deliverChannel;
-      return;
-    case "openclaw.replyTo":
-      delete bridge.replyTo;
-      return;
-    case "openclaw.deliverTimeoutMs":
-      delete bridge.deliverTimeoutMs;
-      return;
-    case "openclaw.attachmentDir":
-      delete bridge.attachmentDir;
-      return;
-    case "openclaw.attachmentMaxBytes":
-      delete bridge.attachmentMaxBytes;
-      return;
-    case "telegram.botToken":
-      delete telegram.botToken;
-      delete telegram.botUsername;
-      delete telegram.hasMainWebApp;
-      return;
-    default:
-      throw new Error(`Unknown config key for --unset: ${key}`);
+  const def = CONFIG_KEY_REGISTRY[key];
+  if (!def) {
+    throw new Error(`Unknown config key for --unset: ${key}`);
+  }
+  if (def.target === "bridge") {
+    delete bridge[def.field];
+  } else {
+    delete telegram[def.field];
+    if (def.cascadeUnset) {
+      for (const cascadeField of def.cascadeUnset) {
+        delete telegram[cascadeField];
+      }
+    }
   }
 }
 function hasValues(obj) {
@@ -261,41 +292,32 @@ async function telegramSetMenuButton(token, button) {
     throw new Error(data.description ?? "setChatMenuButton failed");
   }
 }
-function printConfigSummary(saved) {
-  if (!saved) {
-    console.log("Saved config: none");
+function formatFieldValue(value, def) {
+  if (def.displayAs === "set-only") return "(set)";
+  if (def.type === "boolean") return value ? "true" : "false";
+  return String(value);
+}
+function printBridgeConfig(bridge) {
+  if (!hasValues(bridge)) {
+    console.log("  bridge: none");
     return;
   }
-  console.log("Saved config:");
-  console.log(`  apiKey: ${maskSecret(saved.apiKey)}`);
-  if (saved.bridge && hasValues(saved.bridge)) {
-    if (saved.bridge.openclawPath) console.log(`  openclaw.path: ${saved.bridge.openclawPath}`);
-    if (saved.bridge.sessionId) console.log(`  openclaw.sessionId: ${saved.bridge.sessionId}`);
-    if (saved.bridge.threadId) console.log(`  openclaw.threadId: ${saved.bridge.threadId}`);
-    if (saved.bridge.canvasReminderEvery !== void 0)
-      console.log(`  openclaw.canvasReminderEvery: ${saved.bridge.canvasReminderEvery}`);
-    if (saved.bridge.deliver !== void 0)
-      console.log(`  openclaw.deliver: ${saved.bridge.deliver ? "true" : "false"}`);
-    if (saved.bridge.deliverChannel)
-      console.log(`  openclaw.deliverChannel: ${saved.bridge.deliverChannel}`);
-    if (saved.bridge.replyTo) console.log(`  openclaw.replyTo: ${saved.bridge.replyTo}`);
-    if (saved.bridge.deliverTimeoutMs !== void 0)
-      console.log(`  openclaw.deliverTimeoutMs: ${saved.bridge.deliverTimeoutMs}`);
-    if (saved.bridge.attachmentDir)
-      console.log(`  openclaw.attachmentDir: ${saved.bridge.attachmentDir}`);
-    if (saved.bridge.attachmentMaxBytes !== void 0)
-      console.log(`  openclaw.attachmentMaxBytes: ${saved.bridge.attachmentMaxBytes}`);
-  } else {
-    console.log("  bridge: none");
+  for (const [key, def] of Object.entries(CONFIG_KEY_REGISTRY)) {
+    if (def.target !== "bridge") continue;
+    const value = bridge[def.field];
+    if (value === void 0) continue;
+    console.log(`  ${key}: ${formatFieldValue(value, def)}`);
   }
-  if (saved.telegram?.botToken && saved.telegram.botUsername) {
-    console.log(`  telegram.botToken: ${maskSecret(saved.telegram.botToken)}`);
-    console.log(`  telegram.botUsername: @${saved.telegram.botUsername}`);
-    if (!saved.telegram.hasMainWebApp) {
+}
+function printTelegramConfig(telegram) {
+  if (telegram?.botToken && telegram.botUsername) {
+    console.log(`  telegram.botToken: ${maskSecret(telegram.botToken)}`);
+    console.log(`  telegram.botUsername: @${telegram.botUsername}`);
+    if (!telegram.hasMainWebApp) {
       console.log("    INFO: Register Mini App in @BotFather for deep links to open in Telegram");
     }
-  } else if (saved.telegram?.botToken) {
-    console.log(`  telegram.botToken: ${maskSecret(saved.telegram.botToken)}`);
+  } else if (telegram?.botToken) {
+    console.log(`  telegram.botToken: ${maskSecret(telegram.botToken)}`);
     console.log("  telegram.botUsername: (not resolved)");
   } else {
     console.log("  telegram: not configured");
@@ -303,6 +325,16 @@ function printConfigSummary(saved) {
     console.log("    Example: pubblue configure --set telegram.botToken=<BOT_TOKEN>");
   }
 }
+function printConfigSummary(saved) {
+  if (!saved) {
+    console.log("Saved config: none");
+    return;
+  }
+  console.log("Saved config:");
+  console.log(`  apiKey: ${maskSecret(saved.apiKey)}`);
+  printBridgeConfig(saved.bridge ?? {});
+  printTelegramConfig(saved.telegram);
+}
 function registerConfigureCommand(program2) {
   program2.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").option(
     "--set <key=value>",
@@ -311,7 +343,7 @@ function registerConfigureCommand(program2) {
     []
   ).option("--unset <key>", "Unset config key (repeatable)", collectValues, []).option("--show", "Show saved configuration").action(
     async (opts) => {
-      const saved = loadConfig();
+      const saved = readConfig();
       const hasApiUpdate = Boolean(opts.apiKey || opts.apiKeyStdin);
       const hasSet = opts.set.length > 0;
       const hasUnset = opts.unset.length > 0;
@@ -349,7 +381,7 @@ function registerConfigureCommand(program2) {
             console.log("Telegram menu button reset to default.");
           } catch (error) {
             console.error(
-              `Warning: failed to reset Telegram menu button: ${error instanceof Error ? error.message : String(error)}`
+              `Warning: failed to reset Telegram menu button: ${errorMessage(error)}`
             );
           }
         }
@@ -389,21 +421,21 @@ function registerConfigureCommand(program2) {
 }
 
 // src/commands/live.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // package.json
 var package_default = {
   name: "pubblue",
-  version: "0.6.1",
-  description: "CLI tool for publishing content and running interactive sessions via pub.blue",
+  version: "0.6.8",
+  description: "CLI tool for publishing content and running live sessions via pub.blue",
   type: "module",
   bin: {
     pubblue: "./dist/index.js"
   },
   scripts: {
-    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",
+    build: "tsup src/index.ts src/live-daemon-entry.ts --format esm --dts --clean",
+    dev: "tsup src/index.ts src/live-daemon-entry.ts --format esm --watch",
     test: "vitest run",
     "test:watch": "vitest",
     lint: "tsc --noEmit"
@@ -455,39 +487,19 @@ function registerLiveCommands(program2) {
   registerDoctorCommand(program2);
 }
 function registerStartCommand(program2) {
-  program2.command("start").description("Start the agent daemon (registers presence, awaits live requests)").requiredOption("--agent-name <name>", "Agent display name shown to the browser user").option("--bridge <mode>", "Bridge mode: openclaw|none").option("--foreground", "Run in foreground (don't fork)").action(async (opts) => {
+  program2.command("start").description("Start the agent daemon (registers presence, awaits live requests)").requiredOption("--agent-name <name>", "Agent display name shown to the browser user").option("--bridge <mode>", "Bridge mode: openclaw|claude-code").action(async (opts) => {
     await ensureNodeDatachannelAvailable();
     writeLatestCliVersion(CLI_VERSION);
     const runtimeConfig = getConfig();
-    const apiClient = createApiClient(runtimeConfig);
     const bridgeMode = resolveBridgeMode(opts);
     const bridgeProcessEnv = buildBridgeProcessEnv(runtimeConfig.bridge);
     const socketPath = getAgentSocketPath();
     const infoPath = liveInfoPath("agent");
     const logPath = liveLogPath("agent");
     await stopOtherDaemons();
-    if (opts.foreground) {
-      const { startDaemon } = await import("./tunnel-daemon-BR5XKNEA.js");
-      console.log("Agent daemon starting in foreground...");
-      console.log("Press Ctrl+C to stop.");
-      try {
-        await startDaemon({
-          cliVersion: CLI_VERSION,
-          apiClient,
-          socketPath,
-          infoPath,
-          bridgeMode,
-          agentName: opts.agentName
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        failCli(`Daemon failed: ${message}`);
-      }
-      return;
-    }
     const { fork } = await import("child_process");
-    const daemonScript = path2.join(import.meta.dirname, "tunnel-daemon-entry.js");
-    const daemonLogFd = fs2.openSync(logPath, "a");
+    const daemonScript = path3.join(import.meta.dirname, "live-daemon-entry.js");
+    const daemonLogFd = fs3.openSync(logPath, "a");
     const child = fork(daemonScript, [], {
       detached: true,
       stdio: buildDaemonForkStdio(daemonLogFd),
@@ -502,7 +514,7 @@ function registerStartCommand(program2) {
         PUBBLUE_DAEMON_BRIDGE_MODE: bridgeMode
       }
     });
-    fs2.closeSync(daemonLogFd);
+    fs3.closeSync(daemonLogFd);
     if (child.connected) {
       child.disconnect();
     }
@@ -564,12 +576,13 @@ function registerStatusCommand(program2) {
       console.log(`  Last error: ${response.lastError}`);
     }
     const logPath = liveLogPath("agent");
-    if (fs2.existsSync(logPath)) {
+    if (fs3.existsSync(logPath)) {
       console.log(`  Log: ${logPath}`);
     }
     const bridge = response.bridge;
     if (bridge) {
-      console.log(`  Bridge: openclaw (${bridge.running ? "running" : "stopped"})`);
+      const bridgeLabel = response.bridgeMode ?? "unknown";
+      console.log(`  Bridge: ${bridgeLabel} (${bridge.running ? "running" : "stopped"})`);
       if (bridge.sessionId) {
         console.log(`  Bridge session: ${bridge.sessionId}`);
       }
@@ -593,10 +606,10 @@ function registerWriteCommand(program2) {
     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);
+      const filePath = path3.resolve(opts.file);
+      const ext = path3.extname(filePath).toLowerCase();
+      const bytes = fs3.readFileSync(filePath);
+      const filename = path3.basename(filePath);
       if (ext === ".html" || ext === ".htm") {
         msg = {
           id: generateMessageId(),
@@ -713,45 +726,29 @@ function registerDoctorCommand(program2) {
       const timeoutMs = timeoutSeconds * 1e3;
       const socketPath = getAgentSocketPath();
       const slug = await resolveActiveSlug();
-      const apiClient = createApiClient();
+      const apiClient = createClient();
       const fail = (message) => failCli(`Doctor failed: ${message}`);
       console.log(`Doctor: ${slug}`);
-      let statusResponse = null;
-      try {
-        statusResponse = await ipcCall(socketPath, {
-          method: "status",
-          params: {}
-        });
-      } catch (error) {
-        fail(
-          `daemon is unreachable (${error instanceof Error ? error.message : String(error)}).`
-        );
-      }
-      if (!statusResponse) {
-        fail("daemon status returned no response.");
-      }
-      const daemonStatus = statusResponse;
-      if (!daemonStatus.ok) {
-        fail(`daemon returned non-ok status: ${String(daemonStatus.error || "unknown error")}`);
-      }
-      if (!daemonStatus.connected) {
+      const statusResponse = await ipcCall(socketPath, {
+        method: "status",
+        params: {}
+      }).catch((error) => fail(`daemon is unreachable (${errorMessage(error)}).`));
+      if (!statusResponse.ok) {
+        fail(`daemon returned non-ok status: ${String(statusResponse.error || "unknown error")}`);
+      }
+      if (!statusResponse.connected) {
         fail("daemon is running but browser is not connected.");
       }
-      const channelNames = Array.isArray(daemonStatus.channels) ? daemonStatus.channels.map((entry) => String(entry)) : [];
+      const channelNames = Array.isArray(statusResponse.channels) ? statusResponse.channels.map((entry) => String(entry)) : [];
       for (const required of [CONTROL_CHANNEL, CHANNELS.CHAT, CHANNELS.CANVAS]) {
         if (!channelNames.includes(required)) {
           fail(`required channel is missing: ${required}`);
         }
       }
       console.log("Daemon/channel check: OK");
-      const live = await (async () => {
-        try {
-          return await apiClient.getLive(slug);
-        } catch (error) {
-          fail(`failed to fetch live info from API: ${formatApiError(error)}`);
-        }
-        throw new Error("unreachable");
-      })();
+      const live = await apiClient.getLive(slug).catch(
+        (error) => fail(`failed to fetch live info from API: ${formatApiError(error)}`)
+      );
       if (live.status !== "active") {
         fail(`API reports live is not active (status: ${live.status})`);
       }
@@ -932,7 +929,7 @@ function registerPubCommands(program2) {
   });
   program2.command("delete").description("Delete a pub").argument("<slug>", "Slug of the pub to delete").action(async (slug) => {
     const client = createClient();
-    await client.remove(slug);
+    await client.deletePub(slug);
     console.log(`Deleted: ${slug}`);
   });
 }