@lobu/worker 3.0.5 → 3.0.7

package/src/openclaw/processor.ts

@@ -0,0 +1,216 @@
+import { createLogger } from "@lobu/core";
+import type { AgentSessionEvent } from "@mariozechner/pi-coding-agent";
+import { formatToolExecution } from "../shared/processor-utils";
+
+const logger = createLogger("openclaw-processor");
+
+/**
+ * Processes Pi agent streaming events and extracts user-friendly content.
+ * Implements chronological display with tool progress and mixed text/tool output.
+ */
+export class OpenClawProgressProcessor {
+  private chronologicalOutput = "";
+  private lastSentContent = "";
+  private currentThinking = "";
+  private verboseLogging = false;
+  private finalResult: { text: string; isFinal: boolean } | null = null;
+  private hasStreamedText = false;
+  private fatalErrorMessage: string | null = null;
+
+  setVerboseLogging(enabled: boolean): void {
+    this.verboseLogging = enabled;
+    logger.info(`Verbose logging ${enabled ? "enabled" : "disabled"}`);
+  }
+
+  /**
+   * Process a Pi agent session event and append to chronological output.
+   * Returns true if new content was appended.
+   */
+  processEvent(event: AgentSessionEvent): boolean {
+    switch (event.type) {
+      case "message_update": {
+        if (event.message.role !== "assistant") {
+          return false;
+        }
+        const assistantEvent = event.assistantMessageEvent;
+
+        if (assistantEvent.type === "text_delta") {
+          this.hasStreamedText = true;
+          this.chronologicalOutput += assistantEvent.delta;
+          return true;
+        }
+
+        if (assistantEvent.type === "thinking_delta") {
+          this.currentThinking += assistantEvent.delta;
+          if (this.verboseLogging) {
+            this.chronologicalOutput += assistantEvent.delta;
+            return true;
+          }
+          return false;
+        }
+
+        if (assistantEvent.type === "thinking_start" && this.verboseLogging) {
+          this.chronologicalOutput += "\n💭 *Reasoning:*\n";
+          return true;
+        }
+
+        if (assistantEvent.type === "thinking_end" && this.verboseLogging) {
+          this.chronologicalOutput += "\n\n";
+          return true;
+        }
+
+        return false;
+      }
+
+      case "message_end": {
+        if (event.message.role !== "assistant") {
+          return false;
+        }
+        const assistantMessage = event.message as {
+          stopReason?: string;
+          errorMessage?: string;
+        };
+        if (
+          assistantMessage.stopReason === "error" &&
+          typeof assistantMessage.errorMessage === "string" &&
+          assistantMessage.errorMessage.trim()
+        ) {
+          this.fatalErrorMessage = assistantMessage.errorMessage.trim();
+          return false;
+        }
+        // If text was already streamed via deltas, skip extraction
+        if (this.hasStreamedText) {
+          return false;
+        }
+        // Fallback: extract text from final message content
+        const content = event.message.content;
+        if (!Array.isArray(content)) {
+          return false;
+        }
+        let extracted = false;
+        for (const block of content) {
+          if (
+            block &&
+            typeof block === "object" &&
+            "type" in block &&
+            (block as { type: string }).type === "text" &&
+            "text" in block &&
+            typeof (block as { text: unknown }).text === "string"
+          ) {
+            const text = (block as { text: string }).text;
+            if (text.trim()) {
+              this.chronologicalOutput += text;
+              extracted = true;
+            }
+          }
+        }
+        return extracted;
+      }
+
+      case "tool_execution_start": {
+        const params =
+          event.args && typeof event.args === "object"
+            ? (event.args as Record<string, unknown>)
+            : {};
+        const formatted = formatToolExecution(
+          event.toolName,
+          params,
+          this.verboseLogging
+        );
+        if (formatted) {
+          this.chronologicalOutput += `${formatted}\n`;
+          return true;
+        }
+        return false;
+      }
+
+      case "auto_compaction_start": {
+        this.chronologicalOutput += "🗜️ *Compacting context...*\n";
+        return true;
+      }
+
+      case "auto_compaction_end": {
+        if (event.aborted) {
+          this.chronologicalOutput += "🗜️ *Compaction aborted*\n";
+        } else if (event.result) {
+          this.chronologicalOutput += "🗜️ *Context compacted*\n";
+        }
+        return true;
+      }
+
+      case "auto_retry_start": {
+        this.chronologicalOutput += `🔄 *Retrying (attempt ${event.attempt}/${event.maxAttempts})...*\n`;
+        return true;
+      }
+
+      case "auto_retry_end": {
+        if (!event.success && event.finalError) {
+          this.chronologicalOutput += `🔄 *Retry failed: ${event.finalError}*\n`;
+          return true;
+        }
+        return false;
+      }
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Get delta since last sent content.
+   * Returns null if no new content.
+   */
+  getDelta(): string | null {
+    const fullContent = this.chronologicalOutput.trim();
+
+    if (!fullContent) {
+      return null;
+    }
+
+    if (fullContent === this.lastSentContent) {
+      return null;
+    }
+
+    if (this.lastSentContent && fullContent.startsWith(this.lastSentContent)) {
+      const delta = fullContent.slice(this.lastSentContent.length);
+      this.lastSentContent = fullContent;
+      return delta;
+    }
+
+    this.lastSentContent = fullContent;
+    return fullContent;
+  }
+
+  setFinalResult(result: { text: string; isFinal: boolean }): void {
+    this.finalResult = result;
+  }
+
+  getFinalResult(): { text: string; isFinal: boolean } | null {
+    const result = this.finalResult;
+    this.finalResult = null;
+    return result;
+  }
+
+  consumeFatalErrorMessage(): string | null {
+    const result = this.fatalErrorMessage;
+    this.fatalErrorMessage = null;
+    return result;
+  }
+
+  getCurrentThinking(): string | null {
+    return this.currentThinking || null;
+  }
+
+  getOutputSnapshot(): string {
+    return this.chronologicalOutput.trim();
+  }
+
+  reset(): void {
+    this.lastSentContent = "";
+    this.chronologicalOutput = "";
+    this.currentThinking = "";
+    this.finalResult = null;
+    this.hasStreamedText = false;
+    this.fatalErrorMessage = null;
+  }
+}

package/src/openclaw/session-context.ts

@@ -0,0 +1,277 @@
+import {
+  type ConfigProviderMeta,
+  createLogger,
+  type McpToolDef,
+} from "@lobu/core";
+import { ensureBaseUrl } from "../core/url-utils";
+
+const logger = createLogger("openclaw-session-context");
+
+interface McpStatus {
+  id: string;
+  name: string;
+  requiresAuth: boolean;
+  requiresInput: boolean;
+  authenticated: boolean;
+  configured: boolean;
+}
+
+export interface ProviderConfig {
+  credentialEnvVarName?: string;
+  defaultProvider?: string;
+  defaultModel?: string;
+  cliBackends?: Array<{
+    providerId: string;
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    modelArg?: string;
+    sessionArg?: string;
+  }>;
+  providerBaseUrlMappings?: Record<string, string>;
+  /** Dynamic provider metadata from config-driven providers */
+  configProviders?: Record<string, ConfigProviderMeta>;
+  /** Credential env var placeholders for proxy mode (e.g. Z_AI_API_KEY → "lobu-proxy") */
+  credentialPlaceholders?: Record<string, string>;
+}
+
+interface SkillContent {
+  name: string;
+  content: string;
+}
+
+interface SessionContextResponse {
+  agentInstructions: string;
+  platformInstructions: string;
+  networkInstructions: string;
+  skillsInstructions: string;
+  mcpStatus: McpStatus[];
+  mcpTools?: Record<string, McpToolDef[]>;
+  mcpInstructions?: Record<string, string>;
+  mcpContext?: Record<string, string>;
+  providerConfig?: ProviderConfig;
+  skillsConfig?: SkillContent[];
+}
+
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+const DEFAULT_SESSION_CONTEXT = {
+  gatewayInstructions: "",
+  providerConfig: {} as ProviderConfig,
+  skillsConfig: [] as SkillContent[],
+  mcpTools: {} as Record<string, McpToolDef[]>,
+  mcpContext: {} as Record<string, string>,
+} as const;
+
+// Module-level cache for session context
+let cachedResult: {
+  gatewayInstructions: string;
+  providerConfig: ProviderConfig;
+  skillsConfig: SkillContent[];
+  mcpTools: Record<string, McpToolDef[]>;
+  mcpContext: Record<string, string>;
+  cachedAt: number;
+} | null = null;
+
+/**
+ * Invalidate the session context cache.
+ * Called by the SSE client when a config_changed event is received.
+ */
+export function invalidateSessionContextCache(): void {
+  cachedResult = null;
+  logger.info("Session context cache invalidated");
+}
+
+function buildMcpInstructions(
+  mcpStatus: McpStatus[],
+  mcpToolIds: Set<string>
+): string {
+  if (!mcpStatus || mcpStatus.length === 0) {
+    return "";
+  }
+
+  // MCPs with no tools at all that need setup (explicit auth/input requirements)
+  const undiscoveredMcps = mcpStatus.filter(
+    (mcp) =>
+      !mcpToolIds.has(mcp.id) &&
+      ((mcp.requiresAuth && !mcp.authenticated) ||
+        (mcp.requiresInput && !mcp.configured))
+  );
+
+  // MCPs with tools visible but still needing auth to use them
+  const unauthenticatedMcps = mcpStatus.filter(
+    (mcp) => mcpToolIds.has(mcp.id) && mcp.requiresAuth && !mcp.authenticated
+  );
+
+  // MCPs with no tools and no explicit auth requirement — may need plugin-level
+  // authentication (e.g. owletto device auth flow via owletto_login tool)
+  const pluginAuthMcps = mcpStatus.filter(
+    (mcp) => !mcpToolIds.has(mcp.id) && !mcp.requiresAuth && !mcp.requiresInput
+  );
+
+  if (
+    undiscoveredMcps.length === 0 &&
+    unauthenticatedMcps.length === 0 &&
+    pluginAuthMcps.length === 0
+  ) {
+    return "";
+  }
+
+  const lines: string[] = ["## MCP Tools Requiring Setup"];
+
+  for (const mcp of undiscoveredMcps) {
+    const reasons: string[] = [];
+    if (mcp.requiresAuth && !mcp.authenticated) {
+      reasons.push("OAuth authentication");
+    }
+    if (mcp.requiresInput && !mcp.configured) {
+      reasons.push("configuration");
+    }
+
+    lines.push(
+      `- ⚠️ **${mcp.name}** (id: ${mcp.id}): Requires ${reasons.join(" and ")}. Start the relevant login flow if a login tool exists; otherwise tell the user an admin must connect it.`
+    );
+  }
+
+  for (const mcp of unauthenticatedMcps) {
+    lines.push(
+      `- ⚠️ **${mcp.name}** (id: ${mcp.id}): Tools are visible but require authentication to use. Start the relevant login flow if available; otherwise tell the user an admin must connect it.`
+    );
+  }
+
+  for (const mcp of pluginAuthMcps) {
+    lines.push(
+      `- **IMPORTANT** — **${mcp.name}** (id: ${mcp.id}): Memory tools (save_knowledge, search_knowledge) are NOT available because authentication is required. You MUST call the \`${mcp.id}_login\` tool NOW to start the login flow. After the user completes login in their browser, call \`${mcp.id}_login_check\` to finish authentication. Do NOT tell the user that memory is unavailable — instead, initiate login immediately.`
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function buildMcpServerInstructions(
+  mcpInstructions: Record<string, string>
+): string {
+  const entries = Object.entries(mcpInstructions).filter(([, v]) => v);
+  if (entries.length === 0) return "";
+
+  const lines: string[] = ["## MCP Server Instructions", ""];
+  for (const [mcpId, instructions] of entries) {
+    lines.push(`### ${mcpId}`, "", instructions, "");
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Fetch session context from gateway for OpenClaw worker.
+ * Returns gateway instructions and dynamic provider configuration.
+ * Caches the result until invalidated by a config_changed SSE event.
+ * Skips MCP server config (OpenClaw doesn't use Claude SDK's MCP format).
+ */
+export async function getOpenClawSessionContext(): Promise<{
+  gatewayInstructions: string;
+  providerConfig: ProviderConfig;
+  skillsConfig: SkillContent[];
+  mcpTools: Record<string, McpToolDef[]>;
+  mcpContext: Record<string, string>;
+}> {
+  if (cachedResult && Date.now() - cachedResult.cachedAt < CACHE_TTL_MS) {
+    logger.debug("Returning cached session context");
+    return cachedResult;
+  }
+
+  const dispatcherUrl = process.env.DISPATCHER_URL;
+  const workerToken = process.env.WORKER_TOKEN;
+
+  if (!dispatcherUrl || !workerToken) {
+    logger.warn("Missing dispatcher URL or worker token for session context");
+    return { ...DEFAULT_SESSION_CONTEXT };
+  }
+
+  try {
+    const url = new URL(
+      "/worker/session-context",
+      ensureBaseUrl(dispatcherUrl)
+    );
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${workerToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      logger.warn("Gateway returned non-success status for session context", {
+        status: response.status,
+      });
+      return { ...DEFAULT_SESSION_CONTEXT };
+    }
+
+    const data = (await response.json()) as SessionContextResponse;
+
+    logger.info(
+      `Received session context: ${data.platformInstructions.length} chars platform instructions, ${data.mcpStatus.length} MCP status entries, provider: ${data.providerConfig?.defaultProvider || "none"}, cliBackends: ${data.providerConfig?.cliBackends?.map((b) => b.name).join(", ") || "none"}`
+    );
+
+    const toolMcpIds = new Set(Object.keys(data.mcpTools || {}));
+    const mcpSetupInstructions = buildMcpInstructions(
+      data.mcpStatus,
+      toolMcpIds
+    );
+    // Include MCP server instructions for all servers (with or without tools).
+    // These provide workspace context (available connectors, entity schemas, etc.)
+    // that helps the agent use the tools effectively.
+    const mcpServerInstructions = buildMcpServerInstructions(
+      data.mcpInstructions || {}
+    );
+
+    const gatewayInstructions = [
+      data.agentInstructions,
+      data.platformInstructions,
+      data.networkInstructions,
+      data.skillsInstructions,
+      mcpSetupInstructions,
+      mcpServerInstructions,
+    ]
+      .filter(Boolean)
+      .join("\n\n");
+
+    const mcpTools = data.mcpTools || {};
+
+    logger.info(
+      `Built gateway instructions: agent (${(data.agentInstructions || "").length} chars) + platform (${data.platformInstructions.length} chars) + network (${data.networkInstructions.length} chars) + skills (${(data.skillsInstructions || "").length} chars) + MCP setup (${mcpSetupInstructions.length} chars) + MCP server instructions (${mcpServerInstructions.length} chars), mcpTools: ${Object.keys(mcpTools).length} servers`
+    );
+
+    const mcpContext = data.mcpContext || {};
+
+    const result = {
+      gatewayInstructions,
+      providerConfig: data.providerConfig || {},
+      skillsConfig: data.skillsConfig || [],
+      mcpTools,
+      mcpContext,
+    };
+
+    // Don't cache if any authenticated MCP returned no tools — likely a
+    // transient upstream failure that should be retried on the next message.
+    const hasEmptyAuthenticatedMcp = data.mcpStatus.some(
+      (mcp) => mcp.authenticated && !toolMcpIds.has(mcp.id)
+    );
+    if (!hasEmptyAuthenticatedMcp) {
+      cachedResult = { ...result, cachedAt: Date.now() };
+    } else {
+      logger.warn(
+        "Skipping session context cache — authenticated MCP(s) returned no tools",
+        {
+          emptyMcps: data.mcpStatus
+            .filter((mcp) => mcp.authenticated && !toolMcpIds.has(mcp.id))
+            .map((mcp) => mcp.id),
+        }
+      );
+    }
+
+    return result;
+  } catch (error) {
+    logger.error("Failed to fetch session context from gateway", { error });
+    return { ...DEFAULT_SESSION_CONTEXT };
+  }
+}

package/src/openclaw/tool-policy.ts

@@ -0,0 +1,212 @@
+import type { ToolsConfig } from "@lobu/core";
+
+export type BashCommandPolicy = {
+  allowAll: boolean;
+  allowPrefixes: string[];
+  denyPrefixes: string[];
+};
+
+export type ToolPolicy = {
+  toolsConfig?: ToolsConfig;
+  allowedPatterns: string[];
+  deniedPatterns: string[];
+  strictMode: boolean;
+  bashPolicy: BashCommandPolicy;
+};
+
+const DEFAULT_PACKAGE_MANAGER_DENY_PREFIXES = [
+  "apt ",
+  "apt-get ",
+  "yum ",
+  "dnf ",
+  "apk ",
+  "pacman ",
+  "zypper ",
+  "brew ",
+  "nix-shell ",
+  "nix-env ",
+  "nix profile ",
+  "sudo apt ",
+  "sudo apt-get ",
+  "sudo yum ",
+  "sudo dnf ",
+  "sudo apk ",
+  "sudo pacman ",
+  "sudo zypper ",
+  "sudo brew ",
+  "sudo nix-shell ",
+  "sudo nix-env ",
+  "sudo nix profile ",
+];
+
+export function isDirectPackageInstallCommand(command: string): boolean {
+  const trimmed = command.trim().toLowerCase();
+  if (!trimmed) {
+    return false;
+  }
+
+  return DEFAULT_PACKAGE_MANAGER_DENY_PREFIXES.some((prefix) =>
+    trimmed.startsWith(prefix.toLowerCase())
+  );
+}
+
+function normalizePattern(pattern: string): string {
+  return pattern.trim();
+}
+
+function normalizeToolName(name: string): string {
+  return name.trim().toLowerCase();
+}
+
+export function normalizeToolList(value?: string | string[]): string[] {
+  if (!value) {
+    return [];
+  }
+  const rawList = Array.isArray(value) ? value : value.split(/[,\n]/);
+  return rawList
+    .map((entry) =>
+      typeof entry === "string" ? entry.trim() : String(entry).trim()
+    )
+    .filter((entry) => entry.length > 0);
+}
+
+function parseBashFilter(pattern: string): string | null {
+  const match = pattern.match(/^Bash\(([^:]+):\*\)$/i);
+  if (!match) {
+    return null;
+  }
+  const prefix = match[1]?.trim();
+  return prefix ? prefix : null;
+}
+
+function matchesToolPattern(toolName: string, pattern: string): boolean {
+  const normalizedTool = normalizeToolName(toolName);
+  const normalizedPattern = normalizePattern(pattern);
+  const normalizedPatternLower = normalizedPattern.toLowerCase();
+
+  if (normalizedPattern === "*") {
+    return true;
+  }
+
+  if (normalizedPatternLower.endsWith("*")) {
+    const prefix = normalizedPatternLower.slice(0, -1);
+    return normalizedTool.startsWith(prefix);
+  }
+
+  return normalizedTool === normalizedPatternLower;
+}
+
+export function buildToolPolicy(params: {
+  toolsConfig?: ToolsConfig;
+  allowedTools?: string | string[];
+  disallowedTools?: string | string[];
+}): ToolPolicy {
+  const allowedPatterns = normalizeToolList(params.allowedTools);
+  const deniedPatterns = normalizeToolList(params.disallowedTools);
+  const toolsConfig = params.toolsConfig;
+  const strictMode = toolsConfig?.strictMode === true;
+
+  const mergedAllowed = [
+    ...(toolsConfig?.allowedTools ?? []),
+    ...allowedPatterns,
+  ].map(normalizePattern);
+  const mergedDenied = [
+    ...(toolsConfig?.deniedTools ?? []),
+    ...deniedPatterns,
+  ].map(normalizePattern);
+
+  const bashAllowPrefixes = mergedAllowed
+    .map((pattern) => parseBashFilter(pattern))
+    .filter((prefix): prefix is string => Boolean(prefix));
+
+  const bashDenyPrefixes = mergedDenied
+    .map((pattern) => parseBashFilter(pattern))
+    .filter((prefix): prefix is string => Boolean(prefix));
+
+  const bashAllowAll = mergedAllowed.some((pattern) =>
+    matchesToolPattern("bash", pattern)
+  );
+
+  return {
+    toolsConfig,
+    allowedPatterns: mergedAllowed,
+    deniedPatterns: mergedDenied,
+    strictMode,
+    bashPolicy: {
+      allowAll: bashAllowAll,
+      allowPrefixes: bashAllowPrefixes,
+      denyPrefixes: [
+        ...DEFAULT_PACKAGE_MANAGER_DENY_PREFIXES,
+        ...bashDenyPrefixes,
+      ],
+    },
+  };
+}
+
+export function isToolAllowedByPolicy(
+  toolName: string,
+  policy: ToolPolicy
+): boolean {
+  const normalizedName = normalizeToolName(toolName);
+  const { allowedPatterns, deniedPatterns, strictMode } = policy;
+
+  const explicitDenied = deniedPatterns.some(
+    (pattern) =>
+      !parseBashFilter(pattern) && matchesToolPattern(normalizedName, pattern)
+  );
+  if (explicitDenied) {
+    return false;
+  }
+
+  if (normalizedName === "bash") {
+    if (strictMode) {
+      const explicitlyAllowed = allowedPatterns.some((pattern) =>
+        matchesToolPattern(normalizedName, pattern)
+      );
+      const hasCommandAllowlist = policy.bashPolicy.allowPrefixes.length > 0;
+      return explicitlyAllowed || hasCommandAllowlist;
+    }
+    return true;
+  }
+
+  if (!strictMode) {
+    return true;
+  }
+
+  return allowedPatterns.some((pattern) =>
+    matchesToolPattern(normalizedName, pattern)
+  );
+}
+
+export function enforceBashCommandPolicy(
+  command: string,
+  policy: BashCommandPolicy
+): void {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return;
+  }
+
+  const normalizedCommand = trimmed.toLowerCase();
+  const denyMatchPrefix = policy.denyPrefixes.find((prefix) =>
+    normalizedCommand.startsWith(prefix.toLowerCase())
+  );
+  if (denyMatchPrefix) {
+    throw new Error("Bash command denied by policy");
+  }
+
+  if (policy.allowAll) {
+    return;
+  }
+
+  if (policy.allowPrefixes.length === 0) {
+    return;
+  }
+
+  const allowMatch = policy.allowPrefixes.some((prefix) =>
+    normalizedCommand.startsWith(prefix.toLowerCase())
+  );
+  if (!allowMatch) {
+    throw new Error("Bash command not allowed by policy");
+  }
+}