@chibitek/chibi 0.1.157 → 0.1.158

package/dist-server/server/vault/runtime.js

@@ -0,0 +1,48 @@
+import { timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+import { VaultStore } from "./store.js";
+import { join } from "node:path";
+import { ROUTES } from "../routes/table.js";
+import { createVaultRoutes } from "./routes.js";
+const keyMessage = z.object({ type: z.literal("atomic:native-vault-key"), ownerId: z.string().uuid(), key: z.string().regex(/^[0-9a-f]{64}$/) }).strict();
+/** Constructed by the server, bootstrapped only on Electron's private port.
+ * No HTTP endpoint can unlock the vault or replace its owner. */
+export class NativeVaultRuntime {
+    #directory;
+    #store = null;
+    #ownerId = null;
+    constructor(directory) { this.#directory = directory; }
+    receive(raw) {
+        if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "atomic:native-vault-key")
+            return false;
+        const parsed = keyMessage.safeParse(raw);
+        if (!parsed.success || this.#store)
+            return true;
+        const key = Buffer.from(parsed.data.key, "hex");
+        try {
+            this.#store = new VaultStore(this.#directory, key);
+            this.#ownerId = parsed.data.ownerId;
+        }
+        finally {
+            key.fill(0);
+        }
+        return true;
+    }
+    store() { return this.#store; }
+    /** Until paired owner identity is established, remote clients fail closed.
+     * GET needs the desktop capability too; loopback alone is not authority. */
+    owner(req, auth, desktopToken) {
+        if (!desktopToken || auth.kind !== "loopback" || auth.trust === "service" || !auth.scopes.includes("admin"))
+            return null;
+        const supplied = req.headers["x-chibi-desktop-owner"];
+        if (typeof supplied !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(supplied) || supplied.length !== desktopToken.length || !timingSafeEqual(Buffer.from(supplied), Buffer.from(desktopToken)))
+            return null;
+        return this.#ownerId ?? "pending";
+    }
+}
+/** Keep bootstrapping and route registration together, outside index.ts. */
+export function installNativeVault(dataDir, port, desktopToken, fromBot) {
+    const runtime = new NativeVaultRuntime(join(dataDir, "providers", "native-vault"));
+    port?.on("message", (event) => { runtime.receive(event?.data); });
+    ROUTES.push(createVaultRoutes({ store: () => runtime.store(), owner: (req, auth) => fromBot(req) ? null : runtime.owner(req, auth, desktopToken()) }));
+}

package/dist-server/server/vault/store.js

@@ -0,0 +1,177 @@
+// Native Vault persistence. No API/OAuth credentials are stored here.
+// The caller supplies a key from the trusted runtime; this module never
+// creates a plaintext key file or returns stored secrets to a model.
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { vaultInputSchema, vaultMetadata } from "../../shared/vault.js";
+import { writeFileAtomic } from "../atomic.js";
+const MAX_BYTES = 16 * 1024 * 1024;
+const MAX_ITEMS = 1000;
+const AAD = Buffer.from("atomic-native-vault:v1");
+const identity = z.string().uuid();
+const metadataSchema = z.object({
+    id: identity, ownerId: identity, createdAt: z.number().int().nonnegative(), updatedAt: z.number().int().nonnegative(),
+});
+const envelopeSchema = z.object({
+    version: z.literal(1), iv: z.string().regex(/^[0-9a-f]{24}$/),
+    tag: z.string().regex(/^[0-9a-f]{32}$/), data: z.string().regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+}).strict();
+export class VaultError extends Error {
+}
+function owner(value) {
+    if (!identity.safeParse(value).success)
+        throw new VaultError("Invalid Vault owner.");
+}
+export class VaultStore {
+    #directory;
+    #file;
+    #key;
+    constructor(directory, key) {
+        if (key.length !== 32)
+            throw new VaultError("Vault encryption is unavailable.");
+        this.#directory = directory;
+        this.#file = join(directory, "vault.enc");
+        this.#key = Buffer.from(key);
+    }
+    read() {
+        try {
+            let stat;
+            try {
+                stat = lstatSync(this.#file);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return [];
+                throw error;
+            }
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_BYTES)
+                throw new Error();
+            const envelope = envelopeSchema.parse(JSON.parse(readFileSync(this.#file, "utf8")));
+            const decipher = createDecipheriv("aes-256-gcm", this.#key, Buffer.from(envelope.iv, "hex"));
+            decipher.setAAD(AAD);
+            decipher.setAuthTag(Buffer.from(envelope.tag, "hex"));
+            const plain = Buffer.concat([decipher.update(Buffer.from(envelope.data, "base64")), decipher.final()]);
+            try {
+                // Separate metadata before the strict input schema validates each item.
+                const raw = JSON.parse(plain.toString("utf8"));
+                if (!Array.isArray(raw) || raw.length > MAX_ITEMS)
+                    throw new Error();
+                const items = raw.map((value) => {
+                    if (!value || typeof value !== "object" || Array.isArray(value))
+                        throw new Error();
+                    const { id, ownerId, createdAt, updatedAt, ...input } = value;
+                    const metadata = metadataSchema.parse({ id, ownerId, createdAt, updatedAt });
+                    return { ...vaultInputSchema.parse(input), ...metadata };
+                });
+                if (new Set(items.map((item) => item.id)).size !== items.length)
+                    throw new Error();
+                return items;
+            }
+            finally {
+                plain.fill(0);
+            }
+        }
+        catch {
+            throw new VaultError("Vault is locked or unreadable.");
+        }
+    }
+    write(items) {
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", this.#key, iv);
+        cipher.setAAD(AAD);
+        const plain = Buffer.from(JSON.stringify(items));
+        try {
+            const encrypted = Buffer.concat([cipher.update(plain), cipher.final()]);
+            const envelope = JSON.stringify({ version: 1, iv: iv.toString("hex"), tag: cipher.getAuthTag().toString("hex"), data: encrypted.toString("base64") });
+            if (Buffer.byteLength(envelope) > MAX_BYTES)
+                throw new VaultError("Vault has reached its size limit.");
+            writeFileAtomic(this.#file, envelope, { mode: 0o600 });
+        }
+        finally {
+            plain.fill(0);
+        }
+    }
+    /** Cross-process writes refuse contention instead of losing an update.
+     * A crash leaves the lock in place for explicit recovery, never guessing
+     * that an older process has stopped writing. */
+    mutate(fn) {
+        const lock = join(this.#directory, "write.lock");
+        try {
+            mkdirSync(this.#directory, { recursive: true, mode: 0o700 });
+        }
+        catch {
+            throw new VaultError("Vault could not be saved.");
+        }
+        try {
+            mkdirSync(lock, { mode: 0o700 });
+        }
+        catch {
+            throw new VaultError("Vault is busy or needs recovery.");
+        }
+        try {
+            const items = this.read();
+            const result = fn(items);
+            this.write(items);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof VaultError)
+                throw error;
+            throw new VaultError("Vault could not be saved.");
+        }
+        finally {
+            rmdirSync(lock);
+        }
+    }
+    list(ownerId) {
+        owner(ownerId);
+        return this.read().filter((item) => item.ownerId === ownerId).map(vaultMetadata);
+    }
+    create(ownerId, input) {
+        owner(ownerId);
+        const parsed = vaultInputSchema.safeParse(input);
+        if (!parsed.success)
+            throw new VaultError("Invalid Vault item.");
+        return this.mutate((items) => {
+            if (items.length >= MAX_ITEMS)
+                throw new VaultError("Vault has reached its item limit.");
+            const now = Date.now();
+            const item = { ...parsed.data, id: randomUUID(), ownerId, createdAt: now, updatedAt: now };
+            items.push(item);
+            return vaultMetadata(item);
+        });
+    }
+    update(ownerId, id, input) {
+        owner(ownerId);
+        if (!input || typeof input !== "object" || Array.isArray(input))
+            throw new VaultError("Invalid Vault item.");
+        return this.mutate((items) => {
+            const index = items.findIndex((item) => item.id === id && item.ownerId === ownerId);
+            const current = items[index];
+            if (!current)
+                throw new VaultError("Vault item is unavailable.");
+            const { id: _id, ownerId: _owner, createdAt: _created, updatedAt: _updated, ...previous } = current;
+            // A blank password is invalid; omission preserves it, so metadata can
+            // be edited without ever reading the saved secret back to the UI.
+            const parsed = vaultInputSchema.safeParse({ ...previous, ...input });
+            if (!parsed.success)
+                throw new VaultError("Invalid Vault item.");
+            if (current.kind !== parsed.data.kind)
+                throw new VaultError("A Vault item's category cannot change.");
+            const item = { ...parsed.data, id, ownerId, createdAt: current.createdAt, updatedAt: Date.now() };
+            items[index] = item;
+            return vaultMetadata(item);
+        });
+    }
+    remove(ownerId, id) {
+        owner(ownerId);
+        this.mutate((items) => {
+            const index = items.findIndex((item) => item.id === id && item.ownerId === ownerId);
+            if (index < 0)
+                throw new VaultError("Vault item is unavailable.");
+            items.splice(index, 1);
+        });
+    }
+}

package/dist-server/shared/connector-availability.js

@@ -0,0 +1,12 @@
+const MANAGED_CUSTOM_AUTH_TOOLKITS = new Set(["twitter", "x"]);
+/**
+ * Some Composio toolkits no longer include provider-managed credentials.
+ * The official OpenMausBot broker cannot offer those connections until its
+ * project owns the corresponding OAuth app. Self-hosted Composio projects can
+ * still supply their own auth config, so keep this restriction mode-specific.
+ */
+export function managedConnectorUnavailableReason(mode, slug) {
+    if (mode !== "managed" || !MANAGED_CUSTOM_AUTH_TOOLKITS.has(slug.trim().toLowerCase()))
+        return null;
+    return "Twitter/X needs your own X Developer app and Composio auth config. Use self-hosted connected apps for now.";
+}

package/dist-server/shared/desktop-private-port.js

@@ -0,0 +1 @@
+export {};

package/dist-server/shared/subscription-bots.js

@@ -88,6 +88,9 @@ export function subscriptionProviderForEngine(engine) {
 export function isProviderModel(provider, model) {
     return provider.ownModels ? provider.ownModels.test(model) : true;
 }
+/** Turns one conversation of a company subscription bot may run on another
+ * provider's subscription when its own has no account free (server/session-fallback.ts). */
+export const SESSION_FALLBACK_TURNS = 50;
 export function isSubscriptionBot(bot) {
     const value = bot?.subscription;
     return Boolean(value && typeof value.instanceId === "string" && subscriptionProvider(value.provider));

package/dist-server/shared/vault.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+/** Only absolute HTTPS origins can receive a saved item. Paths never broaden
+ * authority to sibling domains, frames, ports or subdomains. */
+export function vaultOrigin(raw) {
+    if (raw.length > 2048 || [...raw].some((c) => c.charCodeAt(0) <= 32 || c.charCodeAt(0) === 127) || raw.includes("\\"))
+        return null;
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== "https:" || !url.hostname || url.username || url.password || url.hostname.endsWith("."))
+            return null;
+        return url.origin;
+    }
+    catch {
+        return null;
+    }
+}
+const text = (max) => z.string().max(max);
+const origin = z.string().refine((value) => vaultOrigin(value) !== null).transform((value) => vaultOrigin(value));
+const address = z.object({
+    name: text(200), line1: text(300), line2: text(300), city: text(200),
+    region: text(200), postalCode: text(40), country: text(100),
+}).strict();
+const base = {
+    label: z.string().trim().min(1).max(200), hints: text(1000),
+    botIds: z.array(z.string().uuid()).max(100).refine((ids) => new Set(ids).size === ids.length),
+    expiresAt: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+};
+/** Reject unknown fields rather than accidentally persisting secrets in
+ * metadata. CVC is deliberately absent: it belongs to a single secure use. */
+export const vaultInputSchema = z.discriminatedUnion("kind", [
+    z.object({ ...base, kind: z.literal("login"), website: origin,
+        username: z.string().min(1).max(320), password: z.string().min(1).max(4096),
+    }).strict(),
+    z.object({ ...base, kind: z.literal("card"), origins: z.array(origin).min(1).max(50),
+        number: z.string().regex(/^\d{12,19}$/), expiryMonth: z.number().int().min(1).max(12),
+        expiryYear: z.number().int().min(2000).max(9999), billing: address,
+    }).strict(),
+    z.object({ ...base, kind: z.literal("contact"), origins: z.array(origin).min(1).max(50),
+        address, email: z.union([z.literal(""), z.string().email().max(320)]), phone: text(80),
+    }).strict(),
+]);
+/** Explicit allowlist. Never spread a stored item into a response. */
+export function vaultMetadata(item) {
+    return {
+        id: item.id, kind: item.kind, label: item.label, hints: item.hints,
+        botIds: [...item.botIds], expiresAt: item.expiresAt,
+        origins: item.kind === "login" ? [item.website] : [...item.origins],
+        ...(item.kind === "login" ? { username: item.username } : {}),
+        ...(item.kind === "card" ? { lastFour: item.number.slice(-4), expiryMonth: item.expiryMonth, expiryYear: item.expiryYear, billing: { ...item.billing } } : {}),
+        ...(item.kind === "contact" ? { address: { ...item.address }, email: item.email, phone: item.phone } : {}),
+        createdAt: item.createdAt, updatedAt: item.updatedAt,
+    };
+}
+export function vaultUseAllowed(item, actor, now) {
+    const destination = vaultOrigin(actor.destination);
+    return Number.isSafeInteger(now) && now >= 0 && item.ownerId === actor.ownerId && item.botIds.includes(actor.botId)
+        && (item.expiresAt === null || now < item.expiresAt) && destination !== null
+        && (item.kind === "login" ? item.website === destination : item.origins.includes(destination));
+}