@kernel.chat/kbot 3.99.30 → 3.99.33

package/dist/file-library.js

@@ -0,0 +1,269 @@
+/**
+ * File Library — local-first per-user file store.
+ *
+ * Mirrors ChatGPT's File Library: auto-saves uploaded and created files,
+ * lists, searches by name/content, fetches by id. Content-addressed (sha256).
+ *
+ * Storage layout:
+ *   <root>/index.json           — atomic JSON index of entries
+ *   <root>/blobs/<id>           — raw file bytes (id = sha256 of contents)
+ *
+ * Default root: ~/.kbot/files (overridable via KBOT_FILE_LIBRARY_ROOT or ctor opt).
+ */
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const MAX_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+const TEXT_MIME_PREFIXES = ["text/"];
+const TEXT_MIME_EXACT = new Set([
+    "application/json",
+    "application/yaml",
+    "application/x-yaml",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+]);
+function isTextMime(mimeType) {
+    const m = mimeType.toLowerCase();
+    if (TEXT_MIME_EXACT.has(m))
+        return true;
+    return TEXT_MIME_PREFIXES.some((p) => m.startsWith(p));
+}
+function defaultRoot() {
+    const env = process.env.KBOT_FILE_LIBRARY_ROOT;
+    if (env && env.length > 0)
+        return env;
+    return path.join(os.homedir(), ".kbot", "files");
+}
+export class FileLibrary {
+    root;
+    blobsDir;
+    indexPath;
+    writeLock = Promise.resolve();
+    constructor(opts = {}) {
+        this.root = opts.root ?? defaultRoot();
+        this.blobsDir = path.join(this.root, "blobs");
+        this.indexPath = path.join(this.root, "index.json");
+    }
+    getRoot() {
+        return this.root;
+    }
+    async ensureDirs() {
+        await fs.mkdir(this.blobsDir, { recursive: true });
+    }
+    async readIndex() {
+        try {
+            const raw = await fs.readFile(this.indexPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
+                return { version: 1, entries: [] };
+            }
+            return parsed;
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === "ENOENT")
+                return { version: 1, entries: [] };
+            throw err;
+        }
+    }
+    /**
+     * Atomic write: serialize → write to <indexPath>.tmp.<rand> → rename.
+     */
+    async writeIndexAtomic(idx) {
+        await this.ensureDirs();
+        const tmp = `${this.indexPath}.tmp.${process.pid}.${Date.now()}.${Math.random()
+            .toString(36)
+            .slice(2, 10)}`;
+        const data = JSON.stringify(idx, null, 2);
+        await fs.writeFile(tmp, data, { encoding: "utf8" });
+        await fs.rename(tmp, this.indexPath);
+    }
+    /**
+     * Run a read-modify-write of the index under the writeLock so concurrent
+     * mutations don't lose updates. The mutator may return a fresh IndexFile
+     * (or undefined to skip the write).
+     */
+    async mutateIndex(fn) {
+        const run = async () => {
+            const idx = await this.readIndex();
+            const out = await fn(idx);
+            if (out.next)
+                await this.writeIndexAtomic(out.next);
+            return out.result;
+        };
+        const next = this.writeLock.then(run, run);
+        // Don't poison the lock chain on error.
+        this.writeLock = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    async addFile(input) {
+        if (!input.name || input.name.trim().length === 0) {
+            throw new Error("file-library: name is required");
+        }
+        if (!input.mimeType) {
+            throw new Error("file-library: mimeType is required");
+        }
+        if (input.content === undefined && input.buffer === undefined) {
+            throw new Error("file-library: provide content or buffer");
+        }
+        if (input.content !== undefined && input.buffer !== undefined) {
+            throw new Error("file-library: provide content OR buffer, not both");
+        }
+        const buf = input.buffer !== undefined
+            ? input.buffer
+            : Buffer.from(input.content, "utf8");
+        if (buf.byteLength > MAX_FILE_BYTES) {
+            throw new Error(`file-library: file exceeds 50 MB cap (${buf.byteLength} bytes > ${MAX_FILE_BYTES})`);
+        }
+        const id = createHash("sha256").update(buf).digest("hex");
+        await this.ensureDirs();
+        const blobPath = path.join(this.blobsDir, id);
+        // Write blob if not already present (content-addressed dedup).
+        try {
+            await fs.access(blobPath);
+        }
+        catch {
+            const tmp = `${blobPath}.tmp.${process.pid}.${Date.now()}`;
+            await fs.writeFile(tmp, buf);
+            await fs.rename(tmp, blobPath);
+        }
+        const entry = {
+            id,
+            name: input.name,
+            mimeType: input.mimeType,
+            size: buf.byteLength,
+            createdAt: new Date().toISOString(),
+            source: input.source,
+            tags: [...(input.tags ?? [])],
+            path: blobPath,
+        };
+        return this.mutateIndex((idx) => {
+            // If an entry with this id already exists, replace it (latest metadata wins,
+            // since the blob bytes are identical by id).
+            const filtered = idx.entries.filter((e) => e.id !== id);
+            filtered.push(entry);
+            return { next: { version: 1, entries: filtered }, result: entry };
+        });
+    }
+    async listFiles(opts = {}) {
+        const idx = await this.readIndex();
+        let entries = idx.entries.slice();
+        if (opts.tag) {
+            const tag = opts.tag;
+            entries = entries.filter((e) => e.tags.includes(tag));
+        }
+        if (opts.since !== undefined) {
+            const sinceMs = opts.since instanceof Date
+                ? opts.since.getTime()
+                : new Date(opts.since).getTime();
+            if (!Number.isNaN(sinceMs)) {
+                entries = entries.filter((e) => new Date(e.createdAt).getTime() >= sinceMs);
+            }
+        }
+        // Newest first.
+        entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        if (typeof opts.limit === "number" && opts.limit >= 0) {
+            entries = entries.slice(0, opts.limit);
+        }
+        return entries;
+    }
+    async getFile(id) {
+        const idx = await this.readIndex();
+        const entry = idx.entries.find((e) => e.id === id);
+        if (!entry)
+            return null;
+        try {
+            const buffer = await fs.readFile(entry.path);
+            return { entry, buffer };
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === "ENOENT")
+                return null;
+            throw err;
+        }
+    }
+    async removeFile(id) {
+        const removedEntry = await this.mutateIndex((idx) => {
+            const entry = idx.entries.find((e) => e.id === id);
+            if (!entry)
+                return { result: null };
+            const remaining = idx.entries.filter((e) => e.id !== id);
+            return {
+                next: { version: 1, entries: remaining },
+                result: entry,
+            };
+        });
+        if (!removedEntry)
+            return false;
+        try {
+            await fs.unlink(removedEntry.path);
+        }
+        catch (err) {
+            const e = err;
+            if (e.code !== "ENOENT")
+                throw err;
+        }
+        return true;
+    }
+    async searchFiles(opts) {
+        const q = (opts.query ?? "").toLowerCase();
+        if (q.length === 0)
+            return [];
+        const idx = await this.readIndex();
+        const entries = idx.entries;
+        const matchName = (e) => e.name.toLowerCase().includes(q);
+        const matchContent = async (e) => {
+            if (!isTextMime(e.mimeType))
+                return false;
+            try {
+                const buf = await fs.readFile(e.path);
+                return buf.toString("utf8").toLowerCase().includes(q);
+            }
+            catch (err) {
+                const ne = err;
+                if (ne.code === "ENOENT")
+                    return false;
+                throw err;
+            }
+        };
+        const seen = new Set();
+        const out = [];
+        if (opts.mode === "name" || opts.mode === "both") {
+            for (const e of entries) {
+                if (matchName(e) && !seen.has(e.id)) {
+                    seen.add(e.id);
+                    out.push(e);
+                }
+            }
+        }
+        if (opts.mode === "content" || opts.mode === "both") {
+            for (const e of entries) {
+                if (seen.has(e.id))
+                    continue;
+                // eslint-disable-next-line no-await-in-loop
+                const hit = await matchContent(e);
+                if (hit) {
+                    seen.add(e.id);
+                    out.push(e);
+                }
+            }
+        }
+        out.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        return out;
+    }
+}
+// Singleton helper for default root usage.
+let _default = null;
+export function getDefaultFileLibrary() {
+    if (!_default)
+        _default = new FileLibrary();
+    return _default;
+}
+// Reset the cached default — primarily for tests that mutate env.
+export function _resetDefaultFileLibrary() {
+    _default = null;
+}
+//# sourceMappingURL=file-library.js.map

