agentic-drive 0.0.0-stage → 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface CliIo {
+    out(text: string): void;
+    err(text: string): void;
+    env: Record<string, string | undefined>;
+}
+declare class UsageError extends Error {
+}
+declare function runCli(argv: string[], io: CliIo): Promise<number>;
+
+export { type CliIo, UsageError, runCli };

package/dist/cli.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-4QE7E5UQ.js";
+import {
+  DriveError,
+  buildExport,
+  openLocal,
+  publicNode,
+  upload
+} from "./chunk-QRGKXPLX.js";
+
+// src/cli.ts
+import { createReadStream, realpathSync, writeFileSync } from "fs";
+import { basename, join, resolve } from "path";
+import { pathToFileURL } from "url";
+import { parseArgs } from "util";
+var HELP = `agentic-drive ${VERSION}
+Store, sort, and share files and folders.
+
+Usage: agentic-drive <command> [flags]
+
+Commands:
+  ls [path]                    List a folder.
+  stat <path|id>               Show one item.
+  mkdir <path> [-p]            Make a folder.
+  upload <local> <remote>      Upload a file. End remote with "/" to keep the name.
+  download <remote> [out]      Save a file. Use "-" for stdout.
+  mv <src> <folder>            Move an item. Use --name to rename it.
+  rm <path|id>                 Move an item to the trash.
+  trash                        List the trash.
+  restore <id>                 Put a trashed item back.
+  purge <id>                   Delete a trashed item for good.
+  search                       Find items. Flags: --name --mime --kind --min-size --max-size --created-by-kind --limit
+  export <out.zip>             Write everything you own to a zip with a JSON manifest.
+  delete-all --yes             Delete everything you own for good.
+  mcp                          Start the MCP server on stdio.
+
+Flags:
+  --dir <path>        Data folder. Env AGENTIC_DRIVE_DIR. Default ./.agentic-drive
+  --owner <id>        Drive owner. Env AGENTIC_DRIVE_OWNER. Default "me"
+  --actor <id>        Who acts. Env AGENTIC_DRIVE_ACTOR. Default the owner
+  --actor-kind <k>    Actor kind. Env AGENTIC_DRIVE_KIND. Default human
+  --on-conflict <m>   fail, rename, or replace
+  -p, --parents       Create missing parent folders
+`;
+var UsageError = class extends Error {
+};
+var options = {
+  dir: { type: "string" },
+  owner: { type: "string" },
+  actor: { type: "string" },
+  "actor-kind": { type: "string" },
+  "on-conflict": { type: "string" },
+  parents: { type: "boolean", short: "p" },
+  mime: { type: "string" },
+  "max-bytes": { type: "string" },
+  kind: { type: "string" },
+  name: { type: "string" },
+  parent: { type: "string" },
+  "min-size": { type: "string" },
+  "max-size": { type: "string" },
+  "created-by-kind": { type: "string" },
+  limit: { type: "string" },
+  yes: { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "V" }
+};
+function num(value, flag) {
+  if (value === void 0) return void 0;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) throw new UsageError(`--${flag} needs a number of 0 or more`);
+  return n;
+}
+async function runCli(argv, io) {
+  try {
+    const { values, positionals } = parseArgs({ args: argv, options, allowPositionals: true, strict: true });
+    const [command, ...args] = positionals;
+    if (values.version) return io.out(VERSION), 0;
+    if (!command || values.help || command === "help") return io.out(HELP), 0;
+    const need = (n, usage) => {
+      if (args.length < n) throw new UsageError(`usage: agentic-drive ${usage}`);
+    };
+    const env = io.env;
+    const dir = resolve(values.dir ?? env.AGENTIC_DRIVE_DIR ?? ".agentic-drive");
+    const { drive, ctx } = openLocal({
+      dir,
+      owner: values.owner ?? env.AGENTIC_DRIVE_OWNER ?? "me",
+      actor: values.actor ?? env.AGENTIC_DRIVE_ACTOR,
+      kind: values["actor-kind"] ?? env.AGENTIC_DRIVE_KIND
+    });
+    const onConflict = values["on-conflict"];
+    if (onConflict && !["fail", "rename", "replace"].includes(onConflict)) throw new UsageError("--on-conflict needs fail, rename, or replace");
+    const print = (value) => io.out(JSON.stringify(value));
+    switch (command) {
+      case "ls":
+        print((await drive.list(ctx, args[0] ?? "/")).map((n) => publicNode(n)));
+        break;
+      case "stat":
+        need(1, "stat <path|id>");
+        print(publicNode(await drive.stat(ctx, args[0])));
+        break;
+      case "mkdir":
+        need(1, "mkdir <path> [-p]");
+        print(publicNode(await drive.mkdir(ctx, args[0], { parents: values.parents })));
+        break;
+      case "upload": {
+        need(2, "upload <local> <remote>");
+        const remote = args[1].endsWith("/") ? `${args[1]}${basename(args[0])}` : args[1];
+        const node = await upload(drive, ctx, remote, createReadStream(resolve(args[0])), {
+          mime: values.mime,
+          maxBytes: num(values["max-bytes"], "max-bytes"),
+          parents: values.parents,
+          onConflict
+        });
+        print(publicNode(node));
+        break;
+      }
+      case "download": {
+        need(1, "download <remote> [out]");
+        const { node, data } = await drive.read(ctx, args[0]);
+        const out = args[1] ?? node.name;
+        if (out === "-") process.stdout.write(data);
+        else {
+          writeFileSync(resolve(out), data);
+          print({ saved: resolve(out), size: data.byteLength, hash: node.hash });
+        }
+        break;
+      }
+      case "mv":
+        need(2, "mv <src> <folder>");
+        print(publicNode(await drive.move(ctx, args[0], args[1], { name: values.name, onConflict })));
+        break;
+      case "rm":
+        need(1, "rm <path|id>");
+        print(publicNode(await drive.trash(ctx, args[0])));
+        break;
+      case "trash":
+        print((await drive.listTrash(ctx)).map((n) => publicNode(n)));
+        break;
+      case "restore":
+        need(1, "restore <id>");
+        print(publicNode(await drive.restore(ctx, args[0], { parentId: values.parent, onConflict })));
+        break;
+      case "purge":
+        need(1, "purge <id>");
+        print(await drive.purge(ctx, args[0]));
+        break;
+      case "search":
+        print((await drive.search(ctx, {
+          name: values.name,
+          mime: values.mime,
+          kind: values.kind,
+          minSize: num(values["min-size"], "min-size"),
+          maxSize: num(values["max-size"], "max-size"),
+          createdByKind: values["created-by-kind"],
+          limit: num(values.limit, "limit")
+        })).map((r) => publicNode(r.node, r.path)));
+        break;
+      case "export": {
+        need(1, "export <out.zip>");
+        const zip = await buildExport(drive, ctx);
+        writeFileSync(resolve(args[0]), zip);
+        print({ saved: resolve(args[0]), size: zip.byteLength });
+        break;
+      }
+      case "delete-all":
+        if (!values.yes) throw new UsageError("delete-all removes everything you own for good. Add --yes to confirm.");
+        print(await drive.deleteAll(ctx));
+        break;
+      case "mcp": {
+        const { startMcp } = await import("./mcp.js");
+        await startMcp({ drive, ctx, exportDir: join(dir, "exports") });
+        return 0;
+      }
+      default:
+        throw new UsageError(`unknown command "${command}"`);
+    }
+    return 0;
+  } catch (error) {
+    if (error instanceof UsageError || error instanceof TypeError && "code" in error && String(error.code).startsWith("ERR_PARSE_ARGS")) {
+      io.err(JSON.stringify({ error: { code: "USAGE", message: error.message } }));
+      return 2;
+    }
+    if (error instanceof DriveError) {
+      io.err(JSON.stringify({ error: { code: error.code, message: error.message } }));
+      return 1;
+    }
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      io.err(JSON.stringify({ error: { code: "LOCAL_FILE_NOT_FOUND", message: error.message } }));
+      return 1;
+    }
+    io.err(JSON.stringify({ error: { code: "INTERNAL", message: error instanceof Error ? error.message : String(error) } }));
+    return 1;
+  }
+}
+function isMainModule() {
+  const invoked = process.argv[1];
+  if (typeof invoked !== "string") return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(invoked)).href;
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  runCli(process.argv.slice(2), {
+    out: (t) => console.log(t),
+    err: (t) => console.error(t),
+    env: process.env
+  }).then((code) => {
+    if (code !== 0) process.exit(code);
+  });
+}
+export {
+  UsageError,
+  runCli
+};

