agentic-drive 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,44 @@
+import {
+  VERSION
+} from "./chunk-RWMBGIAS.js";
+import {
+  backfillAuthorIds,
+  backfillResources
+} from "./chunk-3LISWG7H.js";
+import {
+  ACTOR_KINDS,
+  DEFAULT_MAX_BYTES,
+  DriveError,
+  ROOT_ID,
+  buildExport,
+  createDrive,
+  createFileBlobs,
+  createFileStore,
+  openLocal,
+  parseName,
+  publicNode,
+  readZip,
+  sniffMime,
+  upload,
+  writeZip
+} from "./chunk-6CWBHSJ7.js";
+export {
+  ACTOR_KINDS,
+  DEFAULT_MAX_BYTES,
+  DriveError,
+  ROOT_ID,
+  VERSION,
+  backfillAuthorIds,
+  backfillResources,
+  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-DKOs1FyM.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,116 @@
+import {
+  VERSION
+} from "./chunk-RWMBGIAS.js";
+import {
+  ACTOR_KINDS,
+  DriveError,
+  buildExport,
+  publicNode,
+  upload
+} from "./chunk-6CWBHSJ7.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, such as "/x" or "<folder id>/x", 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_home",
+    "List files and app documents together, newest change first. Pass `app` (such as docs) to see one app's documents.",
+    { app: z.string().optional(), limit: z.number().int().min(1).optional() },
+    async ({ app, limit }) => {
+      const home = await drive.home(ctx, { app, limit });
+      return { apps: home.apps, files: home.files, items: home.items.map((i) => ({ ...publicNode(i.node, i.path), app: i.app })) };
+    },
+    { readOnlyHint: true }
+  );
+  tool(
+    "drive_register_document",
+    "Put an app document in the drive, as a reference such as docs:<id>. A document that is already there comes back as it is.",
+    { ref: z.string(), name: z.string(), folder: z.string().optional() },
+    async ({ ref, name, folder }) => publicNode(await drive.registerDocument(ctx, { ref, name, folder }))
+  );
+  tool("drive_forget_document", "Move every reference to an app document to the trash.", { ref: z.string() }, async ({ ref }) => drive.forgetDocument(ctx, ref));
+  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/migrate-B79gRPMu.d.ts

@@ -0,0 +1,29 @@
+import { Store } from 'agentic-identity';
+
+type BackfillOptions = {
+    /** Where the last call stopped. Pass the `nextCursor` it returned. */
+    cursor?: string;
+    /** How many pages this call runs. The default runs them all. */
+    maxPages?: number;
+};
+type BackfillResult = {
+    fixed: number;
+    nextCursor?: string;
+};
+/**
+ * Items made before drive kept `createdById` and `updatedById` have no such fields, so an export or an erase
+ * cannot find what a person made in other drives. It sets the two fields from `createdBy` and `updatedBy`. It
+ * changes nothing else. Run it on the store once, after the old Worker has stopped writing. It returns how
+ * many items it fixed, and `nextCursor` while items remain.
+ */
+declare function backfillAuthorIds(store: Store, options?: BackfillOptions): Promise<BackfillResult>;
+/**
+ * Items made before sharing was on have no `resources` doc. With sharing on, their owner gets NOT_FOUND. This
+ * writes the doc of each such item, with the parent a new item gets: its folder, or the drive root. An item
+ * that has a doc is left alone, so a second run changes nothing. A damaged item stops the run, because a doc
+ * with a guessed parent would give access that nobody granted. Run it after the old Worker has stopped
+ * writing, and before the new Worker serves the drive.
+ */
+declare function backfillResources(store: Store, options?: BackfillOptions): Promise<BackfillResult>;
+
+export { type BackfillOptions as B, type BackfillResult as a, backfillAuthorIds as b, backfillResources as c };

package/dist/worker.d.ts

@@ -0,0 +1,36 @@
+import { Hono } from 'hono';
+import { D1Like, R2Like } from 'agentic-identity/cloudflare';
+import { Store } from 'agentic-identity';
+import { C as Ctx, D as Drive } from './drive-DKOs1FyM.js';
+export { B as BackfillOptions, a as BackfillResult, b as backfillAuthorIds, c as backfillResources } from './migrate-B79gRPMu.js';
+
+interface WorkerEnv {
+    DB: D1Like;
+    FILES: R2Like;
+    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;
+        store: Store;
+        ctx: Ctx;
+    };
+};
+/**
+ * The caller behind a bearer token, resolved by the store-backed Auth of agentic-identity: the credential
+ * names a principal, and the whole delegation chain must be live. Only a bearer token counts. A session
+ * cookie is refused, because no check of the request origin stands behind it here. Any problem gives null.
+ */
+declare function authenticate(request: Request, store: Store, now?: () => number): Promise<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 };