package/dist/managed-agents-anthropic.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Anthropic Managed Agents client (April 2026 launch).
+ *
+ * Hosted long-horizon agent platform. This module is a STANDALONE backend
+ * that workspace agents can route through when ANTHROPIC_API_KEY is set.
+ * Wiring into ./workspace-agents.ts happens in a follow-up pass.
+ *
+ * Beta header: `anthropic-beta: managed-agents-2026-04-01` is sent on every
+ * request.
+ *
+ * SPEC: best-effort, refine when official docs published.
+ * Endpoint shape mirrors the public beta announcement; refine when the
+ * official OpenAPI spec lands.
+ */
+export interface CreateSessionInput {
+    mission: string;
+    allowedTools?: string[];
+    model?: string;
+}
+export interface CreateSessionOutput {
+    session_id: string;
+    [key: string]: unknown;
+}
+export interface SendTurnInput {
+    sessionId: string;
+    input: string;
+}
+export interface SendTurnOutput {
+    output: string;
+    tool_calls?: unknown[];
+    [key: string]: unknown;
+}
+export interface SessionState {
+    session_id: string;
+    mission?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+export interface ListSessionsOutput {
+    sessions: SessionState[];
+    [key: string]: unknown;
+}
+export interface MemoryReadInput {
+    sessionId: string;
+    key?: string;
+}
+export interface MemoryWriteInput {
+    sessionId: string;
+    key: string;
+    value: unknown;
+}
+export interface MemoryAck {
+    ok: boolean;
+    [key: string]: unknown;
+}
+export declare class AnthropicManagedAgentsError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(message: string, status: number, body: string);
+}
+export interface AnthropicManagedAgentsClientOptions {
+    /** Override the API key (default: process.env.ANTHROPIC_API_KEY). */
+    apiKey?: string;
+    /** Override the base URL (default: https://api.anthropic.com/v1). */
+    baseUrl?: string;
+    /** Override fetch (used by tests). */
+    fetchImpl?: typeof fetch;
+}
+export declare class AnthropicManagedAgentsClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(opts?: AnthropicManagedAgentsClientOptions);
+    createSession(input: CreateSessionInput): Promise<CreateSessionOutput>;
+    sendTurn(input: SendTurnInput): Promise<SendTurnOutput>;
+    getSession(input: {
+        sessionId: string;
+    }): Promise<SessionState>;
+    listSessions(): Promise<ListSessionsOutput>;
+    closeSession(input: {
+        sessionId: string;
+    }): Promise<{
+        ok: boolean;
+        [key: string]: unknown;
+    }>;
+    memoryRead(input: MemoryReadInput): Promise<unknown>;
+    memoryWrite(input: MemoryWriteInput): Promise<MemoryAck>;
+    private request;
+}
+//# sourceMappingURL=managed-agents-anthropic.d.ts.map