package/dist/drive-DRQ8LiHl.d.ts

@@ -0,0 +1,144 @@
+import { Store, Blobs } from 'agentic-identity';
+
+declare const ROOT_ID = "root";
+declare const ACTOR_KINDS: readonly ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
+type ActorKind = (typeof ACTOR_KINDS)[number];
+type Actor = {
+    id: string;
+    kind: ActorKind;
+};
+/** `owner` is the drive's owner. `actor` is who acts for them. */
+type Ctx = {
+    owner: string;
+    actor: Actor;
+};
+type Action = "read" | "write" | "delete";
+/** The seam for sharing. A later release swaps this for a role check. */
+type Can = (ctx: Ctx, action: Action, node: Node) => boolean | Promise<boolean>;
+type Node = {
+    id: string;
+    owner: string;
+    parentId: string;
+    kind: "folder" | "file" | "ref";
+    name: string;
+    nameKey: string;
+    size: number;
+    mime: string | null;
+    hash: string | null;
+    /** A typed reference such as `docs:<id>`. Set when kind is "ref". */
+    ref: string | null;
+    blobKey: string | null;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: Actor;
+    updatedBy: Actor;
+    trashed: boolean;
+    trashedAt: number | null;
+    /** Set while a purge deletes the item. Nothing can see or change it then. */
+    purging: boolean;
+};
+type ErrorCode = "NOT_FOUND" | "NAME_TAKEN" | "BLOB_EXISTS" | "INVALID_NAME" | "INVALID_PATH" | "INVALID_REF" | "NOT_A_FOLDER" | "NOT_A_FILE" | "MOVE_INTO_SELF" | "TOO_DEEP" | "PARENT_GONE" | "TRASHED" | "NOT_TRASHED" | "IS_ROOT" | "FORBIDDEN" | "BLOB_MISSING" | "TOO_LARGE" | "INVALID_EXPIRY" | "BUSY";
+declare class DriveError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}
+interface SearchQuery {
+    /** Part of the name. Case and Unicode form do not matter. */
+    name?: string;
+    /** An exact type, or a family such as `image/*`. */
+    mime?: string;
+    kind?: Node["kind"];
+    minSize?: number;
+    maxSize?: number;
+    /** Items first made by this kind of actor, such as `agent_of_human`. */
+    createdByKind?: ActorKind;
+    /** At most this many results. Defaults to 100. */
+    limit?: number;
+}
+type OnConflict = "fail" | "rename" | "replace";
+interface DriveDeps {
+    store: Store;
+    blobs: Blobs;
+    now?: () => number;
+    newId?: () => string;
+    can?: Can;
+    /** Most parent steps any ancestor walk takes. A walk that hits it fails closed. */
+    maxDepth?: number;
+    /** Called with a blob key that no node points at and that could not be deleted. */
+    onOrphan?: (key: string, error: unknown) => void;
+}
+type Drive = ReturnType<typeof createDrive>;
+/** Validates a name. Names are NFC-normalized. Two names clash when their keys match. */
+declare function parseName(raw: string): {
+    name: string;
+    key: string;
+};
+declare function createDrive(deps: DriveDeps): {
+    stat(ctx: Ctx, loc: string): Promise<Node>;
+    /** Live children, sorted by name. */
+    list(ctx: Ctx, loc?: string): Promise<Node[]>;
+    mkdir(ctx: Ctx, path: string, opts?: {
+        parents?: boolean;
+    }): Promise<Node>;
+    /**
+     * Stores one blob and one node. The blob is written first. The new node commits before
+     * any old blob goes. A failed old-blob delete leaves an orphan and never undoes the commit.
+     */
+    putFile(ctx: Ctx, path: string, data: Uint8Array, opts?: {
+        mime?: string;
+        parents?: boolean;
+        onConflict?: OnConflict;
+    }): Promise<Node>;
+    /** A reference points at a document in another app, such as `docs:<id>`. */
+    putRef(ctx: Ctx, path: string, ref: string, opts?: {
+        parents?: boolean;
+        onConflict?: OnConflict;
+    }): Promise<Node>;
+    read(ctx: Ctx, loc: string): Promise<{
+        node: Node;
+        data: Uint8Array;
+        contentType?: string;
+    }>;
+    /**
+     * A time-limited URL to fetch the bytes. The URL signs an attachment header and the stored
+     * type, so the link holder cannot change how the bytes are served. Trashing an item does
+     * not revoke a link already issued.
+     */
+    downloadUrl(ctx: Ctx, loc: string, expiresInSeconds?: number): Promise<string>;
+    move(ctx: Ctx, src: string, destLoc: string, opts?: {
+        name?: string;
+        onConflict?: OnConflict;
+    }): Promise<Node>;
+    rename(ctx: Ctx, loc: string, name: string): Promise<Node>;
+    /** Hides an item and, for a folder, everything under it. Nothing else changes. */
+    trash(ctx: Ctx, loc: string): Promise<Node>;
+    /** Items trashed on their own, newest first. */
+    listTrash(ctx: Ctx): Promise<Node[]>;
+    /** Puts a trashed item back. It needs a live parent folder. */
+    restore(ctx: Ctx, id: string, opts?: {
+        parentId?: string;
+        onConflict?: OnConflict;
+    }): Promise<Node>;
+    /** Live items that match every field given, sorted by path. */
+    search(ctx: Ctx, q?: SearchQuery): Promise<{
+        node: Node;
+        path: string;
+    }[]>;
+    /** Every item of the owner, trashed or not, with its original path and bytes. For export. */
+    exportData(ctx: Ctx): Promise<{
+        node: Node;
+        path: string;
+        data: Uint8Array | null;
+        missing: boolean;
+    }[]>;
+    /** Deletes every item and blob of the owner for good. Only the owner may do this, never an agent for them. A failed call can run again. */
+    deleteAll(ctx: Ctx): Promise<{
+        removed: number;
+    }>;
+    /** Deletes a trashed item for good, with everything under it and all their bytes. */
+    purge(ctx: Ctx, id: string): Promise<{
+        removed: number;
+    }>;
+};
+
+export { type ActorKind as A, type Ctx as C, type Drive as D, type ErrorCode as E, type Node as N, type OnConflict as O, ROOT_ID as R, type SearchQuery as S, type Actor as a, ACTOR_KINDS as b, type Action as c, type Can as d, type DriveDeps as e, DriveError as f, createDrive as g, parseName as p };

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+import { O as OnConflict, D as Drive, C as Ctx, N as Node, A as ActorKind, a as Actor } from './drive-DRQ8LiHl.js';
+export { b as ACTOR_KINDS, c as Action, d as Can, e as DriveDeps, f as DriveError, E as ErrorCode, R as ROOT_ID, S as SearchQuery, g as createDrive, p as parseName } from './drive-DRQ8LiHl.js';
+import { AdapterOptions, Blobs, Store } from 'agentic-identity';
+
+declare const VERSION: string;
+
+/**
+ * A Store kept in a journal file: one JSON line per committed write set, replayed on open.
+ * It is the shared memory store plus the journal, so it follows the same rules. One process at a time.
+ * A half-written last line (a crash during an append) is cut off on open. A bad line anywhere else
+ * throws, because the data cannot be trusted. If an append fails, the store refuses every later call.
+ * `shared` exists for the contract suites: stores that share a name share one live dataset, so do not
+ * open the same directory twice with it in production.
+ */
+declare function createFileStore(dir: string, options?: AdapterOptions & {
+    shared?: string;
+}): Store;
+/** Blobs kept as files under `dir`. One process at a time: a conditional put is atomic only inside one process. File names are key hashes, so no key escapes the folder. */
+declare function createFileBlobs(dir: string, options?: AdapterOptions): Blobs;
+
+declare const DEFAULT_MAX_BYTES: number;
+/** The type named by the first bytes, or null when they match no known signature. */
+declare function sniffMime(head: Uint8Array): string | null;
+interface UploadOptions {
+    /** Refuse a stream longer than this. Defaults to 25 MiB. */
+    maxBytes?: number;
+    /** The type the caller claims. Known file signatures override it. */
+    mime?: string;
+    parents?: boolean;
+    onConflict?: OnConflict;
+}
+/** Reads the stream with a size cap, finds the type, hashes the bytes, then stores the file. */
+declare function upload(drive: Drive, ctx: Ctx, path: string, source: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, opts?: UploadOptions): Promise<Node>;
+
+/**
+ * Everything one owner has, as a zip. `manifest.json` lists each item with its
+ * metadata and, for a file, the entry that holds its bytes. Trashed items are included and flagged.
+ * Entries are named by item id, never by file name. A file whose bytes are gone is marked `missing`.
+ */
+declare function buildExport(drive: Drive, ctx: Ctx, now?: () => number): Promise<Uint8Array>;
+
+interface ZipEntry {
+    name: string;
+    data: Uint8Array;
+}
+declare function writeZip(entries: ZipEntry[], at: number): Uint8Array;
+/** Reads a zip made by `writeZip`. It checks every CRC. */
+declare function readZip(bytes: Uint8Array): Map<string, Uint8Array>;
+
+interface LocalOptions {
+    /** Where the drive keeps its data. */
+    dir: string;
+    /** Whose drive this is. */
+    owner: string;
+    /** Who acts. Defaults to the owner. */
+    actor?: string;
+    /** What kind of actor. Defaults to `human`. Set an agent kind when an agent runs the command. */
+    kind?: ActorKind;
+}
+declare function openLocal(options: LocalOptions): {
+    drive: Drive;
+    ctx: Ctx;
+};
+/** A node as the CLI and MCP print it: no storage keys. */
+declare function publicNode(node: Node, path?: string): {
+    id: string;
+    owner: string;
+    parentId: string;
+    kind: "folder" | "file" | "ref";
+    name: string;
+    size: number;
+    mime: string | null;
+    hash: string | null;
+    ref: string | null;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: Actor;
+    updatedBy: Actor;
+    trashed: boolean;
+    trashedAt: number | null;
+} | {
+    id: string;
+    owner: string;
+    parentId: string;
+    kind: "folder" | "file" | "ref";
+    name: string;
+    size: number;
+    mime: string | null;
+    hash: string | null;
+    ref: string | null;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: Actor;
+    updatedBy: Actor;
+    trashed: boolean;
+    trashedAt: number | null;
+    path: string;
+};
+
+export { Actor, ActorKind, Ctx, DEFAULT_MAX_BYTES, Drive, Node, OnConflict, type UploadOptions, VERSION, buildExport, createFileBlobs, createFileStore, openLocal, publicNode, readZip, sniffMime, upload, writeZip };

