agentic-drive 0.0.0-stage → 0.2.0

package/dist/chunk-RWMBGIAS.js

@@ -0,0 +1,7 @@
+// src/version.ts
+import { createRequire } from "module";
+var VERSION = true ? "0.2.0" : readPackageVersion();
+
+export {
+  VERSION
+};

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,235 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-RWMBGIAS.js";
+import {
+  DriveError,
+  buildExport,
+  openLocal,
+  publicNode,
+  upload
+} from "./chunk-6CWBHSJ7.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.
+  home [--app <name>]          List files and app documents, newest change first.
+  register <ref> <name>        Put an app document in the drive. Flag: --parent <folder>
+  forget <ref>                 Move the references to an app document to the trash.
+  delete-all --yes             Erase you for good: your drive, and what you shared or held.
+  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" },
+  app: { 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 "home": {
+        const home = await drive.home(ctx, { app: values.app, limit: num(values.limit, "limit") });
+        print({ apps: home.apps, files: home.files, items: home.items.map((i) => ({ ...publicNode(i.node, i.path), app: i.app })) });
+        break;
+      }
+      case "register":
+        need(2, "register <ref> <name>");
+        print(publicNode(await drive.registerDocument(ctx, { ref: args[0], name: args[1], folder: values.parent })));
+        break;
+      case "forget":
+        need(1, "forget <ref>");
+        print(await drive.forgetDocument(ctx, args[0]));
+        break;
+      case "delete-all":
+        if (!values.yes) throw new UsageError("delete-all erases you for good. Add --yes to confirm.");
+        print(await drive.erasePerson(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-DKOs1FyM.d.ts

@@ -0,0 +1,325 @@
+import * as agentic_identity from 'agentic-identity';
+import { PrincipalContext, Store, Blobs, createSharing, Role } 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, and the root of the caller's chain. `actor` is who acts for them.
+ * `principal` is the resolved caller. Drive needs it to check roles when `sharing` is set.
+ */
+type Ctx = {
+    owner: string;
+    actor: Actor;
+    principal?: PrincipalContext;
+};
+/** `delete` is for the owner only: purge and erase. Trash needs `write`. */
+type Action = "read" | "write" | "delete";
+type Sharing = ReturnType<typeof createSharing>;
+/** The seam for access. With `sharing`, the default is a role check through agentic-identity. */
+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;
+    /** The ids of `createdBy` and `updatedBy`, at the top level so a store can find what a person made. */
+    createdById: string;
+    updatedById: string;
+    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" | "CROSS_DRIVE" | "INVALID_SHARE" | "TOO_MANY_ITEMS";
+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;
+    /** Only references to documents of this app, such as `docs`. */
+    app?: string;
+    /** 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;
+    /** Turns on roles. Folders and files register as resources, and `can()` decides every request. Make it on the same `store`. */
+    sharing?: Sharing;
+    /** 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;
+    }>;
+    /**
+     * What the home view shows: every file and every reference to an app's document, newest change first.
+     * `apps` counts references per app, and `files` counts plain files, before `app` and `limit` apply.
+     */
+    home(ctx: Ctx, q?: {
+        app?: string;
+        limit?: number;
+    }): Promise<{
+        items: {
+            node: Node;
+            path: string;
+            app: string | null;
+        }[];
+        apps: Record<string, number>;
+        files: number;
+    }>;
+    /**
+     * An app puts one of its documents in this drive, as a reference such as `docs:<id>`. A document that is
+     * already in the drive comes back as it is, so an app can register again. The reference sits in `folder`
+     * (a path or a folder id, "/" by default) under `name`, and gets a free name when that one is taken.
+     */
+    registerDocument(ctx: Ctx, input: {
+        ref: string;
+        name: string;
+        folder?: string;
+    }): Promise<Node>;
+    /** An app deleted a document. Its references in this drive go to the trash. Returns how many. */
+    forgetDocument(ctx: Ctx, ref: string): Promise<{
+        trashed: number;
+    }>;
+    /**
+     * What drive holds about the person behind a call, besides their own drive (`exportData` has that). It is
+     * only for the person in person: an agent gets `partial: true` and nothing else. It holds the ids of the
+     * items they or their agents made or changed in other drives (no names, and nothing of the people who own
+     * them), the shares they hold, the invites they sent, and the audit entries of what they and their agents
+     * did. Invitee emails and link tokens are not in it.
+     */
+    exportPerson(ctx: Ctx): Promise<{
+        subject: {
+            id: string;
+            kind: "human" | "agent_of_human" | "agent_of_agent" | "agent" | "user_token" | null;
+        };
+        partial: boolean;
+        authored: {
+            id: string;
+            kind: "folder" | "file" | "ref";
+            created: boolean;
+            updated: boolean;
+            createdAt: number | null;
+            updatedAt: number | null;
+            by: any[];
+        }[];
+        agents: {
+            id: string;
+            items: {
+                id: string;
+                kind: "folder" | "file" | "ref";
+                name: string;
+                size: number;
+                mime: string | null;
+                createdAt: number;
+                updatedAt: number;
+                trashed: boolean;
+            }[];
+        }[];
+        shares: {
+            held: {
+                subjectId: unknown;
+                resourceId: unknown;
+                role: unknown;
+            }[];
+            invitesCreated: {
+                id: unknown;
+                resourceId: unknown;
+                role: unknown;
+                expiresAt: unknown;
+                accepted: boolean;
+            }[];
+        };
+        audit: {
+            at: unknown;
+            action: unknown;
+            resourceId: unknown;
+            outcome: unknown;
+            principalId: unknown;
+            principalKind: unknown;
+            machineMade: unknown;
+        }[];
+    }>;
+    /**
+     * Erases a person for good. Only the person in person may. Their drive and its shares go. So do the shares
+     * they hold and the invites they or their agents sent, on drive items only: the grants of other apps stay for
+     * those apps and for identity. What they or their agents made in other drives stays, because it belongs to
+     * those drives: the id becomes "erased", and the kind stays, so machine-made work keeps its label. The audit
+     * trail stays: it holds ids and kinds only. A failed call can run again.
+     */
+    erasePerson(ctx: Ctx): Promise<{
+        removed: number;
+        grants: number;
+        invites: number;
+        anonymized: number;
+    }>;
+    /** Gives a person or an agent a role on an item and everything under it. Only an owner may. */
+    shareWith(ctx: Ctx, loc: string, subjectId: string, role: Role): Promise<void>;
+    unshare(ctx: Ctx, loc: string, subjectId: string): Promise<void>;
+    /** Invite by `email` (a person) or `handle` (an agent). The invite lasts `expiresInMs`, if given. It sends no message. */
+    invite(ctx: Ctx, loc: string, input: {
+        role: Role;
+        email?: string;
+        handle?: string;
+        expiresInMs?: number;
+    }): Promise<{
+        id: string;
+    }>;
+    /** `identity` is the verified email of a person, or the handle of an agent. */
+    acceptInvite(ctx: Ctx, inviteId: string, identity: {
+        email?: string;
+        handle?: string;
+    }): Promise<void>;
+    /** The token comes back once. Only its hash is stored. */
+    createLink(ctx: Ctx, loc: string, input: {
+        role: Role;
+        expiresAt?: number;
+        signedInOnly?: boolean;
+    }): Promise<{
+        id: string;
+        token: string;
+    }>;
+    revokeLink(ctx: Ctx, linkId: string): Promise<void>;
+    /** Who can reach an item, and by which links and invites. Only an owner may look. Link tokens are never shown. */
+    shares(ctx: Ctx, loc: string): Promise<{
+        grants: {
+            subjectId: agentic_identity.Json;
+            role: agentic_identity.Json;
+        }[];
+        links: {
+            id: agentic_identity.Json;
+            role: agentic_identity.Json;
+            signedInOnly: boolean;
+            expiresAt: string | number | boolean | agentic_identity.Json[] | {
+                [key: string]: agentic_identity.Json;
+            } | null;
+            revoked: boolean;
+        }[];
+        invites: {
+            id: agentic_identity.Json;
+            role: agentic_identity.Json;
+            email: string | number | boolean | agentic_identity.Json[] | {
+                [key: string]: agentic_identity.Json;
+            } | null;
+            handle: string | number | boolean | agentic_identity.Json[] | {
+                [key: string]: agentic_identity.Json;
+            } | null;
+            expiresAt: string | number | boolean | agentic_identity.Json[] | {
+                [key: string]: agentic_identity.Json;
+            } | null;
+            accepted: boolean;
+        }[];
+    }>;
+    openShared: (principal: PrincipalContext | null, id: string, linkToken?: string) => Promise<Node>;
+    /** Live children of a folder that a link visitor or a signed-in person may read, sorted by name. */
+    listShared(principal: PrincipalContext | null, id: string, linkToken?: string): Promise<Node[]>;
+    readShared(principal: PrincipalContext | null, id: string, linkToken?: string): Promise<{
+        node: Node;
+        data: Uint8Array;
+        contentType?: string;
+    }>;
+};
+
+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,108 @@
+import { O as OnConflict, D as Drive, C as Ctx, N as Node, A as ActorKind, a as Actor } from './drive-DKOs1FyM.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-DKOs1FyM.js';
+import { AdapterOptions, Blobs, Store } from 'agentic-identity';
+export { B as BackfillOptions, a as BackfillResult, b as backfillAuthorIds, c as backfillResources } from './migrate-B79gRPMu.js';
+
+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` names the person (id and kind), lists each item with its
+ * metadata and, for a file, the entry that holds its bytes, and adds what the person made in other drives, the
+ * shares they hold, the invites they sent, and the audit entries of what they did. Only the person in person gets
+ * those parts, and the items of their agents that have an identity of their own (no bytes). For an agent the
+ * manifest says `partial: true`. 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;
+    createdById: string;
+    updatedById: string;
+    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;
+    createdById: string;
+    updatedById: string;
+    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 };