agentic-drive 0.9.0 → 0.10.0

package/dist/chunk-HJXRMOUY.js

@@ -0,0 +1,204 @@
+import {
+  DriveError,
+  safeMime
+} from "./chunk-DB4F5EWD.js";
+
+// src/upload.ts
+var DEFAULT_MAX_BYTES = 25 * 1024 * 1024;
+var SIGNATURES = [
+  [[137, 80, 78, 71, 13, 10, 26, 10], "image/png"],
+  [[255, 216, 255], "image/jpeg"],
+  [[71, 73, 70, 56], "image/gif"],
+  [[37, 80, 68, 70, 45], "application/pdf"],
+  [[80, 75, 3, 4], "application/zip"],
+  [[31, 139], "application/gzip"]
+];
+function sniffMime(head) {
+  const hit = SIGNATURES.find(([sig]) => sig.every((byte, i) => head[i] === byte));
+  if (hit) return hit[1];
+  const isWebp = [..."RIFF"].every((c, i) => head[i] === c.charCodeAt(0)) && [..."WEBP"].every((c, i) => head[8 + i] === c.charCodeAt(0));
+  return isWebp ? "image/webp" : null;
+}
+function looksLikeText(head) {
+  if (head.includes(0)) return false;
+  for (let cut = 0; cut < 4 && cut <= head.length; cut++) {
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(head.subarray(0, head.length - cut));
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+async function* iterate(source) {
+  if (Symbol.asyncIterator in source) {
+    yield* source;
+    return;
+  }
+  const reader = source.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function upload(drive, ctx, path, source, opts = {}) {
+  const max = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  const parts = [];
+  let size = 0;
+  for await (const chunk of iterate(source)) {
+    size += chunk.byteLength;
+    if (size > max) throw new DriveError("TOO_LARGE", `upload is over the limit of ${max} bytes`);
+    parts.push(chunk);
+  }
+  const data = new Uint8Array(size);
+  for (let at = 0, i = 0; i < parts.length; at += parts[i].byteLength, i++) data.set(parts[i], at);
+  const head = data.subarray(0, 512);
+  const mime = sniffMime(head) ?? (opts.mime !== void 0 ? safeMime(opts.mime) : looksLikeText(head) ? "text/plain" : "application/octet-stream");
+  return drive.putFile(ctx, path, data, { mime, parents: opts.parents, onConflict: opts.onConflict });
+}
+
+// src/zip.ts
+var CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+  return c >>> 0;
+});
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function safeEntryName(name) {
+  if (name === "" || /[\\\u0000]/.test(name) || name.startsWith("/") || /^[a-zA-Z]:/.test(name)) return false;
+  return name.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function writeZip(entries, at) {
+  for (const { name } of entries) if (!safeEntryName(name)) throw new Error(`zip: unsafe entry name ${JSON.stringify(name)}`);
+  const d = new Date(at);
+  const time = d.getUTCHours() << 11 | d.getUTCMinutes() << 5 | d.getUTCSeconds() >> 1;
+  const date = Math.max(d.getUTCFullYear(), 1980) - 1980 << 9 | d.getUTCMonth() + 1 << 5 | d.getUTCDate();
+  const parts = [];
+  const central = [];
+  let offset = 0;
+  const u16 = (v, o, n) => v.setUint16(o, n, true);
+  const u32 = (v, o, n) => v.setUint32(o, n, true);
+  for (const entry of entries) {
+    const name = new TextEncoder().encode(entry.name);
+    const crc = crc32(entry.data);
+    if (entry.data.byteLength >= 4294967295 || offset >= 4294967295 || entries.length >= 65535) throw new Error("zip: export is too large for a plain zip");
+    const local = new DataView(new ArrayBuffer(30));
+    u32(local, 0, 67324752);
+    u16(local, 4, 20);
+    u16(local, 6, 2048);
+    u16(local, 8, 0);
+    u16(local, 10, time);
+    u16(local, 12, date);
+    u32(local, 14, crc);
+    u32(local, 18, entry.data.byteLength);
+    u32(local, 22, entry.data.byteLength);
+    u16(local, 26, name.length);
+    u16(local, 28, 0);
+    const head = new DataView(new ArrayBuffer(46));
+    u32(head, 0, 33639248);
+    u16(head, 4, 20);
+    u16(head, 6, 20);
+    u16(head, 8, 2048);
+    u16(head, 10, 0);
+    u16(head, 12, time);
+    u16(head, 14, date);
+    u32(head, 16, crc);
+    u32(head, 20, entry.data.byteLength);
+    u32(head, 24, entry.data.byteLength);
+    u16(head, 28, name.length);
+    u32(head, 42, offset);
+    parts.push(new Uint8Array(local.buffer), name, entry.data);
+    central.push(new Uint8Array(head.buffer), name);
+    offset += 30 + name.length + entry.data.byteLength;
+  }
+  const size = central.reduce((n, p) => n + p.byteLength, 0);
+  const end = new DataView(new ArrayBuffer(22));
+  u32(end, 0, 101010256);
+  u16(end, 8, entries.length);
+  u16(end, 10, entries.length);
+  u32(end, 12, size);
+  u32(end, 16, offset);
+  const all = [...parts, ...central, new Uint8Array(end.buffer)];
+  const out = new Uint8Array(all.reduce((n, p) => n + p.byteLength, 0));
+  let at2 = 0;
+  for (const p of all) {
+    out.set(p, at2);
+    at2 += p.byteLength;
+  }
+  return out;
+}
+function readZip(bytes) {
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let end = bytes.byteLength - 22;
+  while (end >= 0 && v.getUint32(end, true) !== 101010256) end--;
+  if (end < 0) throw new Error("zip: no end signature");
+  const count = v.getUint16(end + 10, true);
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0, at = v.getUint32(end + 16, true); i < count; i++) {
+    if (v.getUint32(at, true) !== 33639248) throw new Error("zip: bad central signature");
+    if (v.getUint16(at + 10, true) !== 0) throw new Error("zip: compressed entries are not supported");
+    const crc = v.getUint32(at + 16, true);
+    const size = v.getUint32(at + 24, true);
+    const nameLen = v.getUint16(at + 28, true);
+    const local = v.getUint32(at + 42, true);
+    const name = new TextDecoder().decode(bytes.subarray(at + 46, at + 46 + nameLen));
+    if (v.getUint32(local, true) !== 67324752) throw new Error("zip: bad local signature");
+    const start = local + 30 + v.getUint16(local + 26, true) + v.getUint16(local + 28, true);
+    const data = bytes.slice(start, start + size);
+    if (crc32(data) !== crc) throw new Error(`zip: crc mismatch in ${name}`);
+    out.set(name, data);
+    at += 46 + nameLen + v.getUint16(at + 30, true) + v.getUint16(at + 32, true);
+  }
+  return out;
+}
+
+// src/export.ts
+async function buildExport(drive, ctx, now = Date.now) {
+  const entries = [];
+  const items = (await drive.exportData(ctx)).map(({ node, path, data, missing }) => {
+    const file = data ? `files/${node.id}` : null;
+    if (data && file) entries.push({ name: file, data });
+    return {
+      id: node.id,
+      owner: node.owner,
+      path,
+      parentId: node.parentId,
+      kind: node.kind,
+      name: node.name,
+      size: node.size,
+      mime: node.mime,
+      hash: node.hash,
+      ref: node.ref,
+      createdAt: node.createdAt,
+      updatedAt: node.updatedAt,
+      createdBy: node.createdBy,
+      updatedBy: node.updatedBy,
+      trashed: node.trashed,
+      trashedAt: node.trashedAt,
+      file,
+      ...missing ? { missing: true } : {}
+    };
+  });
+  const person = await drive.exportPerson(ctx);
+  const manifest = { format: "agentic-drive-export", version: 2, exportedAt: now(), owner: ctx.owner, subject: person.subject, partial: person.partial, items, authored: person.authored, agents: person.agents, shares: person.shares, audit: person.audit, activity: person.activity };
+  return writeZip([{ name: "manifest.json", data: new TextEncoder().encode(JSON.stringify(manifest, null, 2)) }, ...entries], now());
+}
+
+export {
+  DEFAULT_MAX_BYTES,
+  sniffMime,
+  upload,
+  writeZip,
+  readZip,
+  buildExport
+};

package/dist/{chunk-IMWV5QEH.js → chunk-NHHBNW64.js}

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

package/dist/{chunk-LELTSSZF.js → chunk-SEHT5Q5L.js}

@@ -48,6 +48,8 @@ var ROLES = ["viewer", "commenter", "editor", "owner"];
 var oneOf = (list) => (v) => typeof v === "string" && list.includes(v);
 var actor = (v) => record(v) && text(v.id) && oneOf(Object.keys(ACTOR_KINDS))(v.kind);
 var isItem = (v) => record(v) && text(v.id) && text(v.owner) && text(v.parentId) && text(v.name) && (v.kind === "folder" || v.kind === "file" || v.kind === "ref") && num(v.size) && orNull(text)(v.mime) && orNull(text)(v.hash) && orNull(text)(v.ref) && num(v.createdAt) && num(v.updatedAt) && actor(v.createdBy) && actor(v.updatedBy) && text(v.createdById) && text(v.updatedById) && typeof v.trashed === "boolean" && orNull(num)(v.trashedAt) && typeof v.machineMade === "boolean";
+var ACTIVITY_ACTIONS = ["create", "rename", "move", "update", "share", "unshare", "delete", "restore"];
+var isActivity = (v) => record(v) && text(v.id) && text(v.itemId) && oneOf(ACTIVITY_ACTIONS)(v.action) && record(v.actor) && text(v.actor.id) && oneOf(["human", "agent"])(v.actor.kind) && oneOf(Object.keys(ACTOR_KINDS))(v.principalKind) && num(v.at) && (v.detail === void 0 || record(v.detail));
 var isPathItem = (v) => isItem(v) && typeof v.path === "string";
 var listOf = (check) => (v) => Array.isArray(v) && v.every(check);
 var shape = (test) => (v) => record(v) && test(v);
@@ -186,6 +188,8 @@ function createClient(options) {
   return {
     /** The live items of a folder. */
     list: (path = "/", o = {}) => json("GET", `/items${query({ path })}`, o, listOf(isItem)),
+    /** The changes made to an item, newest first. `idOrPath` is an id or a path. */
+    listActivity: (idOrPath, opts = {}) => json("GET", `/items/${encodeURIComponent(idOrPath)}/activity${query({ limit: opts.limit })}`, opts, listOf(isActivity)),
     stat: (path, o = {}) => json("GET", `/stat${query({ path })}`, o, isItem),
     mkdir: (path, opts = {}, o = {}) => json("POST", "/folders", { json: { path, parents: opts.parents === true }, ...o }, isItem),
     /** Writes a file. A `ReadableStream` body streams in runtimes that allow it. */

package/dist/cli.js

@@ -4,13 +4,16 @@ import {
 } from "./chunk-AB2RTTHJ.js";
 import {
   VERSION
-} from "./chunk-IMWV5QEH.js";
+} from "./chunk-NHHBNW64.js";
+import {
+  buildExport,
+  upload
+} from "./chunk-HJXRMOUY.js";
 import {
   AuthError,
   DriveError,
   NO_TOKEN,
   addPrincipal,
-  buildExport,
   ensureSharing,
   inviteIdentity,
   issueKey,
@@ -18,9 +21,8 @@ import {
   publicNode,
   resolveToken,
   revokeKey,
-  revokePrincipal,
-  upload
-} from "./chunk-R2DUVOJT.js";
+  revokePrincipal
+} from "./chunk-DB4F5EWD.js";
 
 // src/cli.ts
 import { createReadStream, realpathSync, writeFileSync } from "fs";
@@ -36,6 +38,7 @@ Usage: agentic-drive <command> [flags]
 Commands:
   ls [path]                    List a folder.
   stat <path|id>               Show one item.
+  activity <path|id> [--limit] List the changes to an item: who (person or AI agent), what, when.
   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.
@@ -78,7 +81,7 @@ Flags:
 
 Exit codes: 0 done, 1 error, 2 bad usage, 3 no principal or an invalid key.
 `;
-var COMMANDS = ["ls", "stat", "mkdir", "upload", "download", "mv", "rm", "trash", "restore", "purge", "search", "export", "home", "register", "find-ref", "claim-ref", "forget", "shares", "share", "unshare", "invite", "accept-invite", "link-create", "link-revoke", "delete-all", "mcp", "principal", "key"];
+var COMMANDS = ["ls", "stat", "activity", "mkdir", "upload", "download", "mv", "rm", "trash", "restore", "purge", "search", "export", "home", "register", "find-ref", "claim-ref", "forget", "shares", "share", "unshare", "invite", "accept-invite", "link-create", "link-revoke", "delete-all", "mcp", "principal", "key"];
 var UsageError = class extends Error {
 };
 var options = {
@@ -166,6 +169,14 @@ async function runCli(argv, io) {
         need(1, "stat <path|id>");
         print(publicNode(await drive.stat(ctx, args[0])));
         break;
+      case "activity":
+        need(1, "activity <path|id> [--limit n]");
+        {
+          const limit = num(values.limit, "limit");
+          if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1)) throw new UsageError("--limit needs a whole number of 1 or more");
+          print(await drive.listActivity(ctx, args[0], { limit }));
+        }
+        break;
       case "mkdir":
         need(1, "mkdir <path> [-p]");
         print(publicNode(await drive.mkdir(ctx, args[0], { parents: values.parents })));

package/dist/client.d.ts

@@ -1,4 +1,5 @@
-import { E as ErrorCode, N as Node, S as SearchQuery } from './drive-Dxy0gL0_.js';
+import { E as ErrorCode, N as Node, A as ActivityEntry, S as SearchQuery } from './drive-BhMTeQ-s.js';
+export { a as ActivityAction } from './drive-BhMTeQ-s.js';
 import 'agentic-identity';
 
 type Role = "viewer" | "commenter" | "editor" | "owner";
@@ -49,6 +50,10 @@ interface Downloaded {
 declare function createClient(options: ClientOptions): {
     /** The live items of a folder. */
     list: (path?: string, o?: CallOptions) => Promise<Item[]>;
+    /** The changes made to an item, newest first. `idOrPath` is an id or a path. */
+    listActivity: (idOrPath: string, opts?: {
+        limit?: number;
+    } & CallOptions) => Promise<ActivityEntry[]>;
     stat: (path: string, o?: CallOptions) => Promise<Item>;
     mkdir: (path: string, opts?: {
         parents?: boolean;
@@ -186,4 +191,4 @@ declare function createClient(options: ClientOptions): {
 };
 type DriveClient = ReturnType<typeof createClient>;
 
-export { type ApiErrorCode, type CallOptions, type ClientErrorCode, type ClientOptions, type Downloaded, DriveApiError, type DriveClient, ErrorCode, type Item, Node, type OnConflict, type PathItem, type Role, type Subject, type SubjectKind, type UploadBody, createClient };
+export { ActivityEntry, type ApiErrorCode, type CallOptions, type ClientErrorCode, type ClientOptions, type Downloaded, DriveApiError, type DriveClient, ErrorCode, type Item, Node, type OnConflict, type PathItem, type Role, type Subject, type SubjectKind, type UploadBody, createClient };

package/dist/client.js

@@ -1,7 +1,7 @@
 import {
   DriveApiError,
   createClient
-} from "./chunk-LELTSSZF.js";
+} from "./chunk-SEHT5Q5L.js";
 export {
   DriveApiError,
   createClient

package/dist/{drive-Dxy0gL0_.d.ts → drive-BhMTeQ-s.d.ts}

@@ -1,5 +1,5 @@
 import * as agentic_identity from 'agentic-identity';
-import { PrincipalKind, PrincipalContext, Store, Blobs, createSharing, Subject, Role, SubjectKind } from 'agentic-identity';
+import { PrincipalKind, Store, Blobs, PrincipalContext, createSharing, Subject, Role, SubjectKind } from 'agentic-identity';
 
 declare const ROOT_ID = "root";
 declare const ACTOR_KINDS: readonly ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
@@ -8,6 +8,22 @@ type Actor = {
     id: string;
     kind: ActorKind;
 };
+type ActivityAction = "create" | "rename" | "move" | "update" | "share" | "unshare" | "delete" | "restore";
+/** One change to an item. `actor.kind` is `agent` for every principal that is not a person, so a reader can label machine-made changes. */
+type ActivityEntry = {
+    id: string;
+    itemId: string;
+    action: ActivityAction;
+    actor: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    /** The kind of principal behind the change, such as `agent_of_human`. */
+    principalKind: ActorKind;
+    at: number;
+    /** What changed, such as `{ from, to }` for a rename. Never file content. */
+    detail?: Record<string, string | number | null>;
+};
 /**
  * `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.
@@ -98,6 +114,13 @@ declare function subjectKindOf(kind: unknown): SubjectKind;
 declare function parseSubject(input: unknown): Subject;
 declare function createDrive(deps: DriveDeps): {
     stat(ctx: Ctx, loc: string): Promise<Node>;
+    /**
+     * The changes made to one item, newest first: who (a person or an agent), what, and when. Anyone who may read
+     * the item may read its log. A trashed item can be named by id, so its log can be read before a restore.
+     */
+    listActivity(ctx: Ctx, loc: string, opts?: {
+        limit?: number;
+    }): Promise<ActivityEntry[]>;
     /** Live children, sorted by name. */
     list(ctx: Ctx, loc?: string): Promise<Node[]>;
     mkdir(ctx: Ctx, path: string, opts?: {
@@ -219,8 +242,8 @@ declare function createDrive(deps: DriveDeps): {
      * 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.
+     * them), the shares they hold and the invites they sent on drive items, 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: {
@@ -274,6 +297,7 @@ declare function createDrive(deps: DriveDeps): {
             principalKind: unknown;
             machineMade: unknown;
         }[];
+        activity: ActivityEntry[];
     }>;
     /**
      * Erases a person for good. Only the person in person may. Their drive and its shares go. So do the shares
@@ -356,4 +380,4 @@ declare function createDrive(deps: DriveDeps): {
     }>;
 };
 
-export { type Actor 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, ACTOR_KINDS as a, type Action as b, type ActorKind as c, type Can as d, type DriveDeps as e, DriveError as f, ERROR_STATUS as g, createDrive as h, parseSubject as i, parseName as p, subjectKindOf as s };
+export { type ActivityEntry 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 ActivityAction as a, type Actor as b, ACTOR_KINDS as c, type Action as d, type ActorKind as e, type Can as f, type DriveDeps as g, DriveError as h, ERROR_STATUS as i, createDrive as j, parseSubject as k, parseName as p, subjectKindOf as s };

package/dist/embed.css

@@ -289,3 +289,18 @@ html:has(.drive-bulk) {
   background-repeat: no-repeat;
   background-position: center;
 }
+.drive-activity {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: grid;
+  gap: var(--agd-space-2);
+}
+.drive-activity li {
+  padding: var(--agd-space-2) 0;
+  border-bottom: 1px solid var(--agd-color-border);
+}
+.drive-activity time {
+  color: var(--agd-color-text-muted);
+  font-size: 0.875em;
+}