agentic-drive 0.0.0-stage → 0.1.0

package/dist/worker.js

@@ -0,0 +1,230 @@
+import {
+  ACTOR_KINDS,
+  DEFAULT_MAX_BYTES,
+  DEFAULT_URL_SECONDS,
+  DriveError,
+  buildExport,
+  createDrive,
+  publicNode,
+  safeMime,
+  upload
+} from "./chunk-QRGKXPLX.js";
+
+// src/worker.ts
+import { Hono } from "hono";
+import { parseRegion } from "agentic-identity";
+import { D1_SCHEMA, createD1Store, createR2Blobs, verifySignedBlobUrl } from "agentic-identity/cloudflare";
+var MIN_TOKEN_LENGTH = 32;
+var STATUS = {
+  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" } });
+function sameText(a, b) {
+  const x = new TextEncoder().encode(a);
+  const y = new TextEncoder().encode(b);
+  let diff = x.length ^ y.length;
+  for (let i = 0; i < Math.max(x.length, y.length); i++) diff |= (x[i] ?? 0) ^ (y[i] ?? 0);
+  return diff === 0;
+}
+var isText = (v) => typeof v === "string" && v !== "";
+function principalOf(grant) {
+  if (typeof grant !== "object" || grant === null) return null;
+  const { owner, actor, kind } = grant;
+  if (!isText(owner) || !isText(actor) || !ACTOR_KINDS.includes(kind)) return null;
+  return { owner, actor: { id: actor, kind } };
+}
+function authenticate(request, env) {
+  const token = /^Bearer (.+)$/.exec(request.headers.get("authorization") ?? "")?.[1];
+  if (!token || !env.DRIVE_API_TOKENS) return null;
+  let grants;
+  try {
+    grants = JSON.parse(env.DRIVE_API_TOKENS);
+  } catch {
+    return null;
+  }
+  if (typeof grants !== "object" || grants === null) return null;
+  let found;
+  for (const [candidate, grant] of Object.entries(grants)) {
+    if (sameText(candidate, token) && candidate.length >= MIN_TOKEN_LENGTH) found = grant;
+  }
+  return principalOf(found);
+}
+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;
+  return createDrive({ store: createD1Store(env.DB, { region: regionOf(env) }), blobs: blobsFor(env, config) });
+}
+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 ctx = authenticate(c.req.raw, c.env);
+    if (!ctx) return fail("UNAUTHORIZED", "send a valid bearer token", 401);
+    c.set("ctx", ctx);
+    c.set("drive", await driveFor(c.env, config));
+    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"),
+      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 delete everything you own for good");
+    return c.json(await c.var.drive.deleteAll(c.var.ctx));
+  });
+  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"
+      }
+    });
+  });
+  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,
+  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,75 @@
 {
   "name": "agentic-drive",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.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",
+    "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",
+    "ci:local": "npm run build && npm run typecheck && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "agentic-identity": "^0.2.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"
+  }
+}