@vibesdotdev/storage 0.0.1 → 1.0.0-rc.3

package/dist/testing.js

@@ -0,0 +1,82 @@
+/**
+ * Test-safe storage manifest implementation.
+ *
+ * Storage owns the manifest contract, so storage-specific test doubles live here
+ * rather than in the generic @vibesdotdev/testing substrate.
+ */
+import { getLogger } from '@vibesdotdev/logging';
+import { CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+import { StorageManifest } from "./manifest/base.js";
+/** Notify one subscriber; a test subscriber that throws never stops the manifest updating, and says why. */
+function notifyTestSubscriber(runtime, callback, data) {
+    const logger = getLogger('storage:testing', runtime);
+    try {
+        callback(data);
+    }
+    catch (error) {
+        logger.warn('A test manifest subscriber threw', { error: valueFreeFailure(CaughtFailureSchema.parse(error)) });
+    }
+}
+export class MockStorageManifest extends StorageManifest {
+    _data = null;
+    _updateQueue = Promise.resolve();
+    _subscribers = new Set();
+    /** The test host's runtime: a subscriber failure is reported to its Logging. */
+    handedRuntime;
+    constructor(descriptorOrId, context) {
+        super(descriptorOrId, context);
+        this.handedRuntime = context.runtime;
+    }
+    async load() {
+        return this._data;
+    }
+    async save(data) {
+        this._data = data;
+        this.notifySubscribers(data);
+    }
+    async exists() {
+        return this._data !== null;
+    }
+    async delete() {
+        this._data = null;
+        this.notifySubscribers(null);
+    }
+    async loadOrDefault(defaultValue) {
+        return this._data ?? defaultValue;
+    }
+    async update(transform) {
+        const operation = this._updateQueue.then(async () => {
+            const updated = await transform(this._data);
+            await this.save(updated);
+        });
+        // The queue tail waits for this update to settle either way; its failure
+        // reaches this caller through `await operation`.
+        this._updateQueue = Promise.allSettled([operation]).then(() => undefined);
+        await operation;
+    }
+    getCachedData() {
+        return this._data ?? undefined;
+    }
+    isCached() {
+        return true;
+    }
+    invalidateCache() {
+        // Memory-only store is always fresh.
+    }
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => {
+            this._subscribers.delete(callback);
+        };
+    }
+    notifySubscribers(data) {
+        for (const callback of this._subscribers)
+            notifyTestSubscriber(this.handedRuntime, callback, data);
+    }
+    reset() {
+        this._data = null;
+        this._updateQueue = Promise.resolve();
+        this._subscribers.clear();
+    }
+}
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"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"}

package/dist/tools/descriptors.d.ts

@@ -0,0 +1,312 @@
+/**
+ * Storage agent-tool descriptors.
+ *
+ * Generic `tools/tool` descriptors owned by the storage feature package.
+ * The impls speak the platform object/browse HTTP protocol (providerId-based,
+ * server-side config resolution) so they run on any surface — including
+ * workerd, where no filesystem or direct adapter bindings exist.
+ */
+export declare const STORAGE_TOOL_IDS: readonly ["storage.browse", "storage.copy", "storage.search"];
+export type StorageToolId = (typeof STORAGE_TOOL_IDS)[number];
+export declare function isStorageToolId(value: string): value is StorageToolId;
+export declare const storageBrowseToolDescriptor: {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            path: import("zod/v4").ZodDefault<import("zod/v4").ZodString>;
+            itemId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            limit: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            mode: import("zod/v4").ZodEnum<{
+                entries: "entries";
+                drives: "drives";
+            }>;
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            path: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            drives: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                id: import("zod/v4").ZodString;
+                name: import("zod/v4").ZodString;
+                kind: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                scope: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            entries: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                name: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                kind: import("zod/v4").ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+                providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sizeBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+                modifiedAt: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                documentId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sourceRefreshUrl: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            notes: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+};
+export declare const storageCopyToolDescriptor: {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            source: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            target: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            source: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+            }, import("zod/v4/core").$strip>;
+            target: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+            }, import("zod/v4/core").$strip>;
+            sizeBytes: import("zod/v4").ZodNumber;
+            contentType: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            message: import("zod/v4").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+};
+export declare const storageSearchToolDescriptor: {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            query: import("zod/v4").ZodString;
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            path: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            limit: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            results: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                name: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                kind: import("zod/v4").ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+                providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sizeBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+                modifiedAt: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                documentId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sourceRefreshUrl: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            query: import("zod/v4").ZodString;
+            notes: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+};
+export declare const storageToolDescriptors: readonly [{
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            path: import("zod/v4").ZodDefault<import("zod/v4").ZodString>;
+            itemId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            limit: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            mode: import("zod/v4").ZodEnum<{
+                entries: "entries";
+                drives: "drives";
+            }>;
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            path: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            drives: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                id: import("zod/v4").ZodString;
+                name: import("zod/v4").ZodString;
+                kind: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                scope: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            entries: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                name: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                kind: import("zod/v4").ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+                providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sizeBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+                modifiedAt: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                documentId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sourceRefreshUrl: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            notes: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+}, {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            source: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            target: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            source: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+            }, import("zod/v4/core").$strip>;
+            target: import("zod/v4").ZodObject<{
+                providerId: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+            }, import("zod/v4/core").$strip>;
+            sizeBytes: import("zod/v4").ZodNumber;
+            contentType: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            message: import("zod/v4").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+}, {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            query: import("zod/v4").ZodString;
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            path: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            limit: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            results: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                name: import("zod/v4").ZodString;
+                path: import("zod/v4").ZodString;
+                kind: import("zod/v4").ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+                providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sizeBytes: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+                modifiedAt: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                documentId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                sourceRefreshUrl: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            providerId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            driveId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            query: import("zod/v4").ZodString;
+            notes: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+}];
+//# sourceMappingURL=descriptors.d.ts.map