package/dist/index.js

@@ -0,0 +1,38 @@
+import {
+  VERSION
+} from "./chunk-4QE7E5UQ.js";
+import {
+  ACTOR_KINDS,
+  DEFAULT_MAX_BYTES,
+  DriveError,
+  ROOT_ID,
+  buildExport,
+  createDrive,
+  createFileBlobs,
+  createFileStore,
+  openLocal,
+  parseName,
+  publicNode,
+  readZip,
+  sniffMime,
+  upload,
+  writeZip
+} from "./chunk-QRGKXPLX.js";
+export {
+  ACTOR_KINDS,
+  DEFAULT_MAX_BYTES,
+  DriveError,
+  ROOT_ID,
+  VERSION,
+  buildExport,
+  createDrive,
+  createFileBlobs,
+  createFileStore,
+  openLocal,
+  parseName,
+  publicNode,
+  readZip,
+  sniffMime,
+  upload,
+  writeZip
+};

package/dist/mcp.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { D as Drive, C as Ctx } from './drive-DRQ8LiHl.js';
+import 'agentic-identity';
+
+declare function createMcpServer(drive: Drive, ctx: Ctx, exportDir: string): McpServer;
+declare function startMcp(deps: {
+    drive: Drive;
+    ctx: Ctx;
+    exportDir: string;
+}): Promise<void>;
+
+export { createMcpServer, startMcp };

