pubblue 0.6.9 → 0.7.0

package/dist/{chunk-JSX5KHV3.js → chunk-5ODXW2EM.js}

@@ -56,8 +56,8 @@ var PubApiClient = class {
   getApiKey() {
     return this.apiKey;
   }
-  async request(path4, options = {}) {
-    const url = new URL(path4, this.baseUrl);
+  async request(path5, options = {}) {
+    const url = new URL(path5, this.baseUrl);
     const res = await fetch(url, {
       ...options,
       headers: {
@@ -169,8 +169,8 @@ var PubApiClient = class {
       params.set("daemonSessionId", daemonSessionId);
     }
     const query = params.toString();
-    const path4 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
-    const data = await this.request(path4);
+    const path5 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
+    const data = await this.request(path5);
     return data.live;
   }
   async signalAnswer(opts) {
@@ -185,8 +185,8 @@ var PubApiClient = class {
       params.set("daemonSessionId", daemonSessionId);
     }
     const query = params.toString();
-    const path4 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
-    await this.request(path4, { method: "DELETE" });
+    const path5 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
+    await this.request(path5, { method: "DELETE" });
   }
   // -- Telegram bot token ---------------------------------------------------
   async uploadBotToken(opts) {
@@ -809,25 +809,289 @@ async function createClaudeCodeBridgeRunner(config, abortSignal) {
   };
 }
 
+// src/lib/live-bridge-claude-sdk.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+async function tryImportSdk() {
+  try {
+    return await import("./sdk-IV5ZYS3G.js");
+  } catch {
+    return null;
+  }
+}
+function isClaudeSdkAvailableInEnv(env) {
+  return isClaudeCodeAvailableInEnv(env);
+}
+async function isClaudeSdkImportable() {
+  return await tryImportSdk() !== null;
+}
+function buildSdkSessionOptions(env = process.env) {
+  const model = env.CLAUDE_CODE_MODEL?.trim() || "claude-sonnet-4-6";
+  const claudePath = resolveClaudeCodePath(env);
+  const allowedToolsRaw = env.CLAUDE_CODE_ALLOWED_TOOLS?.trim();
+  const allowedTools = allowedToolsRaw ? allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+  const sdkEnv = { ...env };
+  delete sdkEnv.CLAUDECODE;
+  return { model, claudePath, allowedTools, sdkEnv };
+}
+function buildAppendSystemPrompt(bridgeSystemPrompt, env = process.env) {
+  const userSystemPrompt = env.CLAUDE_CODE_APPEND_SYSTEM_PROMPT?.trim();
+  const effective = [bridgeSystemPrompt, userSystemPrompt].filter(Boolean).join("\n\n");
+  return effective.length > 0 ? effective : void 0;
+}
+async function runClaudeSdkBridgeStartupProbe(env = process.env) {
+  const { model, claudePath, allowedTools } = buildSdkSessionOptions(env);
+  const cwd = env.CLAUDE_CODE_CWD?.trim() || env.PUBBLUE_PROJECT_ROOT || void 0;
+  const sdk = await tryImportSdk();
+  if (!sdk) {
+    throw new Error(
+      "Claude Agent SDK (@anthropic-ai/claude-agent-sdk) is not importable. Install it and retry."
+    );
+  }
+  await runAgentWritePongProbe({
+    label: "Claude SDK",
+    baseEnv: env,
+    execute: async (probeEnv) => {
+      const probeEnvClean = { ...probeEnv };
+      delete probeEnvClean.CLAUDECODE;
+      const socketPath = probeEnv.PUBBLUE_AGENT_SOCKET ?? "";
+      const logPath = path2.join(os2.tmpdir(), "pubblue-sdk-probe.log");
+      const appendLog = (line) => {
+        try {
+          fs2.appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+        } catch {
+        }
+      };
+      appendLog(`probe start socket=${socketPath}`);
+      const prompt = [
+        "This is a startup connectivity probe.",
+        "Run this exact shell command now:",
+        `PUBBLUE_AGENT_SOCKET=${socketPath} pubblue write "pong"`,
+        "Do not explain. Just execute it."
+      ].join("\n");
+      const q = sdk.query({
+        prompt,
+        options: {
+          model,
+          pathToClaudeCodeExecutable: claudePath,
+          env: probeEnvClean,
+          allowedTools,
+          cwd: os2.tmpdir(),
+          maxTurns: 2,
+          persistSession: false,
+          canUseTool: async (toolName, input) => {
+            appendLog(`canUseTool: tool=${toolName}`);
+            return { behavior: "allow", updatedInput: input };
+          }
+        }
+      });
+      for await (const msg of q) {
+        appendLog(`msg: type=${msg.type} ${JSON.stringify(msg).slice(0, 300)}`);
+      }
+      appendLog("probe stream completed");
+    }
+  });
+  return { claudePath, cwd };
+}
+var MAX_SESSION_RECREATIONS = 2;
+async function createClaudeSdkBridgeRunner(config, abortSignal) {
+  const { slug, sendMessage, debugLog, sessionBriefing } = config;
+  const env = process.env;
+  const sdk = await tryImportSdk();
+  if (!sdk) {
+    throw new Error("Claude Agent SDK is not importable.");
+  }
+  const { model, claudePath, allowedTools, sdkEnv } = buildSdkSessionOptions(env);
+  const appendSystemPrompt = buildAppendSystemPrompt(config.instructions.systemPrompt, env);
+  let sessionId;
+  let forwardedMessageCount = 0;
+  let lastError;
+  let stopped = abortSignal?.aborted ?? false;
+  let sessionRecreations = 0;
+  let activeSession = null;
+  if (abortSignal) {
+    abortSignal.addEventListener(
+      "abort",
+      () => {
+        stopped = true;
+        activeSession?.close();
+      },
+      { once: true }
+    );
+  }
+  const canvasReminderEvery = resolveCanvasReminderEvery();
+  function createSession() {
+    const session2 = sdk.unstable_v2_createSession({
+      model,
+      pathToClaudeCodeExecutable: claudePath,
+      env: {
+        ...sdkEnv,
+        ...appendSystemPrompt ? { CLAUDE_CODE_APPEND_SYSTEM_PROMPT: appendSystemPrompt } : {}
+      },
+      allowedTools,
+      canUseTool: async (_tool, input) => ({ behavior: "allow", updatedInput: input })
+    });
+    activeSession = session2;
+    return session2;
+  }
+  async function consumeStream(session2) {
+    for await (const msg of session2.stream()) {
+      if (stopped) break;
+      if (msg.type === "assistant") {
+        debugLog(`sdk assistant message received`);
+      } else if (msg.type === "result") {
+        if ("session_id" in msg && typeof msg.session_id === "string") {
+          sessionId = msg.session_id;
+          debugLog(`captured session_id: ${sessionId}`);
+        }
+        if (msg.subtype !== "success") {
+          throw new Error(`Claude SDK result error: ${msg.subtype}`);
+        }
+      }
+    }
+  }
+  async function sendAndStream(session2, prompt) {
+    await session2.send(prompt);
+    await consumeStream(session2);
+  }
+  async function deliverWithRecovery(prompt) {
+    if (stopped) return;
+    try {
+      if (!activeSession) throw new Error("session not initialized");
+      await sendAndStream(activeSession, prompt);
+    } catch (error) {
+      const msg = errorMessage(error);
+      debugLog(`session error: ${msg}`, error);
+      if (stopped || sessionRecreations >= MAX_SESSION_RECREATIONS) {
+        throw error;
+      }
+      debugLog(`recreating session (attempt ${sessionRecreations + 1}/${MAX_SESSION_RECREATIONS})`);
+      sessionRecreations += 1;
+      try {
+        activeSession?.close();
+      } catch {
+      }
+      const newSession = createSession();
+      await sendAndStream(newSession, sessionBriefing);
+      debugLog("session briefing re-delivered after recovery");
+      await sendAndStream(newSession, prompt);
+    }
+  }
+  const session = createSession();
+  await sendAndStream(session, sessionBriefing);
+  debugLog("session briefing delivered via SDK");
+  const queue = createBridgeEntryQueue({
+    onEntry: async (entry) => {
+      const chat = readTextChatMessage(entry);
+      if (chat) {
+        const includeCanvasReminder = shouldIncludeCanvasPolicyReminder(
+          forwardedMessageCount + 1,
+          canvasReminderEvery
+        );
+        const prompt = buildInboundPrompt(slug, chat, includeCanvasReminder, config.instructions);
+        await deliverWithRecovery(prompt);
+        forwardedMessageCount += 1;
+        config.onDeliveryUpdate?.({
+          channel: entry.channel,
+          messageId: entry.msg.id,
+          stage: "confirmed"
+        });
+        return;
+      }
+      const renderError = readRenderErrorMessage(entry);
+      if (renderError) {
+        const prompt = buildRenderErrorPrompt(slug, renderError, config.instructions);
+        await deliverWithRecovery(prompt);
+        forwardedMessageCount += 1;
+        config.onDeliveryUpdate?.({
+          channel: entry.channel,
+          messageId: entry.msg.id,
+          stage: "confirmed"
+        });
+        return;
+      }
+      if (entry.msg.type === "binary" || entry.msg.type === "stream-start" || entry.msg.type === "stream-end") {
+        const streamId = typeof entry.msg.meta?.streamId === "string" ? entry.msg.meta.streamId : void 0;
+        if (entry.msg.type === "binary" && streamId) return;
+        const deliveryMessageId = entry.msg.type === "stream-end" && streamId ? streamId : entry.msg.id;
+        config.onDeliveryUpdate?.({
+          channel: entry.channel,
+          messageId: deliveryMessageId,
+          stage: "failed",
+          error: "Attachments are not supported in Claude SDK bridge mode."
+        });
+        if (entry.msg.type !== "stream-end") {
+          void sendMessage(CHANNELS.CHAT, {
+            id: generateMessageId(),
+            type: "text",
+            data: "Attachments are not supported in Claude SDK bridge mode."
+          });
+        }
+      }
+    },
+    onError: (error, entry) => {
+      const message = errorMessage(error);
+      lastError = message;
+      debugLog(`bridge entry processing failed: ${message}`, error);
+      const deliveryMessageId = entry.msg.type === "stream-end" && typeof entry.msg.meta?.streamId === "string" ? entry.msg.meta.streamId : entry.msg.id;
+      config.onDeliveryUpdate?.({
+        channel: entry.channel,
+        messageId: deliveryMessageId,
+        stage: "failed",
+        error: message
+      });
+      void sendMessage(CHANNELS.CHAT, {
+        id: generateMessageId(),
+        type: "text",
+        data: `Bridge error: ${message}`
+      });
+    }
+  });
+  debugLog(`claude-sdk bridge runner started (path=${claudePath})`);
+  return {
+    enqueue: (entries) => queue.enqueue(entries),
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      try {
+        activeSession?.close();
+      } catch {
+      }
+      activeSession = null;
+      await queue.stop();
+    },
+    status() {
+      return {
+        running: !stopped,
+        sessionId,
+        lastError,
+        forwardedMessages: forwardedMessageCount
+      };
+    }
+  };
+}
+
 // src/lib/live-bridge-openclaw.ts
 import { execFile } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { promisify } from "util";
 
 // src/lib/live-bridge-openclaw-attachments.ts
 import { createHash } from "crypto";
 import { mkdirSync, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { basename, extname, join as join4 } from "path";
+import { basename, extname, join as join5 } from "path";
 
 // src/lib/live-bridge-openclaw-session.ts
 import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/lib/openclaw-paths.ts
 import { existsSync as existsSync3, readFileSync } from "fs";
 import { homedir } from "os";
-import { dirname, isAbsolute, join as join2, resolve } from "path";
+import { dirname, isAbsolute, join as join3, resolve } from "path";
 function trimToUndefined(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : void 0;
@@ -846,7 +1110,7 @@ function resolveBaseHome(env) {
 function expandHomePrefix(input, home) {
   if (input === "~") return home;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return join2(home, input.slice(2));
+    return join3(home, input.slice(2));
   }
   return input;
 }
@@ -864,12 +1128,12 @@ function resolveOpenClawHome(env = process.env) {
 function resolveOpenClawStateDir(env = process.env) {
   const configured = trimToUndefined(env.OPENCLAW_STATE_DIR);
   if (configured) return resolvePathFromInput(configured, env);
-  return join2(resolveOpenClawHome(env), ".openclaw");
+  return join3(resolveOpenClawHome(env), ".openclaw");
 }
 function resolveOpenClawConfigPath(env = process.env) {
   const configured = trimToUndefined(env.OPENCLAW_CONFIG_PATH);
   if (configured) return resolvePathFromInput(configured, env);
-  return join2(resolveOpenClawStateDir(env), "openclaw.json");
+  return join3(resolveOpenClawStateDir(env), "openclaw.json");
 }
 function readWorkspaceFromOpenClawConfig(configPath) {
   if (!existsSync3(configPath)) return null;
@@ -899,13 +1163,13 @@ function resolveOpenClawWorkspaceDir(env = process.env) {
   const configPath = resolveOpenClawConfigPath(env);
   const fromConfig = readWorkspaceFromOpenClawConfig(configPath);
   if (fromConfig) return resolveWorkspacePath(fromConfig, configPath, env);
-  return join2(resolveOpenClawStateDir(env), "workspace");
+  return join3(resolveOpenClawStateDir(env), "workspace");
 }
 
 // src/lib/live-bridge-openclaw-session.ts
 var OPENCLAW_MAIN_SESSION_KEY = "agent:main:main";
 function resolveOpenClawSessionsPath(env = process.env) {
-  return join3(resolveOpenClawStateDir(env), "agents", "main", "sessions", "sessions.json");
+  return join4(resolveOpenClawStateDir(env), "agents", "main", "sessions", "sessions.json");
 }
 function buildThreadCandidateKeys(threadId) {
   const trimmed = threadId?.trim();
@@ -981,7 +1245,7 @@ var DEFAULT_ATTACHMENT_MAX_BYTES = 5 * 1024 * 1024;
 function resolveAttachmentRootDir() {
   const configured = process.env.OPENCLAW_ATTACHMENT_DIR?.trim();
   if (configured) return configured;
-  return join4(resolveOpenClawStateDir(), "pubblue-inbox");
+  return join5(resolveOpenClawStateDir(), "pubblue-inbox");
 }
 function resolveAttachmentMaxBytes() {
   const raw = Number.parseInt(process.env.OPENCLAW_ATTACHMENT_MAX_BYTES ?? "", 10);
@@ -1022,12 +1286,12 @@ function resolveAttachmentFilename(params) {
 }
 function ensureDirectoryWritable(dirPath) {
   mkdirSync(dirPath, { recursive: true });
-  const probe = join4(dirPath, `.bridge-writecheck-${process.pid}-${Date.now()}`);
+  const probe = join5(dirPath, `.bridge-writecheck-${process.pid}-${Date.now()}`);
   writeFileSync(probe, "ok\n", { mode: 384 });
   unlinkSync2(probe);
 }
 function stageAttachment(params) {
-  const slugDir = join4(params.attachmentRoot, sanitizeFilename(params.slug));
+  const slugDir = join5(params.attachmentRoot, sanitizeFilename(params.slug));
   ensureDirectoryWritable(slugDir);
   const mime = (params.mime || "application/octet-stream").trim();
   const resolvedName = resolveAttachmentFilename({
@@ -1037,7 +1301,7 @@ function stageAttachment(params) {
     mime
   });
   const collisionSafeName = `${Date.now()}-${sanitizeFilename(params.messageId)}-${resolvedName}`;
-  const targetPath = join4(slugDir, collisionSafeName);
+  const targetPath = join5(slugDir, collisionSafeName);
   const tempPath = `${targetPath}.tmp-${process.pid}`;
   writeFileSync(tempPath, params.bytes, { mode: 384 });
   renameSync(tempPath, targetPath);
@@ -1219,9 +1483,9 @@ function getOpenClawDiscoveryPaths(env = process.env) {
   return [
     .../* @__PURE__ */ new Set([
       "/app/dist/index.js",
-      join5(home, "openclaw", "dist", "index.js"),
-      join5(stateDir, "openclaw"),
-      join5(home, ".openclaw", "openclaw"),
+      join6(home, "openclaw", "dist", "index.js"),
+      join6(stateDir, "openclaw"),
+      join6(home, ".openclaw", "openclaw"),
       "/usr/local/bin/openclaw",
       "/opt/homebrew/bin/openclaw"
     ])
@@ -1258,7 +1522,7 @@ function resolveOpenClawPath(env = process.env) {
       "OpenClaw executable was not found.",
       "Configure it with: pubblue configure --set openclaw.path=/absolute/path/to/openclaw",
       "Or set OPENCLAW_PATH in environment.",
-      "Checked: " + discoveryPaths.join(", ")
+      `Checked: ${discoveryPaths.join(", ")}`
     ].join(" ")
   );
 }
@@ -1486,35 +1750,35 @@ async function createOpenClawBridgeRunner(config) {
 }
 
 // src/lib/live-runtime/daemon-files.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // src/lib/config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var DEFAULT_BASE_URL = "https://silent-guanaco-514.convex.site";
 function getConfigDir(homeDir) {
   const explicit = process.env.PUBBLUE_CONFIG_DIR?.trim();
   if (explicit) return explicit;
   if (homeDir) {
-    return path2.join(path2.resolve(homeDir), ".openclaw", "pubblue");
+    return path3.join(path3.resolve(homeDir), ".openclaw", "pubblue");
   }
-  return path2.join(resolveOpenClawStateDir(), "pubblue");
+  return path3.join(resolveOpenClawStateDir(), "pubblue");
 }
 function getConfigPath(homeDir) {
   const dir = getConfigDir(homeDir);
-  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
-  return path2.join(dir, "config.json");
+  fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  return path3.join(dir, "config.json");
 }
 function readConfig(homeDir) {
   const configPath = getConfigPath(homeDir);
-  if (!fs2.existsSync(configPath)) return null;
-  const raw = fs2.readFileSync(configPath, "utf-8");
+  if (!fs3.existsSync(configPath)) return null;
+  const raw = fs3.readFileSync(configPath, "utf-8");
   return JSON.parse(raw);
 }
 function saveConfig(config, homeDir) {
   const configPath = getConfigPath(homeDir);
-  fs2.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `, {
     mode: 384
   });
@@ -1546,15 +1810,15 @@ function getTelegramMiniAppUrl(slug) {
 
 // src/lib/live-runtime/daemon-files.ts
 function liveInfoDir() {
-  const dir = path3.join(getConfigDir(), "lives");
-  fs3.mkdirSync(dir, { recursive: true });
+  const dir = path4.join(getConfigDir(), "lives");
+  fs4.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function liveInfoPath(slug) {
-  return path3.join(liveInfoDir(), `${slug}.json`);
+  return path4.join(liveInfoDir(), `${slug}.json`);
 }
 function liveLogPath(slug) {
-  return path3.join(liveInfoDir(), `${slug}.log`);
+  return path4.join(liveInfoDir(), `${slug}.log`);
 }
 function sanitizeSlugForFilename(slug) {
   const sanitized = slug.trim().replace(/[^a-zA-Z0-9._-]/g, "-");
@@ -1569,16 +1833,16 @@ function resolveSessionContentExtension(contentType) {
 function liveSessionContentPath(slug, contentType, rootDir) {
   const safeSlug = sanitizeSlugForFilename(slug);
   const ext = resolveSessionContentExtension(contentType);
-  return path3.join(rootDir ?? liveInfoDir(), `${safeSlug}.session-content.${ext}`);
+  return path4.join(rootDir ?? liveInfoDir(), `${safeSlug}.session-content.${ext}`);
 }
 function writeLiveSessionContentFile(params) {
   const filePath = liveSessionContentPath(params.slug, params.contentType, params.rootDir);
-  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
-  fs3.writeFileSync(filePath, params.content, "utf-8");
+  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(filePath, params.content, "utf-8");
   return filePath;
 }
 function latestCliVersionPath() {
-  return path3.join(liveInfoDir(), "cli-version.txt");
+  return path4.join(liveInfoDir(), "cli-version.txt");
 }
 function isMissingPathError(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return false;
@@ -1588,7 +1852,7 @@ function isMissingPathError(error) {
 function readLatestCliVersion(versionPath) {
   const resolved = versionPath || latestCliVersionPath();
   try {
-    const value = fs3.readFileSync(resolved, "utf-8").trim();
+    const value = fs4.readFileSync(resolved, "utf-8").trim();
     return value.length === 0 ? null : value;
   } catch (error) {
     if (isMissingPathError(error)) return null;
@@ -1599,13 +1863,13 @@ function writeLatestCliVersion(version, versionPath) {
   const trimmed = version.trim();
   if (trimmed.length === 0) return;
   const resolved = versionPath || latestCliVersionPath();
-  const dir = path3.dirname(resolved);
-  fs3.mkdirSync(dir, { recursive: true });
-  fs3.writeFileSync(resolved, trimmed, "utf-8");
+  const dir = path4.dirname(resolved);
+  fs4.mkdirSync(dir, { recursive: true });
+  fs4.writeFileSync(resolved, trimmed, "utf-8");
 }
 function readLogTail(logPath, maxChars = 4e3) {
   try {
-    const content = fs3.readFileSync(logPath, "utf-8");
+    const content = fs4.readFileSync(logPath, "utf-8");
     if (content.length <= maxChars) return content;
     return content.slice(-maxChars);
   } catch (error) {
@@ -1644,6 +1908,10 @@ export {
   buildClaudeArgs,
   runClaudeCodeBridgeStartupProbe,
   createClaudeCodeBridgeRunner,
+  isClaudeSdkAvailableInEnv,
+  isClaudeSdkImportable,
+  runClaudeSdkBridgeStartupProbe,
+  createClaudeSdkBridgeRunner,
   isOpenClawAvailable,
   resolveOpenClawRuntime,
   runOpenClawBridgeStartupProbe,