package/dist/managed-agents-anthropic.js

@@ -0,0 +1,123 @@
+/**
+ * Anthropic Managed Agents client (April 2026 launch).
+ *
+ * Hosted long-horizon agent platform. This module is a STANDALONE backend
+ * that workspace agents can route through when ANTHROPIC_API_KEY is set.
+ * Wiring into ./workspace-agents.ts happens in a follow-up pass.
+ *
+ * Beta header: `anthropic-beta: managed-agents-2026-04-01` is sent on every
+ * request.
+ *
+ * SPEC: best-effort, refine when official docs published.
+ * Endpoint shape mirrors the public beta announcement; refine when the
+ * official OpenAPI spec lands.
+ */
+const DEFAULT_BASE_URL = 'https://api.anthropic.com/v1';
+const BETA_HEADER_VALUE = 'managed-agents-2026-04-01';
+const ANTHROPIC_VERSION = '2023-06-01';
+export class AnthropicManagedAgentsError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = 'AnthropicManagedAgentsError';
+        this.status = status;
+        this.body = body;
+    }
+}
+export class AnthropicManagedAgentsClient {
+    apiKey;
+    baseUrl;
+    fetchImpl;
+    constructor(opts = {}) {
+        const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new Error('AnthropicManagedAgentsClient: ANTHROPIC_API_KEY is not set');
+        }
+        this.apiKey = apiKey;
+        this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+    }
+    // ── Sessions ────────────────────────────────────────────────────────────
+    async createSession(input) {
+        if (!input.mission || !input.mission.trim()) {
+            throw new Error('createSession: mission is required');
+        }
+        const body = { mission: input.mission };
+        if (input.model)
+            body.model = input.model;
+        if (input.allowedTools)
+            body.tools = input.allowedTools;
+        return this.request('POST', '/agents/sessions', body);
+    }
+    async sendTurn(input) {
+        if (!input.sessionId)
+            throw new Error('sendTurn: sessionId is required');
+        return this.request('POST', `/agents/sessions/${encodeURIComponent(input.sessionId)}/turns`, { input: input.input });
+    }
+    async getSession(input) {
+        if (!input.sessionId)
+            throw new Error('getSession: sessionId is required');
+        return this.request('GET', `/agents/sessions/${encodeURIComponent(input.sessionId)}`);
+    }
+    async listSessions() {
+        return this.request('GET', '/agents/sessions');
+    }
+    async closeSession(input) {
+        if (!input.sessionId) {
+            throw new Error('closeSession: sessionId is required');
+        }
+        return this.request('DELETE', `/agents/sessions/${encodeURIComponent(input.sessionId)}`);
+    }
+    // ── Memory ──────────────────────────────────────────────────────────────
+    async memoryRead(input) {
+        if (!input.sessionId)
+            throw new Error('memoryRead: sessionId is required');
+        const path = input.key
+            ? `/agents/sessions/${encodeURIComponent(input.sessionId)}/memory/${encodeURIComponent(input.key)}`
+            : `/agents/sessions/${encodeURIComponent(input.sessionId)}/memory`;
+        return this.request('GET', path);
+    }
+    async memoryWrite(input) {
+        if (!input.sessionId)
+            throw new Error('memoryWrite: sessionId is required');
+        if (!input.key)
+            throw new Error('memoryWrite: key is required');
+        return this.request('POST', `/agents/sessions/${encodeURIComponent(input.sessionId)}/memory`, { key: input.key, value: input.value });
+    }
+    // ── Internals ───────────────────────────────────────────────────────────
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'x-api-key': this.apiKey,
+            'anthropic-version': ANTHROPIC_VERSION,
+            'anthropic-beta': BETA_HEADER_VALUE,
+        };
+        const init = { method, headers };
+        if (body !== undefined && method !== 'GET') {
+            headers['content-type'] = 'application/json';
+            init.body = JSON.stringify(body);
+        }
+        let res;
+        try {
+            res = await this.fetchImpl(url, init);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new AnthropicManagedAgentsError(`network error contacting ${url}: ${msg}`, 0, '');
+        }
+        const text = await res.text();
+        if (!res.ok) {
+            throw new AnthropicManagedAgentsError(`Anthropic Managed Agents ${method} ${path} failed: ${res.status} ${res.statusText}`, res.status, text);
+        }
+        if (!text)
+            return {};
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new AnthropicManagedAgentsError(`Anthropic Managed Agents ${method} ${path} returned non-JSON body`, res.status, text);
+        }
+    }
+}
+//# sourceMappingURL=managed-agents-anthropic.js.map

