@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/feishu/scope/scope-registry.js

@@ -0,0 +1,148 @@
+/**
+ * scopes.json reader/writer.
+ *
+ * `cwd` here is the *initial* cwd written by the wizard. The truth source
+ * for "current cwd" after first use is sessions.json. See SessionStore.
+ *
+ * `/feishu bind` is invoked from the TUI process, but the running serve
+ * is a separate spawned subprocess — so the serve's in-memory cache would
+ * go stale the moment the TUI updates scopes.json. To bridge that, every
+ * read path stats the file and reloads if its mtime is newer than what
+ * we have cached. The cost is one stat() call per inbound message, which
+ * is negligible compared to LLM latency.
+ */
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { getScopesPath } from "../paths.js";
+import { validateScopesFile } from "../schema.js";
+export class ScopeRegistry {
+    file;
+    lastMtimeMs;
+    constructor(file, mtimeMs) {
+        this.file = file;
+        this.lastMtimeMs = mtimeMs;
+    }
+    static load() {
+        return loadFromDisk();
+    }
+    /**
+     * Reload from disk if scopes.json has been modified since our cached copy.
+     * Called from every read path so cross-process writes (e.g. `/feishu bind`
+     * from the TUI updating the file while the serve subprocess is running)
+     * become visible without restart.
+     */
+    syncFromDiskIfChanged() {
+        const path = getScopesPath();
+        if (!existsSync(path)) {
+            if (Object.keys(this.file.scopes).length > 0) {
+                this.file = { version: 1, scopes: {} };
+                this.lastMtimeMs = 0;
+            }
+            return;
+        }
+        let mtime;
+        try {
+            mtime = statSync(path).mtimeMs;
+        }
+        catch {
+            return;
+        }
+        if (mtime <= this.lastMtimeMs)
+            return;
+        try {
+            const next = loadFromDisk();
+            this.file = next.file;
+            this.lastMtimeMs = next.lastMtimeMs;
+        }
+        catch {
+            // Bad JSON or schema mid-flight (e.g. user editing scopes.json by hand).
+            // Keep the previous cached copy rather than tearing down the service.
+        }
+    }
+    save() {
+        writeFileSync(getScopesPath(), JSON.stringify(this.file, null, 2), { encoding: "utf8", mode: 0o600 });
+        // Refresh cached mtime so the next read doesn't see *our own* write as a stale-cache miss.
+        try {
+            this.lastMtimeMs = statSync(getScopesPath()).mtimeMs;
+        }
+        catch {
+            this.lastMtimeMs = Date.now();
+        }
+    }
+    get(chatId) {
+        this.syncFromDiskIfChanged();
+        return this.file.scopes[chatId];
+    }
+    has(chatId) {
+        this.syncFromDiskIfChanged();
+        return chatId in this.file.scopes;
+    }
+    list() {
+        this.syncFromDiskIfChanged();
+        return Object.entries(this.file.scopes).map(([chatId, scope]) => ({ chatId, scope }));
+    }
+    upsert(chatId, scope) {
+        this.syncFromDiskIfChanged();
+        this.file.scopes[chatId] = scope;
+        this.save();
+    }
+    remove(chatId) {
+        this.syncFromDiskIfChanged();
+        if (!(chatId in this.file.scopes))
+            return false;
+        delete this.file.scopes[chatId];
+        this.save();
+        return true;
+    }
+    touch(chatId, when = Date.now()) {
+        this.syncFromDiskIfChanged();
+        const scope = this.file.scopes[chatId];
+        if (!scope)
+            return;
+        scope.lastActiveAt = when;
+        this.save();
+    }
+    isUserAllowed(chatId, userId) {
+        this.syncFromDiskIfChanged();
+        const scope = this.file.scopes[chatId];
+        if (!scope)
+            return false;
+        return scope.allowedUsers.includes(userId);
+    }
+    isUserAdmin(chatId, userId) {
+        this.syncFromDiskIfChanged();
+        const scope = this.file.scopes[chatId];
+        if (!scope)
+            return false;
+        return scope.admins.includes(userId);
+    }
+}
+function loadFromDisk() {
+    const path = getScopesPath();
+    if (!existsSync(path)) {
+        return new ScopeRegistry({ version: 1, scopes: {} }, 0);
+    }
+    const raw = readFileSync(path, "utf8");
+    if (!raw.trim()) {
+        return new ScopeRegistry({ version: 1, scopes: {} }, getMtime(path));
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`scopes.json is not valid JSON at ${path}`);
+    }
+    const result = validateScopesFile(parsed);
+    if (!result.ok || !result.value) {
+        throw new Error(`scopes.json invalid:\n  - ${result.errors.join("\n  - ")}`);
+    }
+    return new ScopeRegistry(result.value, getMtime(path));
+}
+function getMtime(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/feishu/scope/session-binder.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Bridges scopeKey ↔ on-disk SessionManager (reuses ~/.bubble/sessions/<safe_cwd>/<name>.jsonl).
+ *
+ * SessionStore (sessions.json) is the index: scopeKey → { sessionFile, cwd, mode }.
+ * On first traffic for a scope we bootstrap from ScopeConfig.cwd.
+ * /cd and /new both archive (keep file on disk, just stop pointing at it) and start fresh.
+ */
+import { SessionManager, type SessionSummary } from "../../session.js";
+import type { PermissionMode } from "../../types.js";
+import type { SessionStore } from "./session-store.js";
+import type { ScopeKey } from "../types.js";
+export interface OpenedSession {
+    manager: SessionManager;
+    cwd: string;
+    permissionMode: PermissionMode;
+    /** True iff this call created a brand-new session file (no prior history). */
+    fresh: boolean;
+}
+export declare class SessionBinder {
+    private readonly store;
+    constructor(store: SessionStore);
+    /**
+     * Get the current session for (scopeKey). If sessions.json has a valid
+     * pointer, reuse it. Otherwise, bootstrap a new session with `bootstrapCwd`
+     * and `bootstrapMode`.
+     */
+    openOrBootstrap(scopeKey: ScopeKey, bootstrapCwd: string, bootstrapMode: PermissionMode): OpenedSession;
+    /** Start a brand-new session at `cwd` with `mode`, replacing the pointer. */
+    createFresh(scopeKey: ScopeKey, cwd: string, mode: PermissionMode): OpenedSession;
+    /**
+     * /cd: archive (pointer-rotate) and create a new session at newCwd.
+     * Permission mode carries over.
+     */
+    changeCwd(scopeKey: ScopeKey, newCwd: string): OpenedSession;
+    /** /resume <name>: re-point sessions.json to an existing file. */
+    resumeNamed(scopeKey: ScopeKey, sessionFile: string): OpenedSession | undefined;
+    /** List sessions (feishu-prefixed) under `cwd` for the /resume picker. */
+    listResumable(cwd: string, limit?: number): SessionSummary[];
+    /**
+     * Update the persisted permission mode for a scopeKey. Called by /mode and
+     * by the agent's onModeUpdate hook.
+     */
+    setMode(scopeKey: ScopeKey, mode: PermissionMode): void;
+}

package/dist/feishu/scope/session-binder.js

@@ -0,0 +1,100 @@
+/**
+ * Bridges scopeKey ↔ on-disk SessionManager (reuses ~/.bubble/sessions/<safe_cwd>/<name>.jsonl).
+ *
+ * SessionStore (sessions.json) is the index: scopeKey → { sessionFile, cwd, mode }.
+ * On first traffic for a scope we bootstrap from ScopeConfig.cwd.
+ * /cd and /new both archive (keep file on disk, just stop pointing at it) and start fresh.
+ */
+import { existsSync } from "node:fs";
+import { SessionManager } from "../../session.js";
+export class SessionBinder {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * Get the current session for (scopeKey). If sessions.json has a valid
+     * pointer, reuse it. Otherwise, bootstrap a new session with `bootstrapCwd`
+     * and `bootstrapMode`.
+     */
+    openOrBootstrap(scopeKey, bootstrapCwd, bootstrapMode) {
+        const entry = this.store.get(scopeKey);
+        if (entry && existsSync(entry.sessionFile)) {
+            return {
+                manager: new SessionManager(entry.sessionFile),
+                cwd: entry.cwd,
+                permissionMode: entry.permissionMode,
+                fresh: false,
+            };
+        }
+        // Bootstrap: pointer is missing or file got removed externally.
+        return this.createFresh(scopeKey, bootstrapCwd, bootstrapMode);
+    }
+    /** Start a brand-new session at `cwd` with `mode`, replacing the pointer. */
+    createFresh(scopeKey, cwd, mode) {
+        const name = makeSessionName(scopeKey);
+        const manager = SessionManager.create(cwd, name);
+        // Persist metadata immediately so the on-disk file exists from this point
+        // on — otherwise openOrBootstrap() on the next call would see the pointer
+        // but no file and re-bootstrap, losing the pointer.
+        manager.updateMetadata({ cwd });
+        const entry = {
+            sessionFile: manager.getSessionFile(),
+            cwd,
+            permissionMode: mode,
+            lastActiveAt: Date.now(),
+        };
+        this.store.upsert(scopeKey, entry);
+        return { manager, cwd, permissionMode: mode, fresh: true };
+    }
+    /**
+     * /cd: archive (pointer-rotate) and create a new session at newCwd.
+     * Permission mode carries over.
+     */
+    changeCwd(scopeKey, newCwd) {
+        const prev = this.store.get(scopeKey);
+        const mode = prev?.permissionMode ?? "default";
+        return this.createFresh(scopeKey, newCwd, mode);
+    }
+    /** /resume <name>: re-point sessions.json to an existing file. */
+    resumeNamed(scopeKey, sessionFile) {
+        if (!existsSync(sessionFile))
+            return undefined;
+        const prev = this.store.get(scopeKey);
+        const manager = new SessionManager(sessionFile);
+        const meta = manager.getMetadata();
+        const cwd = meta.cwd ?? prev?.cwd;
+        if (!cwd)
+            return undefined;
+        const mode = prev?.permissionMode ?? "default";
+        const entry = {
+            sessionFile,
+            cwd,
+            permissionMode: mode,
+            lastActiveAt: Date.now(),
+        };
+        this.store.upsert(scopeKey, entry);
+        return { manager, cwd, permissionMode: mode, fresh: false };
+    }
+    /** List sessions (feishu-prefixed) under `cwd` for the /resume picker. */
+    listResumable(cwd, limit = 10) {
+        const all = SessionManager.summarizeSessionsForCwd(cwd);
+        const feishu = all.filter((s) => s.name.startsWith("feishu-"));
+        return feishu.slice(0, limit);
+    }
+    /**
+     * Update the persisted permission mode for a scopeKey. Called by /mode and
+     * by the agent's onModeUpdate hook.
+     */
+    setMode(scopeKey, mode) {
+        this.store.setPermissionMode(scopeKey, mode);
+    }
+}
+let SESSION_NAME_COUNTER = 0;
+function makeSessionName(scopeKey) {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const safe = scopeKey.replace(/[^A-Za-z0-9_-]/g, "_");
+    // Counter disambiguates back-to-back creates within the same millisecond.
+    const seq = (SESSION_NAME_COUNTER++).toString(36);
+    return `feishu-${safe}-${ts}-${seq}.jsonl`;
+}

package/dist/feishu/scope/session-store.d.ts

@@ -0,0 +1,24 @@
+/**
+ * sessions.json reader/writer. Keyed by `<chatId>:<userId>` (scopeKey).
+ *
+ * Entries hold the *current* effective cwd + sessionFile + permissionMode
+ * for that (chat, user) pair. This is the truth source post-first-use:
+ * scopes.json provides only the bootstrap cwd for first-time sessions.
+ */
+import type { ScopeKey, SessionEntry, SessionsFile } from "../types.js";
+import type { PermissionMode } from "../../types.js";
+export declare class SessionStore {
+    private file;
+    constructor(file: SessionsFile);
+    static load(): SessionStore;
+    save(): void;
+    get(scopeKey: ScopeKey): SessionEntry | undefined;
+    upsert(scopeKey: ScopeKey, entry: SessionEntry): void;
+    remove(scopeKey: ScopeKey): boolean;
+    setPermissionMode(scopeKey: ScopeKey, mode: PermissionMode): void;
+    touch(scopeKey: ScopeKey, when?: number): void;
+    list(): Array<{
+        scopeKey: ScopeKey;
+        entry: SessionEntry;
+    }>;
+}

package/dist/feishu/scope/session-store.js

@@ -0,0 +1,73 @@
+/**
+ * sessions.json reader/writer. Keyed by `<chatId>:<userId>` (scopeKey).
+ *
+ * Entries hold the *current* effective cwd + sessionFile + permissionMode
+ * for that (chat, user) pair. This is the truth source post-first-use:
+ * scopes.json provides only the bootstrap cwd for first-time sessions.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { getSessionsPath } from "../paths.js";
+import { validateSessionsFile } from "../schema.js";
+export class SessionStore {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    static load() {
+        const path = getSessionsPath();
+        if (!existsSync(path)) {
+            return new SessionStore({ version: 1, sessions: {} });
+        }
+        const raw = readFileSync(path, "utf8");
+        if (!raw.trim()) {
+            return new SessionStore({ version: 1, sessions: {} });
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`sessions.json is not valid JSON at ${path}`);
+        }
+        const result = validateSessionsFile(parsed);
+        if (!result.ok || !result.value) {
+            throw new Error(`sessions.json invalid:\n  - ${result.errors.join("\n  - ")}`);
+        }
+        return new SessionStore(result.value);
+    }
+    save() {
+        writeFileSync(getSessionsPath(), JSON.stringify(this.file, null, 2), { encoding: "utf8", mode: 0o600 });
+    }
+    get(scopeKey) {
+        return this.file.sessions[scopeKey];
+    }
+    upsert(scopeKey, entry) {
+        this.file.sessions[scopeKey] = entry;
+        this.save();
+    }
+    remove(scopeKey) {
+        if (!(scopeKey in this.file.sessions))
+            return false;
+        delete this.file.sessions[scopeKey];
+        this.save();
+        return true;
+    }
+    setPermissionMode(scopeKey, mode) {
+        const entry = this.file.sessions[scopeKey];
+        if (!entry)
+            return;
+        entry.permissionMode = mode;
+        entry.lastActiveAt = Date.now();
+        this.save();
+    }
+    touch(scopeKey, when = Date.now()) {
+        const entry = this.file.sessions[scopeKey];
+        if (!entry)
+            return;
+        entry.lastActiveAt = when;
+        this.save();
+    }
+    list() {
+        return Object.entries(this.file.sessions).map(([scopeKey, entry]) => ({ scopeKey, entry }));
+    }
+}

package/dist/feishu/secrets.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AES-256-GCM keystore for the Feishu App Secret.
+ *
+ * Key derivation: scrypt(machineId + home, salt) → 32-byte key.
+ * Salt is stored alongside ciphertext (it's the keystore record itself
+ * that's the secret — salt being public is fine, that's its job).
+ *
+ * File format (JSON, 0600 perms):
+ *   { "v": 1, "iv": "...", "tag": "...", "salt": "...", "ciphertext": "..." }
+ * All blobs base64-encoded.
+ */
+export interface KeystoreFile {
+    v: number;
+    iv: string;
+    tag: string;
+    salt: string;
+    ciphertext: string;
+}
+export declare class KeystoreError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare function encryptSecret(plaintext: string): KeystoreFile;
+export declare function decryptSecret(record: KeystoreFile): string;
+export declare function saveKeystoreFile(path: string, record: KeystoreFile): void;
+export declare function loadKeystoreFile(path: string): KeystoreFile;
+/**
+ * Encrypt-and-verify: encrypts the plaintext, then immediately decrypts it
+ * to confirm the keystore works on this machine. Throws on round-trip
+ * failure. Returns a stable check string callers may persist alongside
+ * config (e.g. `encryptCheck` field) so subsequent startups can sanity-check
+ * without round-tripping the full secret on every boot.
+ */
+export declare function encryptWithSelfCheck(plaintext: string): {
+    record: KeystoreFile;
+    check: string;
+};

package/dist/feishu/secrets.js

@@ -0,0 +1,129 @@
+/**
+ * AES-256-GCM keystore for the Feishu App Secret.
+ *
+ * Key derivation: scrypt(machineId + home, salt) → 32-byte key.
+ * Salt is stored alongside ciphertext (it's the keystore record itself
+ * that's the secret — salt being public is fine, that's its job).
+ *
+ * File format (JSON, 0600 perms):
+ *   { "v": 1, "iv": "...", "tag": "...", "salt": "...", "ciphertext": "..." }
+ * All blobs base64-encoded.
+ */
+import { randomBytes, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+const FILE_VERSION = 1;
+const KEY_LENGTH = 32;
+const IV_LENGTH = 12;
+const TAG_LENGTH = 16;
+const SALT_LENGTH = 16;
+const SCRYPT_N = 1 << 14;
+export class KeystoreError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "KeystoreError";
+    }
+}
+function deriveKey(salt) {
+    const material = `${hostname()}::${homedir()}`;
+    return scryptSync(material, salt, KEY_LENGTH, { N: SCRYPT_N });
+}
+export function encryptSecret(plaintext) {
+    const salt = randomBytes(SALT_LENGTH);
+    const iv = randomBytes(IV_LENGTH);
+    const key = deriveKey(salt);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+        v: FILE_VERSION,
+        iv: iv.toString("base64"),
+        tag: tag.toString("base64"),
+        salt: salt.toString("base64"),
+        ciphertext: enc.toString("base64"),
+    };
+}
+export function decryptSecret(record) {
+    if (record.v !== FILE_VERSION) {
+        throw new KeystoreError(`Unsupported keystore version: ${record.v}`);
+    }
+    const salt = Buffer.from(record.salt, "base64");
+    const iv = Buffer.from(record.iv, "base64");
+    const tag = Buffer.from(record.tag, "base64");
+    const ciphertext = Buffer.from(record.ciphertext, "base64");
+    if (salt.length !== SALT_LENGTH)
+        throw new KeystoreError("Invalid salt length");
+    if (iv.length !== IV_LENGTH)
+        throw new KeystoreError("Invalid iv length");
+    if (tag.length !== TAG_LENGTH)
+        throw new KeystoreError("Invalid tag length");
+    const key = deriveKey(salt);
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    try {
+        const dec = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        return dec.toString("utf8");
+    }
+    catch (err) {
+        throw new KeystoreError("Failed to decrypt: machine identity changed, file corrupted, or wrong key", err);
+    }
+}
+export function saveKeystoreFile(path, record) {
+    writeFileSync(path, JSON.stringify(record), { encoding: "utf8", mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Some filesystems (Windows, certain Linux mounts) reject chmod; not fatal.
+    }
+}
+export function loadKeystoreFile(path) {
+    if (!existsSync(path)) {
+        throw new KeystoreError(`Keystore file not found: ${path}`);
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        throw new KeystoreError(`Failed to read keystore: ${path}`, err);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new KeystoreError("Keystore file is not valid JSON", err);
+    }
+    if (!isKeystoreFile(parsed)) {
+        throw new KeystoreError("Keystore file has unexpected shape");
+    }
+    return parsed;
+}
+function isKeystoreFile(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const obj = value;
+    return (typeof obj.v === "number" &&
+        typeof obj.iv === "string" &&
+        typeof obj.tag === "string" &&
+        typeof obj.salt === "string" &&
+        typeof obj.ciphertext === "string");
+}
+/**
+ * Encrypt-and-verify: encrypts the plaintext, then immediately decrypts it
+ * to confirm the keystore works on this machine. Throws on round-trip
+ * failure. Returns a stable check string callers may persist alongside
+ * config (e.g. `encryptCheck` field) so subsequent startups can sanity-check
+ * without round-tripping the full secret on every boot.
+ */
+export function encryptWithSelfCheck(plaintext) {
+    const record = encryptSecret(plaintext);
+    const back = decryptSecret(record);
+    if (back !== plaintext) {
+        throw new KeystoreError("Self-check failed: decrypt did not match original");
+    }
+    return { record, check: record.tag.slice(0, 8) };
+}

package/dist/feishu/serve.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `bubble serve --feishu` entry. Wires every layer of the host together.
+ */
+export interface ServeFeishuOptions {
+    /** If true, force wizard re-run even if config exists. */
+    setup?: boolean;
+    /** If true, skip conflicting-process prompt and kill the old one. */
+    killOld?: boolean;
+    /** If true, exit immediately after a successful connect (CI / smoke test). */
+    dryRun?: boolean;
+}
+export declare function serveFeishu(opts?: ServeFeishuOptions): Promise<void>;