@bubblebrain-ai/bubble 0.0.10 → 0.0.11

package/dist/agent.d.ts

@@ -84,6 +84,7 @@ export declare class Agent {
     /** All deferred tools in this session (for tool_search to inspect). */
     listDeferredTools(): ToolRegistryEntry[];
     getContextUsageSnapshot(): ContextUsageSnapshot;
+    resetContextUsageAnchor(): void;
     /** Whether a given tool is deferred and not yet unlocked. */
     isDeferredAndLocked(name: string): boolean;
     private getActiveToolEntries;

package/dist/agent.js

@@ -131,6 +131,11 @@ export class Agent {
             skills: this.skillSummaries,
         });
     }
+    resetContextUsageAnchor() {
+        this.lastInputTokens = null;
+        this.lastAnchorMessageCount = null;
+        this.fileStateTracker?.invalidateReadHistory();
+    }
     /** Whether a given tool is deferred and not yet unlocked. */
     isDeferredAndLocked(name) {
         const tool = this.tools.get(name);

package/dist/cli.d.ts

@@ -2,7 +2,9 @@
  * CLI argument parsing.
  */
 import type { PermissionMode, ThinkingLevel } from "./types.js";
+export type CliCommand = "default" | "serve";
 export interface CliArgs {
+    command: CliCommand;
     model?: string;
     cwd: string;
     apiKey?: string;
@@ -12,6 +14,14 @@ export interface CliArgs {
     prompt?: string;
     thinkingLevel?: ThinkingLevel;
     mode?: PermissionMode;
+    /** `serve` subcommand: which host to run. */
+    serveHost?: "feishu";
+    /** `serve` subcommand: force wizard. */
+    setup?: boolean;
+    /** `serve` subcommand: kill stale instance (non-interactive). */
+    killOld?: boolean;
+    /** `serve` subcommand: connect then exit. */
+    dryRun?: boolean;
 }
 export declare function parseArgs(argv: string[]): CliArgs;
 export declare function printHelp(): void;

package/dist/cli.js

@@ -4,9 +4,18 @@
 import { isThinkingLevel } from "./variant/thinking-level.js";
 export function parseArgs(argv) {
     const args = {
+        command: "default",
         cwd: process.cwd(),
     };
-    for (let i = 0; i < argv.length; i++) {
+    // Subcommand detection: first non-flag argv item.
+    let startIndex = 0;
+    if (argv.length > 0 && !argv[0].startsWith("-")) {
+        if (argv[0] === "serve") {
+            args.command = "serve";
+            startIndex = 1;
+        }
+    }
+    for (let i = startIndex; i < argv.length; i++) {
         const arg = argv[i];
         switch (arg) {
             case "--model":
@@ -51,6 +60,18 @@ export function parseArgs(argv) {
             case "--dangerously-skip-permissions":
                 args.mode = "bypassPermissions";
                 break;
+            case "--feishu":
+                args.serveHost = "feishu";
+                break;
+            case "--setup":
+                args.setup = true;
+                break;
+            case "--kill-old":
+                args.killOld = true;
+                break;
+            case "--dry-run":
+                args.dryRun = true;
+                break;
             default:
                 if (!arg.startsWith("-") && !args.prompt) {
                     args.prompt = arg;
@@ -62,9 +83,11 @@ export function parseArgs(argv) {
 }
 export function printHelp() {
     console.log(`
-Usage: bubble [options] [prompt]
+Usage:
+  bubble [options] [prompt]              Start interactive TUI
+  bubble serve --feishu [options]        Run as a Feishu bot host
 
-Options:
+Options (default):
   -m, --model <model>      Model to use
   --cwd <dir>              Working directory (default: current)
   -k, --api-key <key>      API key for the active provider
@@ -77,5 +100,10 @@ Options:
                            Enable bypass mode (auto-approve EVERY tool; disables all safety prompts)
   -p, --print              Non-interactive mode (single prompt)
   -h, --help               Show this help
+
+Options (serve --feishu):
+  --setup                  Force the wizard (scan QR + bind first scope)
+  --kill-old               Kill any conflicting bubble instance for the same App ID
+  --dry-run                Connect once, then exit (smoke test)
 `);
 }

package/dist/feedback/collect.d.ts

@@ -0,0 +1,7 @@
+import type { Agent } from "../agent.js";
+import type { FeedbackPayload } from "./types.js";
+export interface CollectOptions {
+    description: string;
+    recentError?: string;
+}
+export declare function collectFeedback(agent: Agent, opts: CollectOptions): FeedbackPayload;

package/dist/feedback/collect.js

@@ -0,0 +1,119 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { redact } from "./redact.js";
+const MAX_TRANSCRIPT_MESSAGES = 10;
+const MAX_MESSAGE_CHARS = 4000;
+const MAX_TOTAL_TRANSCRIPT_CHARS = 32_000;
+const MAX_TOOL_ARG_CHARS = 80;
+export function collectFeedback(agent, opts) {
+    const transcript = buildTranscript(agent.messages);
+    return {
+        description: redact(opts.description),
+        version: readVersion(),
+        platform: process.platform,
+        arch: process.arch,
+        nodeVersion: process.version,
+        provider: agent.providerId || "unknown",
+        model: agent.model || "unknown",
+        transcript,
+        recentError: opts.recentError ? redact(opts.recentError) : undefined,
+        submittedAt: Date.now(),
+        clientId: randomUUID(),
+    };
+}
+function buildTranscript(messages) {
+    const candidates = messages
+        .filter((m) => m.role === "user" || m.role === "assistant")
+        .map((m) => ({ role: m.role, content: renderMessage(m) }))
+        .filter((m) => m.content.length > 0);
+    const tail = candidates.slice(-MAX_TRANSCRIPT_MESSAGES);
+    const out = [];
+    let totalChars = 0;
+    for (let i = tail.length - 1; i >= 0; i--) {
+        const m = tail[i];
+        const text = redact(truncate(m.content, MAX_MESSAGE_CHARS));
+        if (totalChars + text.length > MAX_TOTAL_TRANSCRIPT_CHARS)
+            break;
+        totalChars += text.length;
+        out.unshift({ role: m.role, content: text });
+    }
+    return out;
+}
+function renderMessage(m) {
+    const text = stringifyContent(m).trim();
+    if (m.role === "assistant") {
+        const toolSummary = summarizeToolCalls(m.toolCalls);
+        if (text && toolSummary)
+            return `${text}\n\n${toolSummary}`;
+        if (toolSummary)
+            return toolSummary;
+        return text;
+    }
+    return text;
+}
+function stringifyContent(m) {
+    if (typeof m.content === "string")
+        return m.content;
+    if (Array.isArray(m.content)) {
+        return m.content
+            .map((part) => {
+            if (part?.type === "text")
+                return part.text ?? "";
+            if (part?.type === "image_url")
+                return "[image]";
+            return "";
+        })
+            .join("\n");
+    }
+    return "";
+}
+function summarizeToolCalls(calls) {
+    if (!calls || calls.length === 0)
+        return "";
+    const parts = calls.map((c) => {
+        const argSummary = summarizeArgs(c.arguments);
+        return argSummary ? `${c.name}(${argSummary})` : c.name;
+    });
+    return `[used tools: ${parts.join(", ")}]`;
+}
+function summarizeArgs(rawJson) {
+    if (!rawJson)
+        return "";
+    try {
+        const parsed = JSON.parse(rawJson);
+        const entries = Object.entries(parsed)
+            .filter(([, v]) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+            .slice(0, 2)
+            .map(([k, v]) => {
+            const str = String(v);
+            return `${k}=${str.length > MAX_TOOL_ARG_CHARS ? str.slice(0, MAX_TOOL_ARG_CHARS) + "…" : str}`;
+        });
+        return entries.join(", ");
+    }
+    catch {
+        return "";
+    }
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max) + `\n…[truncated ${s.length - max} chars]`;
+}
+let cachedVersion;
+function readVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        const here = fileURLToPath(import.meta.url);
+        // From dist/feedback/collect.js → ../../package.json
+        const pkgPath = join(dirname(here), "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        cachedVersion = pkg.version || "unknown";
+    }
+    catch {
+        cachedVersion = "unknown";
+    }
+    return cachedVersion;
+}

package/dist/feedback/config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Endpoint and shared identifier for the feedback submission service.
+ *
+ * WORKER_URL is updated after the first `wrangler deploy` — until then the
+ * /feedback command will fail with a helpful error.
+ *
+ * CLIENT_SECRET is intentionally embedded in the published package. It is NOT
+ * a secret in the cryptographic sense — it exists only to make it slightly
+ * harder for casual scripts to spam the endpoint. The real abuse defence is
+ * per-IP rate limiting in the Worker plus the minimum-scope GitHub token.
+ */
+export declare const FEEDBACK_WORKER_URL = "https://bubble-feedback.chengshengdeng97.workers.dev/submit";
+export declare const FEEDBACK_CLIENT_SECRET = "a4826c3bde789f6e0b06ffbc39e64c029bf0b5d79f10dba0f2ad09362118dd2e";
+export declare function isFeedbackConfigured(): boolean;

package/dist/feedback/config.js

@@ -0,0 +1,16 @@
+/**
+ * Endpoint and shared identifier for the feedback submission service.
+ *
+ * WORKER_URL is updated after the first `wrangler deploy` — until then the
+ * /feedback command will fail with a helpful error.
+ *
+ * CLIENT_SECRET is intentionally embedded in the published package. It is NOT
+ * a secret in the cryptographic sense — it exists only to make it slightly
+ * harder for casual scripts to spam the endpoint. The real abuse defence is
+ * per-IP rate limiting in the Worker plus the minimum-scope GitHub token.
+ */
+export const FEEDBACK_WORKER_URL = "https://bubble-feedback.chengshengdeng97.workers.dev/submit";
+export const FEEDBACK_CLIENT_SECRET = "a4826c3bde789f6e0b06ffbc39e64c029bf0b5d79f10dba0f2ad09362118dd2e";
+export function isFeedbackConfigured() {
+    return !FEEDBACK_WORKER_URL.includes("REPLACE_AFTER_DEPLOY");
+}

package/dist/feedback/redact.d.ts

@@ -0,0 +1 @@
+export declare function redact(input: string): string;

package/dist/feedback/redact.js

@@ -0,0 +1,25 @@
+import { homedir } from "node:os";
+const PATTERNS = [
+    [/sk-ant-[A-Za-z0-9_-]{20,}/g, "sk-ant-***REDACTED***"],
+    [/sk-[A-Za-z0-9]{20,}/g, "sk-***REDACTED***"],
+    [/ghp_[A-Za-z0-9]{36}/g, "ghp_***REDACTED***"],
+    [/gh[oprsu]_[A-Za-z0-9]{36}/g, "gh*_***REDACTED***"],
+    [/github_pat_[A-Za-z0-9_]{82}/g, "github_pat_***REDACTED***"],
+    [/AKIA[0-9A-Z]{16}/g, "AKIA***REDACTED***"],
+    [/xox[pboasr]-[A-Za-z0-9-]{10,}/g, "xox*-***REDACTED***"],
+    [/AIza[0-9A-Za-z_-]{35}/g, "AIza***REDACTED***"],
+    [/Bearer\s+[A-Za-z0-9._-]{20,}/g, "Bearer ***REDACTED***"],
+];
+export function redact(input) {
+    if (!input)
+        return input;
+    let out = input;
+    const home = homedir();
+    if (home && home !== "/" && out.includes(home)) {
+        out = out.split(home).join("~");
+    }
+    for (const [re, repl] of PATTERNS) {
+        out = out.replace(re, repl);
+    }
+    return out;
+}

package/dist/feedback/submit.d.ts

@@ -0,0 +1,6 @@
+import type { FeedbackPayload, SubmitResult } from "./types.js";
+export declare class FeedbackSubmitError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+export declare function submitFeedback(payload: FeedbackPayload): Promise<SubmitResult>;

package/dist/feedback/submit.js

@@ -0,0 +1,43 @@
+import { createHmac } from "node:crypto";
+import { FEEDBACK_CLIENT_SECRET, FEEDBACK_WORKER_URL, isFeedbackConfigured } from "./config.js";
+export class FeedbackSubmitError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "FeedbackSubmitError";
+    }
+}
+export async function submitFeedback(payload) {
+    if (!isFeedbackConfigured()) {
+        throw new FeedbackSubmitError("Feedback service is not configured (worker URL placeholder). See services/feedback-worker/README.");
+    }
+    const body = JSON.stringify(payload);
+    const signature = createHmac("sha256", FEEDBACK_CLIENT_SECRET).update(body).digest("hex");
+    let resp;
+    try {
+        resp = await fetch(FEEDBACK_WORKER_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Bubble-Auth": signature,
+            },
+            body,
+        });
+    }
+    catch (err) {
+        throw new FeedbackSubmitError(`Network error: ${err?.message ?? String(err)}`);
+    }
+    if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        if (resp.status === 429) {
+            throw new FeedbackSubmitError(text || "Rate limited — please try again later.", 429);
+        }
+        throw new FeedbackSubmitError(`Server returned ${resp.status}${text ? `: ${text.slice(0, 200)}` : ""}`, resp.status);
+    }
+    const json = (await resp.json());
+    if (!json.url || typeof json.number !== "number") {
+        throw new FeedbackSubmitError("Server returned malformed response");
+    }
+    return { url: json.url, number: json.number };
+}

package/dist/feedback/types.d.ts

@@ -0,0 +1,22 @@
+export interface TranscriptMessage {
+    role: "user" | "assistant" | "error";
+    content: string;
+    timestamp?: number;
+}
+export interface FeedbackPayload {
+    description: string;
+    version: string;
+    platform: string;
+    arch: string;
+    nodeVersion: string;
+    provider: string;
+    model: string;
+    transcript: TranscriptMessage[];
+    recentError?: string;
+    submittedAt: number;
+    clientId: string;
+}
+export interface SubmitResult {
+    url: string;
+    number: number;
+}

package/dist/feishu/agent-host/approval-card.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Format an ApprovalRequest into a user-readable card body. Kept separate
+ * from the UI controller so we can unit-test rendering without dragging in
+ * the channel mocks.
+ */
+import type { ApprovalRequest } from "../../approval/types.js";
+export interface ApprovalSummary {
+    title: string;
+    body: string;
+}
+export declare function formatApprovalRequest(req: ApprovalRequest): ApprovalSummary;

package/dist/feishu/agent-host/approval-card.js

@@ -0,0 +1,46 @@
+/**
+ * Format an ApprovalRequest into a user-readable card body. Kept separate
+ * from the UI controller so we can unit-test rendering without dragging in
+ * the channel mocks.
+ */
+const COMMAND_PREVIEW_MAX = 1200;
+const PATH_PREVIEW_MAX = 200;
+const CONTENT_PREVIEW_MAX = 2000;
+const DIFF_PREVIEW_MAX = 2400;
+export function formatApprovalRequest(req) {
+    switch (req.type) {
+        case "bash":
+            return {
+                title: "执行命令",
+                body: `\`\`\`bash\n${truncate(req.command, COMMAND_PREVIEW_MAX)}\n\`\`\`\n\n**cwd:** \`${truncate(req.cwd, PATH_PREVIEW_MAX)}\``,
+            };
+        case "write":
+            return {
+                title: req.fileExists ? "覆盖文件" : "新建文件",
+                body: [
+                    `**path:** \`${truncate(req.path, PATH_PREVIEW_MAX)}\``,
+                    req.diff
+                        ? `\n**diff:**\n\`\`\`diff\n${truncate(req.diff, DIFF_PREVIEW_MAX)}\n\`\`\``
+                        : `\n**content preview:**\n\`\`\`\n${truncate(req.content, CONTENT_PREVIEW_MAX)}\n\`\`\``,
+                ].join("\n"),
+            };
+        case "edit":
+            return {
+                title: "编辑文件",
+                body: [
+                    `**path:** \`${truncate(req.path, PATH_PREVIEW_MAX)}\``,
+                    `\n**diff:**\n\`\`\`diff\n${truncate(req.diff, DIFF_PREVIEW_MAX)}\n\`\`\``,
+                ].join("\n"),
+            };
+        case "lsp":
+            return {
+                title: `LSP 操作 (${req.operation})`,
+                body: `**path:** \`${truncate(req.path, PATH_PREVIEW_MAX)}\``,
+            };
+    }
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + "…";
+}

package/dist/feishu/agent-host/approval-ui.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Feishu-side approval handler.
+ *
+ * We don't implement ApprovalController ourselves — we reuse the existing
+ * `PermissionAwareApprovalController` and provide its `handlerRef.current`,
+ * which is the function called when interactive approval is required.
+ *
+ * That handler:
+ *   1. Builds an approval card with [批准] [拒绝] [批准并加入会话允许列表] buttons.
+ *   2. Sends the card to the chat (separately from the run-state card).
+ *   3. Returns a Promise that resolves when the matching `cardAction` event
+ *      arrives (and the clicker is the original user).
+ *   4. Times out after `timeoutMs`, rejecting with feedback.
+ *
+ * Caller responsibilities:
+ *   - Wire the LarkChannel `cardAction` listener to call `dispatch(evt)`.
+ *   - On scope shutdown, call `cancelAll()` so any pending prompt rejects.
+ */
+import type { ApprovalDecision, ApprovalRequest } from "../../approval/types.js";
+import type { BashAllowlist } from "../../approval/session-cache.js";
+export interface ApprovalUIOptions {
+    /** Send a new interactive card to `chatId`, returning the new messageId. */
+    sendCard: (chatId: string, card: object) => Promise<{
+        messageId: string;
+    }>;
+    /** Update a card in place to reflect the decision. */
+    updateCard: (messageId: string, card: object) => Promise<void>;
+    /** Session-scoped bash allowlist (shared with the controller). */
+    bashAllowlist?: BashAllowlist;
+    /** Max time to wait for the user to click. */
+    timeoutMs?: number;
+}
+export interface ApprovalDispatchEvent {
+    /** messageId of the card the button is attached to. */
+    cardMessageId: string;
+    /** open_id of the clicker. */
+    clickerOpenId: string;
+    /** The button's `value` payload (whatever was set in the card). */
+    value: unknown;
+}
+export declare class FeishuApprovalUI {
+    private readonly opts;
+    private pending;
+    constructor(opts: ApprovalUIOptions);
+    /**
+     * Create a handler suitable for `PermissionAwareApprovalController.handlerRef.current`.
+     * The handler is closure-bound to (chatId, originalUserId) so each scope
+     * gets its own clicker-restricted prompt.
+     */
+    makeHandler(chatId: string, originalUserId: string): (req: ApprovalRequest) => Promise<ApprovalDecision>;
+    prompt(chatId: string, originalUserId: string, req: ApprovalRequest): Promise<ApprovalDecision>;
+    /** Called by the channel-level cardAction listener. */
+    dispatch(evt: ApprovalDispatchEvent): Promise<boolean>;
+    /** Reject all pending prompts (e.g. on shutdown or run abort). */
+    cancelAll(reason?: string): void;
+    /** Cancel any pending approvals attached to a specific chat (used per scope on /stop). */
+    cancelForChat(chatId: string, reason?: string): void;
+    pendingCount(): number;
+}