package/dist/plugins-integrity.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Plugin integrity verification — fail-closed SHA-256 manifest checking.
+ *
+ * Ports OpenClaw's `plugins.json5` integrity-pinned plugin model. Plugins must
+ * be declared in a manifest with a SHA-256 hash; the loader verifies the file
+ * on disk against the manifest entry and refuses to load on drift.
+ *
+ * Manifest format here is plain JSON. If we add a JSON5 dep later (e.g.
+ * `json5`), swap `JSON.parse` for `JSON5.parse` and accept `.json5` files.
+ */
+export interface ManifestEntry {
+    name: string;
+    version: string;
+    /** Path relative to the plugins directory (e.g. ~/.kbot/plugins). */
+    path: string;
+    /** SHA-256 hash, base64-encoded, prefixed with "sha256-". */
+    integrity: string;
+}
+export interface Manifest {
+    schemaVersion: 1;
+    plugins: ManifestEntry[];
+}
+export type VerifyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+    expected: string;
+    actual: string;
+};
+export interface VerifyAllResult {
+    verified: string[];
+    failed: Array<{
+        name: string;
+        reason: string;
+        expected?: string;
+        actual?: string;
+    }>;
+}
+export declare class IntegrityError extends Error {
+    failed: VerifyAllResult['failed'];
+    constructor(failed: VerifyAllResult['failed']);
+}
+/**
+ * Load and validate a manifest from disk. Throws on missing file, invalid
+ * JSON, or schema violation.
+ */
+export declare function loadManifest(path: string): Promise<Manifest>;
+/**
+ * Verify a single plugin file against its manifest entry.
+ *
+ * - Missing file → `{ ok: false, reason: "plugin file missing" }`
+ * - Hash mismatch → `{ ok: false, reason: "integrity drift" }`
+ * - Match → `{ ok: true }`
+ */
+export declare function verifyPlugin(filePath: string, manifestEntry: ManifestEntry): Promise<VerifyResult>;
+/**
+ * Verify every plugin in a manifest against the corresponding files under
+ * `pluginsDir`. Resolves entry paths relative to `pluginsDir` unless
+ * absolute.
+ *
+ * Always returns a result; never throws on drift. Callers should pass the
+ * result to `enforce()` to fail closed.
+ */
+export declare function verifyAllPlugins(manifestPath: string, pluginsDir: string): Promise<VerifyAllResult>;
+/**
+ * Fail-closed gate. Throws `IntegrityError` if any plugin failed verification.
+ * No-op when all plugins are verified. Loaders should call this unless
+ * integrity checking has been explicitly disabled (e.g. dev override).
+ */
+export declare function enforce(result: VerifyAllResult): void;
+//# sourceMappingURL=plugins-integrity.d.ts.map