package/dist/worker.js

@@ -0,0 +1,307 @@
+import {
+  backfillAuthorIds,
+  backfillResources
+} from "./chunk-3LISWG7H.js";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_URL_SECONDS,
+  DriveError,
+  buildExport,
+  createDrive,
+  publicNode,
+  safeMime,
+  upload
+} from "./chunk-6CWBHSJ7.js";
+
+// src/worker.ts
+import { Hono } from "hono";
+import { D1_SCHEMA, createD1Store, createR2Blobs, verifySignedBlobUrl } from "agentic-identity/cloudflare";
+import { createSharing, createStoreAuth, parseRegion } from "agentic-identity";
+var STATUS = {
+  CROSS_DRIVE: 409,
+  INVALID_SHARE: 400,
+  TOO_MANY_ITEMS: 409,
+  TOO_DEEP: 400,
+  INVALID_EXPIRY: 400,
+  BUSY: 409,
+  BLOB_EXISTS: 500,
+  NOT_FOUND: 404,
+  NAME_TAKEN: 409,
+  INVALID_NAME: 400,
+  INVALID_PATH: 400,
+  INVALID_REF: 400,
+  NOT_A_FOLDER: 400,
+  NOT_A_FILE: 400,
+  MOVE_INTO_SELF: 409,
+  PARENT_GONE: 409,
+  TRASHED: 409,
+  NOT_TRASHED: 409,
+  IS_ROOT: 400,
+  FORBIDDEN: 403,
+  BLOB_MISSING: 500,
+  TOO_LARGE: 413
+};
+var fail = (code, message, status) => new Response(JSON.stringify({ error: { code, message } }), { status, headers: { "content-type": "application/json" } });
+async function authenticate(request, store, now) {
+  if (!/^Bearer [A-Za-z0-9_-]{1,512}$/.test(request.headers.get("authorization") ?? "")) return null;
+  const principal = await createStoreAuth(store, now ? { now } : {}).authenticate(request);
+  return principal ? { owner: principal.chain[0].id, actor: { id: principal.principalId, kind: principal.kind }, principal } : null;
+}
+var schemas = /* @__PURE__ */ new WeakMap();
+function settings(env) {
+  let publicUrl;
+  try {
+    publicUrl = new URL(env.DRIVE_PUBLIC_URL ?? "").origin;
+  } catch {
+    return null;
+  }
+  const urlSecret = env.DRIVE_URL_SECRET;
+  return typeof urlSecret === "string" && new TextEncoder().encode(urlSecret).length >= 32 ? { publicUrl, urlSecret } : null;
+}
+var regionOf = (env) => parseRegion(env.DRIVE_REGION ?? "eu");
+function blobsFor(env, config) {
+  return createR2Blobs(env.FILES, { region: regionOf(env), urlBase: `${config.publicUrl}/api/v1/drive/blob`, urlSecret: config.urlSecret });
+}
+async function driveFor(env, config) {
+  let ready = schemas.get(env.DB);
+  if (!ready) {
+    ready = env.DB.prepare(D1_SCHEMA).run().catch((error) => {
+      schemas.delete(env.DB);
+      throw error;
+    });
+    schemas.set(env.DB, ready);
+  }
+  await ready;
+  const store = createD1Store(env.DB, { region: regionOf(env) });
+  return { store, drive: createDrive({ store, blobs: blobsFor(env, config), sharing: createSharing(store) }) };
+}
+var number = (v, name) => {
+  if (v === void 0) return void 0;
+  const n = Number(v);
+  if (!Number.isFinite(n) || n < 0) throw new DriveError("INVALID_PATH", `${name} needs a number of 0 or more`);
+  return n;
+};
+var claimedType = (header) => header === void 0 || /^(application\/x-www-form-urlencoded|application\/octet-stream|multipart\/form-data)\b/i.test(header) ? void 0 : header;
+function createApp() {
+  const app2 = new Hono();
+  app2.get("/health", (c) => c.json({ ok: true }));
+  const api = new Hono();
+  api.use("*", async (c, next) => {
+    const config = settings(c.env);
+    if (!config) return fail("NOT_CONFIGURED", "set DRIVE_PUBLIC_URL and DRIVE_URL_SECRET (32 bytes or more)", 503);
+    const { drive, store } = await driveFor(c.env, config);
+    const ctx = await authenticate(c.req.raw, store);
+    if (!ctx) return fail("UNAUTHORIZED", "send a valid bearer token", 401);
+    c.set("ctx", ctx);
+    c.set("drive", drive);
+    c.set("store", store);
+    await next();
+  });
+  const q = (c, k) => c.req.query(k);
+  const need = (value, name) => {
+    if (value === void 0) throw new DriveError("INVALID_PATH", `${name} is required`);
+    return value;
+  };
+  const body = async (c) => {
+    let parsed;
+    try {
+      parsed = await c.req.json();
+    } catch {
+      throw new DriveError("INVALID_PATH", "body must be JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new DriveError("INVALID_PATH", "body must be a JSON object");
+    return parsed;
+  };
+  const str = (v, name) => {
+    if (typeof v !== "string") throw new DriveError("INVALID_PATH", `${name} must be a string`);
+    return v;
+  };
+  const opt = (v, name) => v === void 0 ? void 0 : str(v, name);
+  api.get("/items", async (c) => c.json((await c.var.drive.list(c.var.ctx, q(c, "path") ?? "/")).map((n) => publicNode(n))));
+  api.get("/stat", async (c) => c.json(publicNode(await c.var.drive.stat(c.var.ctx, need(q(c, "path"), "path")))));
+  api.post("/folders", async (c) => {
+    const b = await body(c);
+    return c.json(publicNode(await c.var.drive.mkdir(c.var.ctx, str(b.path, "path"), { parents: b.parents === true })), 201);
+  });
+  api.put("/files", async (c) => {
+    const max = number(c.env.DRIVE_MAX_BYTES, "DRIVE_MAX_BYTES") ?? DEFAULT_MAX_BYTES;
+    const declared = Number(c.req.header("content-length"));
+    if (Number.isFinite(declared) && declared > max) return fail("TOO_LARGE", `upload is over the limit of ${max} bytes`, 413);
+    const stream = c.req.raw.body ?? new Blob([]).stream();
+    const node = await upload(c.var.drive, c.var.ctx, need(q(c, "path"), "path"), stream, {
+      maxBytes: max,
+      mime: q(c, "mime") ?? claimedType(c.req.header("content-type")),
+      parents: q(c, "parents") === "true",
+      onConflict: q(c, "onConflict")
+    });
+    return c.json(publicNode(node), 201);
+  });
+  api.get("/files", async (c) => {
+    const { node, data } = await c.var.drive.read(c.var.ctx, need(q(c, "path"), "path"));
+    return new Response(data, {
+      headers: {
+        "content-type": node.mime ?? "application/octet-stream",
+        "content-disposition": `attachment; filename*=UTF-8''${encodeURIComponent(node.name)}`,
+        "x-content-type-options": "nosniff",
+        "x-content-sha256": node.hash ?? ""
+      }
+    });
+  });
+  api.get("/url", async (c) => {
+    const expires = number(q(c, "expires"), "expires") ?? DEFAULT_URL_SECONDS;
+    return c.json({ url: await c.var.drive.downloadUrl(c.var.ctx, need(q(c, "path"), "path"), expires), expiresInSeconds: expires });
+  });
+  api.post("/move", async (c) => {
+    const b = await body(c);
+    return c.json(publicNode(await c.var.drive.move(c.var.ctx, str(b.src, "src"), str(b.folder, "folder"), { name: opt(b.name, "name"), onConflict: opt(b.onConflict, "onConflict") })));
+  });
+  api.post("/trash", async (c) => c.json(publicNode(await c.var.drive.trash(c.var.ctx, str((await body(c)).path, "path")))));
+  api.get("/trash", async (c) => c.json((await c.var.drive.listTrash(c.var.ctx)).map((n) => publicNode(n))));
+  api.post("/restore", async (c) => {
+    const b = await body(c);
+    return c.json(publicNode(await c.var.drive.restore(c.var.ctx, str(b.id, "id"), { parentId: opt(b.parentId, "parentId"), onConflict: opt(b.onConflict, "onConflict") })));
+  });
+  api.post("/purge", async (c) => c.json(await c.var.drive.purge(c.var.ctx, str((await body(c)).id, "id"))));
+  api.get("/search", async (c) => {
+    const query = {
+      name: q(c, "name"),
+      mime: q(c, "mime"),
+      kind: q(c, "kind"),
+      minSize: number(q(c, "minSize"), "minSize"),
+      maxSize: number(q(c, "maxSize"), "maxSize"),
+      createdByKind: q(c, "createdByKind"),
+      app: q(c, "app"),
+      limit: number(q(c, "limit"), "limit")
+    };
+    return c.json((await c.var.drive.search(c.var.ctx, query)).map((r) => publicNode(r.node, r.path)));
+  });
+  api.get("/export", async (c) => new Response(await buildExport(c.var.drive, c.var.ctx), { headers: { "content-type": "application/zip", "content-disposition": 'attachment; filename="drive-export.zip"' } }));
+  api.delete("/account", async (c) => {
+    if (q(c, "confirm") !== "yes") throw new DriveError("INVALID_PATH", "add ?confirm=yes to erase you for good: your drive, and what you shared or held");
+    return c.json(await c.var.drive.erasePerson(c.var.ctx));
+  });
+  api.get("/home", async (c) => {
+    const home = await c.var.drive.home(c.var.ctx, { app: q(c, "app"), limit: number(q(c, "limit"), "limit") });
+    return c.json({ apps: home.apps, files: home.files, items: home.items.map((i) => ({ ...publicNode(i.node, i.path), app: i.app })) });
+  });
+  api.post("/documents", async (c) => {
+    const b = await body(c);
+    return c.json(publicNode(await c.var.drive.registerDocument(c.var.ctx, { ref: str(b.ref, "ref"), name: str(b.name, "name"), folder: opt(b.folder, "folder") })), 201);
+  });
+  api.delete("/documents", async (c) => c.json(await c.var.drive.forgetDocument(c.var.ctx, need(q(c, "ref"), "ref"))));
+  app2.get("/api/v1/drive/blob", async (c) => {
+    const config = settings(c.env);
+    if (!config) return fail("NOT_CONFIGURED", "set DRIVE_PUBLIC_URL and DRIVE_URL_SECRET (32 bytes or more)", 503);
+    const signed = await verifySignedBlobUrl(c.req.url, { secret: config.urlSecret });
+    if (!signed || signed.method !== "GET") return fail("INVALID_LINK", "this link is not valid, or it has expired", 403);
+    const blob = await blobsFor(c.env, config).get(signed.key);
+    if (!blob) return fail("NOT_FOUND", "the bytes are gone", 404);
+    return new Response(blob.data, {
+      headers: {
+        "content-type": safeMime(signed.responseContentType ?? blob.contentType),
+        "content-disposition": signed.responseContentDisposition ?? "attachment",
+        "x-content-type-options": "nosniff",
+        "cache-control": "private, no-store"
+      }
+    });
+  });
+  const roleOf = (v) => v;
+  const lifetime = (v, name) => {
+    if (v === void 0) return void 0;
+    if (typeof v !== "number") throw new DriveError("INVALID_SHARE", `${name} must be a number of milliseconds`);
+    return v;
+  };
+  api.get("/shares", async (c) => c.json(await c.var.drive.shares(c.var.ctx, need(q(c, "path"), "path"))));
+  api.post("/shares", async (c) => {
+    const b = await body(c);
+    await c.var.drive.shareWith(c.var.ctx, str(b.path, "path"), str(b.subjectId, "subjectId"), roleOf(b.role));
+    return c.json({ ok: true });
+  });
+  api.delete("/shares", async (c) => {
+    await c.var.drive.unshare(c.var.ctx, need(q(c, "path"), "path"), need(q(c, "subjectId"), "subjectId"));
+    return c.json({ ok: true });
+  });
+  api.post("/invites", async (c) => {
+    const b = await body(c);
+    const expiresInMs = lifetime(b.expiresInMs, "expiresInMs");
+    const invite = await c.var.drive.invite(c.var.ctx, str(b.path, "path"), {
+      role: roleOf(b.role),
+      ...b.email === void 0 ? {} : { email: str(b.email, "email") },
+      ...b.handle === void 0 ? {} : { handle: str(b.handle, "handle") },
+      ...expiresInMs === void 0 ? {} : { expiresInMs }
+    });
+    return c.json(invite, 201);
+  });
+  api.post("/invites/accept", async (c) => {
+    const id = str((await body(c)).id, "id");
+    const user = await c.var.store.get("users", c.var.ctx.actor.id);
+    const agent = await c.var.store.get("principals", c.var.ctx.actor.id);
+    await c.var.drive.acceptInvite(c.var.ctx, id, {
+      ...user?.emailVerified === true && typeof user.email === "string" ? { email: user.email } : {},
+      ...typeof agent?.handle === "string" ? { handle: agent.handle } : {}
+    });
+    return c.json({ ok: true });
+  });
+  api.post("/links", async (c) => {
+    const b = await body(c);
+    const expiresInMs = lifetime(b.expiresInMs, "expiresInMs");
+    const link = await c.var.drive.createLink(c.var.ctx, str(b.path, "path"), {
+      role: roleOf(b.role),
+      signedInOnly: b.signedInOnly === true,
+      ...expiresInMs === void 0 ? {} : { expiresAt: Date.now() + expiresInMs }
+    });
+    return c.json(link, 201);
+  });
+  api.delete("/links", async (c) => {
+    await c.var.drive.revokeLink(c.var.ctx, need(q(c, "id"), "id"));
+    return c.json({ ok: true });
+  });
+  const shared = new Hono();
+  const visit = async (c) => {
+    const config = settings(c.env);
+    if (!config) return { stop: fail("NOT_CONFIGURED", "set DRIVE_PUBLIC_URL and DRIVE_URL_SECRET (32 bytes or more)", 503) };
+    const { drive, store } = await driveFor(c.env, config);
+    const ctx = await authenticate(c.req.raw, store);
+    if (!ctx && c.req.header("authorization")) return { stop: fail("UNAUTHORIZED", "send a valid bearer token", 401) };
+    return { drive, principal: ctx?.principal ?? null, token: c.req.header("x-link-token") };
+  };
+  shared.get("/:id", async (c) => {
+    const v = await visit(c);
+    return "stop" in v ? v.stop : c.json(publicNode(await v.drive.openShared(v.principal, c.req.param("id"), v.token)));
+  });
+  shared.get("/:id/items", async (c) => {
+    const v = await visit(c);
+    return "stop" in v ? v.stop : c.json((await v.drive.listShared(v.principal, c.req.param("id"), v.token)).map((n) => publicNode(n)));
+  });
+  shared.get("/:id/content", async (c) => {
+    const v = await visit(c);
+    if ("stop" in v) return v.stop;
+    const { node, data } = await v.drive.readShared(v.principal, c.req.param("id"), v.token);
+    return new Response(data, {
+      headers: {
+        "content-type": safeMime(node.mime),
+        "content-disposition": `attachment; filename*=UTF-8''${encodeURIComponent(node.name)}`,
+        "x-content-type-options": "nosniff",
+        "cache-control": "private, no-store"
+      }
+    });
+  });
+  app2.route("/api/v1/drive/shared", shared);
+  app2.route("/api/v1/drive", api);
+  app2.notFound(() => fail("NOT_FOUND", "no such route", 404));
+  app2.onError((error) => {
+    if (error instanceof DriveError) return new Response(JSON.stringify({ error: { code: error.code, message: error.message } }), { status: STATUS[error.code], headers: { "content-type": "application/json" } });
+    console.error("internal error", error instanceof Error ? error.name : "unknown");
+    return new Response(JSON.stringify({ error: { code: "INTERNAL", message: "the server could not finish the request" } }), { status: 500, headers: { "content-type": "application/json" } });
+  });
+  return app2;
+}
+var app = createApp();
+var worker_default = { fetch: (request, env, ctx) => app.fetch(request, env, ctx) };
+export {
+  authenticate,
+  backfillAuthorIds,
+  backfillResources,
+  createApp,
+  worker_default as default
+};

package/llms.txt

@@ -0,0 +1,14 @@
+# agentic-drive
+
+Store, sort, and share files and folders.
+
+Keywords: drive,files,folders,storage,upload,sharing,agents,mcp,cli,r2.
+
+- SDK: import { createDrive } from "agentic-drive".
+- CLI: agentic-drive ls /.
+- MCP: run agentic-drive mcp, then call drive_ls.
+
+## Docs
+
+- README: https://github.com/pooriaarab/agentic-drive
+- License: MIT

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "agentic-drive",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Store, sort, and share files and folders.",
+  "keywords": [
+    "drive",
+    "files",
+    "folders",
+    "storage",
+    "upload",
+    "sharing",
+    "agents",
+    "mcp",
+    "cli",
+    "r2"
+  ],
+  "license": "MIT",
+  "author": "Pooria Arab",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pooriaarab/agentic-drive.git"
+  },
+  "type": "module",
+  "private": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "llms.txt",
+    "SKILL.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "mcpName": "io.github.pooriaarab/agentic-drive",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist",
+    "prepack": "npm run build --silent >&2",
+    "ci:local": "npm run build && npm run typecheck && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "agentic-identity": "^0.3.0",
+    "hono": "^4.13.14",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "miniflare": "^4.20260730.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0",
+    "wrangler": "^4.155.0"
+  },
+  "bin": {
+    "agentic-drive": "./dist/cli.js"
+  }
+}