package/dist/tools/descriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.d.ts","sourceRoot":"","sources":["../../src/tools/descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAYH,eAAO,MAAM,gBAAgB,+DAAgE,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAErE;AAUD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBtC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBpC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBtC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzB,CAAC"}

package/dist/tools/descriptors.js

@@ -0,0 +1,98 @@
+/**
+ * Storage agent-tool descriptors.
+ *
+ * Generic `tools/tool` descriptors owned by the storage feature package.
+ * The impls speak the platform object/browse HTTP protocol (providerId-based,
+ * server-side config resolution) so they run on any surface — including
+ * workerd, where no filesystem or direct adapter bindings exist.
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { StorageBrowseInputSchema, StorageBrowseOutputSchema, StorageCopyInputSchema, StorageCopyOutputSchema, StorageSearchInputSchema, StorageSearchOutputSchema } from "./schemas.js";
+export const STORAGE_TOOL_IDS = ['storage.browse', 'storage.copy', 'storage.search'];
+export function isStorageToolId(value) {
+    return STORAGE_TOOL_IDS.some((id) => id === value);
+}
+const common = {
+    kind: 'tools/tool',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['agent', 'direct', 'worker'],
+    category: 'storage',
+    tags: ['storage', 'files', 'objects']
+};
+export const storageBrowseToolDescriptor = createRuntimeAsset({
+    ...common,
+    id: 'storage.browse',
+    name: 'Browse Storage',
+    description: 'List the caller\'s storage drives (Vibes storage, connected providers, SharePoint), or list the folders and files at a path inside one drive.',
+    mcpDescription: 'List storage drives, or files and folders at a path in one drive.',
+    subcategory: 'browse',
+    safety: 'read',
+    requiresApproval: false,
+    schemas: {
+        input: StorageBrowseInputSchema,
+        output: StorageBrowseOutputSchema
+    },
+    usageGuidance: {
+        when: 'Use when the user asks what storage locations exist or what files live at a path.',
+        commonPatterns: [
+            'Call without providerId first to discover the available drives.',
+            'Pass the providerId from the drives list, then narrow with path.',
+            'When storage.search returns a directory with id, pass that id as itemId to browse the folder reliably.',
+            'Multi-drive providers (SharePoint) return their drives first — pick one and pass driveId.',
+            'To READ a listed file, pass its documentId and sourceRefreshUrl through UNCHANGED as document.read/document.view ref fields — never construct a provider download URL yourself.'
+        ]
+    }
+});
+export const storageCopyToolDescriptor = createRuntimeAsset({
+    ...common,
+    id: 'storage.copy',
+    name: 'Copy Storage Object',
+    description: 'Copy one file between storage locations (any combination of drives, e.g. SharePoint to Vibes storage). Reads the source object and writes it to the target key.',
+    mcpDescription: 'Copy one file from a source storage drive/path to a target drive/path.',
+    subcategory: 'objects',
+    safety: 'write',
+    requiresApproval: true,
+    schemas: {
+        input: StorageCopyInputSchema,
+        output: StorageCopyOutputSchema
+    },
+    usageGuidance: {
+        when: 'Use only after the user confirms the exact source file and target location.',
+        commonPatterns: [
+            'Resolve both providerIds with storage.browse before copying.',
+            'Target path is the full destination key including the file name.',
+            'Bytes stream through the object API; prefer small-to-medium files and report the copied size.'
+        ]
+    }
+});
+export const storageSearchToolDescriptor = createRuntimeAsset({
+    ...common,
+    id: 'storage.search',
+    name: 'Search Storage',
+    description: 'Search for files by content or name across connected storage drives (SharePoint, OneDrive, Vibes storage). Returns matching entries with path, kind, size, and source identifiers needed to open them.',
+    mcpDescription: 'Search for files by content or name across connected storage drives.',
+    subcategory: 'search',
+    safety: 'read',
+    requiresApproval: false,
+    schemas: {
+        input: StorageSearchInputSchema,
+        output: StorageSearchOutputSchema
+    },
+    usageGuidance: {
+        when: 'Use when the user wants to find files by name or content within a connected storage provider that supports search (e.g. SharePoint).',
+        commonPatterns: [
+            'Omit providerId to search the caller\'s connected drives in one pass.',
+            'Pass providerId and driveId only when the user has already selected a specific source.',
+            'Results include providerId, driveId, and id; for directory results, pass id to storage.browse as itemId to open that folder.',
+            'To READ a file result, pass its documentId and sourceRefreshUrl through UNCHANGED as document.read/document.view ref fields — never construct a provider download URL yourself.',
+            'Optionally narrow the search to a subtree with path.',
+            'When searching one explicit multi-drive provider (SharePoint), include driveId or list drives first with storage.browse.'
+        ]
+    }
+});
+export const storageToolDescriptors = [
+    storageBrowseToolDescriptor,
+    storageCopyToolDescriptor,
+    storageSearchToolDescriptor
+];
+//# sourceMappingURL=descriptors.js.map

package/dist/tools/descriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.js","sourceRoot":"","sources":["../../src/tools/descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EACN,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,cAAc,CAAC;AAEtB,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,gBAAgB,EAAE,cAAc,EAAE,gBAAgB,CAAU,CAAC;AAI9F,MAAM,UAAU,eAAe,CAAC,KAAa;IAC5C,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,KAAK,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,MAAM,GAAG;IACd,IAAI,EAAE,YAAqB;IAC3B,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAU;IACxC,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAU;IAC/C,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC;CACrC,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,kBAAkB,CAAC;IAC7D,GAAG,MAAM;IACT,EAAE,EAAE,gBAAgB;IACpB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EACV,+IAA+I;IAChJ,cAAc,EAAE,mEAAmE;IACnF,WAAW,EAAE,QAAQ;IACrB,MAAM,EAAE,MAAM;IACd,gBAAgB,EAAE,KAAK;IACvB,OAAO,EAAE;QACR,KAAK,EAAE,wBAAwB;QAC/B,MAAM,EAAE,yBAAyB;KACjC;IACD,aAAa,EAAE;QACd,IAAI,EAAE,mFAAmF;QACzF,cAAc,EAAE;YACf,iEAAiE;YACjE,kEAAkE;YAClE,wGAAwG;YACxG,2FAA2F;YAC3F,iLAAiL;SACjL;KACD;CACD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,kBAAkB,CAAC;IAC3D,GAAG,MAAM;IACT,EAAE,EAAE,cAAc;IAClB,IAAI,EAAE,qBAAqB;IAC3B,WAAW,EACV,iKAAiK;IAClK,cAAc,EAAE,wEAAwE;IACxF,WAAW,EAAE,SAAS;IACtB,MAAM,EAAE,OAAO;IACf,gBAAgB,EAAE,IAAI;IACtB,OAAO,EAAE;QACR,KAAK,EAAE,sBAAsB;QAC7B,MAAM,EAAE,uBAAuB;KAC/B;IACD,aAAa,EAAE;QACd,IAAI,EAAE,6EAA6E;QACnF,cAAc,EAAE;YACf,8DAA8D;YAC9D,kEAAkE;YAClE,+FAA+F;SAC/F;KACD;CACD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,2BAA2B,GAAG,kBAAkB,CAAC;IAC7D,GAAG,MAAM;IACT,EAAE,EAAE,gBAAgB;IACpB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EACV,wMAAwM;IACzM,cAAc,EAAE,sEAAsE;IACtF,WAAW,EAAE,QAAQ;IACrB,MAAM,EAAE,MAAM;IACd,gBAAgB,EAAE,KAAK;IACvB,OAAO,EAAE;QACR,KAAK,EAAE,wBAAwB;QAC/B,MAAM,EAAE,yBAAyB;KACjC;IACD,aAAa,EAAE;QACd,IAAI,EAAE,sIAAsI;QAC5I,cAAc,EAAE;YACf,uEAAuE;YACvE,wFAAwF;YACxF,8HAA8H;YAC9H,iLAAiL;YACjL,sDAAsD;YACtD,0HAA0H;SAC1H;KACD;CACD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACrC,2BAA2B;IAC3B,yBAAyB;IACzB,2BAA2B;CAClB,CAAC"}

package/dist/tools/impl.d.ts

@@ -0,0 +1,72 @@
+import type { StorageToolUploadOptions } from '../schemas/tools/views.ts';
+export type { StorageToolUploadOptions } from '../schemas/tools/views.ts';
+/**
+ * Storage agent-tool implementations.
+ *
+ * Generic storage tools over the platform object/browse protocol. Everything
+ * goes through the canonical `platform` runtime client's `storage` namespace
+ * (HTTP `/api/storage/*` routes), bound to the caller's session cookie or JWT —
+ * the same transport StorageExplorer uses. The tools only ever send `providerId`
+ * (+ driveId/path); platform-web re-resolves the trusted adapter config
+ * server-side (`resolveOwnedTarget` / `assertOwnedBrowseConfig`, the
+ * cross-tenant IDOR fix) — raw adapter config never leaves this process'
+ * lookup of the caller's own drives.
+ *
+ * `storage.copy` composes the object protocol's read + upload primitives —
+ * the ObjectStore interface has no copy primitive and the compose keeps the
+ * platform surface unchanged.
+ *
+ * Workerd-safe: HTTP + Blob only, no filesystem, no direct adapter bindings.
+ *
+ * NOTE on deps: this package cannot import `@vibesdotdev/platform` or
+ * `@vibesdotdev/tools` (both depend on storage — importing them back would
+ * close a workspace cycle). The platform client resolves dynamically through
+ * the runtime registry and is typed structurally below.
+ */
+import * as z from 'zod/v4';
+import type { VibesRuntime } from '@vibesdotdev/kernel/api/runtime';
+import type { ToolCallContext } from '@vibesdotdev/kernel/schemas/tool-call';
+import type { StorageDrive, StorageEntry, StorageObjectRef, StorageTarget } from '../schemas/adapter-descriptor.ts';
+import { type StorageToolId } from './descriptors.ts';
+import { type StorageBrowseOutput, type StorageCopyOutput, type StorageSearchOutput } from './schemas.ts';
+/** A drive target's opaque adapter config, passed back to browse and search as resolved. */
+export type StorageToolAdapterConfig = NonNullable<StorageTarget['config']>;
+/** Options an object upload takes. */
+/** Structural view of the platform client's storage namespace (see NOTE above). */
+export interface PlatformStorageToolClient {
+    storage: {
+        drives(scope?: {
+            projectId?: string;
+        }): Promise<StorageTarget[]>;
+        browse: {
+            listDrives(adapterId: string, config?: StorageToolAdapterConfig): Promise<StorageDrive[]>;
+            list(adapterId: string, driveId: string, path?: string, config?: StorageToolAdapterConfig, options?: {
+                itemId?: string;
+            }): Promise<StorageEntry[]>;
+        };
+        search: {
+            search(adapterId: string, driveId: string, query: string, opts?: {
+                path?: string;
+                limit?: number;
+            }, config?: StorageToolAdapterConfig): Promise<StorageEntry[]>;
+        };
+        objects: {
+            read(target: StorageTarget, key: string): Promise<{
+                contentType?: string;
+                data: ArrayBuffer;
+            } | null>;
+            upload(target: StorageTarget, key: string, file: Blob, opts?: StorageToolUploadOptions): Promise<StorageObjectRef>;
+        };
+    };
+}
+export type PlatformStorageClientResolver = (ctx: ToolCallContext, runtime: VibesRuntime) => Promise<PlatformStorageToolClient>;
+/** What a storage tool answers: its own output schema's value. */
+export type StorageToolOutput = StorageBrowseOutput | StorageCopyOutput | StorageSearchOutput;
+/** A tool call's raw argument object; each tool parses it with its own input schema. */
+declare const StorageToolRawInputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type StorageToolInput = z.infer<typeof StorageToolRawInputSchema>;
+export interface StorageToolImplementation {
+    execute(input: StorageToolInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<StorageToolOutput>;
+}
+export declare function createStorageTool(toolId: StorageToolId, resolveClient?: PlatformStorageClientResolver): StorageToolImplementation;
+//# sourceMappingURL=impl.d.ts.map

package/dist/tools/impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impl.d.ts","sourceRoot":"","sources":["../../src/tools/impl.ts"],"names":[],"mappings":"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"}