package/dist/mcp.js

@@ -0,0 +1,99 @@
+import {
+  VERSION
+} from "./chunk-4QE7E5UQ.js";
+import {
+  ACTOR_KINDS,
+  DriveError,
+  buildExport,
+  publicNode,
+  upload
+} from "./chunk-QRGKXPLX.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+var conflict = z.enum(["fail", "rename", "replace"]).optional();
+var loc = z.string().describe('A path that starts with "/", or an item id.');
+var ok = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }] });
+function failure(error) {
+  if (!(error instanceof DriveError)) throw error;
+  return { isError: true, content: [{ type: "text", text: JSON.stringify({ error: { code: error.code, message: error.message } }) }] };
+}
+var EXPORT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}\.zip$/;
+function createMcpServer(drive, ctx, exportDir) {
+  const server = new McpServer({ name: "agentic-drive", version: VERSION });
+  const tool = (name, description, shape, run, annotations = {}) => server.registerTool(name, { description, inputSchema: shape, annotations }, (async (args) => {
+    try {
+      return ok(await run(args));
+    } catch (error) {
+      return failure(error);
+    }
+  }));
+  tool("drive_ls", "List a folder.", { path: loc.optional() }, async ({ path }) => (await drive.list(ctx, path ?? "/")).map((n) => publicNode(n)), { readOnlyHint: true });
+  tool("drive_stat", "Show one item with its metadata and who made it.", { path: loc }, async ({ path }) => publicNode(await drive.stat(ctx, path)), { readOnlyHint: true });
+  tool("drive_mkdir", "Make a folder.", { path: z.string(), parents: z.boolean().optional() }, async ({ path, parents }) => publicNode(await drive.mkdir(ctx, path, { parents })));
+  tool(
+    "drive_upload",
+    "Store a file. Give `text` or `contentBase64`.",
+    { path: z.string(), text: z.string().optional(), contentBase64: z.string().optional(), mime: z.string().optional(), parents: z.boolean().optional(), onConflict: conflict },
+    async ({ path, text, contentBase64, mime, parents, onConflict }) => {
+      if (text === void 0 === (contentBase64 === void 0)) throw new DriveError("INVALID_PATH", "give exactly one of text or contentBase64");
+      const bytes = text !== void 0 ? new TextEncoder().encode(text) : new Uint8Array(Buffer.from(contentBase64, "base64"));
+      return publicNode(await upload(drive, ctx, path, (async function* () {
+        yield bytes;
+      })(), { mime, parents, onConflict }));
+    }
+  );
+  tool("drive_download", "Read a file. Text comes back as `text`, other bytes as `contentBase64`.", { path: loc }, async ({ path }) => {
+    const { node, data } = await drive.read(ctx, path);
+    let text = null;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(data);
+    } catch {
+      text = null;
+    }
+    return { node: publicNode(node), ...text !== null ? { text } : { contentBase64: Buffer.from(data).toString("base64") } };
+  }, { readOnlyHint: true });
+  tool("drive_mv", "Move an item into a folder. Pass `name` to rename it.", { src: loc, folder: loc, name: z.string().optional(), onConflict: conflict }, async ({ src, folder, name, onConflict }) => publicNode(await drive.move(ctx, src, folder, { name, onConflict })));
+  tool("drive_rm", "Move an item to the trash. It stays restorable.", { path: loc }, async ({ path }) => publicNode(await drive.trash(ctx, path)));
+  tool("drive_trash", "List items in the trash.", {}, async () => (await drive.listTrash(ctx)).map((n) => publicNode(n)), { readOnlyHint: true });
+  tool("drive_restore", "Put a trashed item back.", { id: z.string(), parentId: z.string().optional(), onConflict: conflict }, async ({ id, parentId, onConflict }) => publicNode(await drive.restore(ctx, id, { parentId, onConflict })));
+  tool("drive_purge", "Delete a trashed item for good.", { id: z.string() }, async ({ id }) => drive.purge(ctx, id), { destructiveHint: true });
+  tool(
+    "drive_search",
+    "Find items by name and metadata.",
+    { name: z.string().optional(), mime: z.string().optional(), kind: z.enum(["folder", "file", "ref"]).optional(), minSize: z.number().optional(), maxSize: z.number().optional(), createdByKind: z.enum(ACTOR_KINDS).optional(), limit: z.number().int().min(1).optional() },
+    async (q) => (await drive.search(ctx, q)).map((r) => publicNode(r.node, r.path)),
+    { readOnlyHint: true }
+  );
+  tool(
+    "drive_export",
+    "Write everything the owner has to a new zip file in the export folder. Give a plain file name that ends in .zip. It never overwrites a file.",
+    { name: z.string() },
+    async ({ name }) => {
+      if (!EXPORT_NAME.test(name)) throw new DriveError("INVALID_PATH", "name must be a plain file name that ends in .zip");
+      const zip = await buildExport(drive, ctx);
+      mkdirSync(exportDir, { recursive: true });
+      const saved = join(exportDir, name);
+      try {
+        writeFileSync(saved, zip, { flag: "wx" });
+      } catch (error) {
+        if (error.code === "EEXIST") throw new DriveError("NAME_TAKEN", `${name} already exists in the export folder`);
+        throw error;
+      }
+      return { saved, size: zip.byteLength };
+    },
+    { destructiveHint: false }
+  );
+  return server;
+}
+async function startMcp(deps) {
+  await createMcpServer(deps.drive, deps.ctx, deps.exportDir).connect(new StdioServerTransport());
+}
+export {
+  createMcpServer,
+  startMcp
+};

package/dist/worker.d.ts

@@ -0,0 +1,36 @@
+import { Hono } from 'hono';
+import { D1Like, R2Like } from 'agentic-identity/cloudflare';
+import { C as Ctx, D as Drive } from './drive-DRQ8LiHl.js';
+import 'agentic-identity';
+
+interface WorkerEnv {
+    DB: D1Like;
+    FILES: R2Like;
+    /**
+     * JSON: `{ "<token>": { "owner": "u1", "actor": "u1", "kind": "human" } }`. A token is at least 32 characters.
+     * Every grant needs an owner, an actor id, and an actor kind. A token with a missing or bad part gets 401.
+     * Without the secret, every request fails with 401.
+     */
+    DRIVE_API_TOKENS?: string;
+    DRIVE_MAX_BYTES?: string;
+    /** The origin of this Worker, such as `https://drive.example.com`. Signed download URLs start with it. */
+    DRIVE_PUBLIC_URL?: string;
+    /** At least 32 bytes. Signs download URLs. Without it, every request gets 503. */
+    DRIVE_URL_SECRET?: string;
+    DRIVE_REGION?: string;
+}
+type App = {
+    Bindings: WorkerEnv;
+    Variables: {
+        drive: Drive;
+        ctx: Ctx;
+    };
+};
+/** The seam for sign-in. A later release swaps this for agentic-identity. */
+declare function authenticate(request: Request, env: WorkerEnv): Ctx | null;
+declare function createApp(): Hono<App>;
+declare const _default: {
+    fetch: (request: Request, env: WorkerEnv, ctx: unknown) => Response | Promise<Response>;
+};
+
+export { type WorkerEnv, authenticate, createApp, _default as default };