@persistmemory/cli 0.1.2 → 0.2.1

package/dist/bin.js

@@ -234,6 +234,27 @@ var HttpClient = class {
       ...options ? { options } : {}
     });
   }
+  /** POST with a file as the body. The type describes the bytes, not JSON. */
+  async postBytes(path, bytes, contentType, query, options) {
+    return this.#request({
+      method: "POST",
+      path,
+      rawBody: bytes,
+      contentType,
+      ...query ? { query } : {},
+      ...options ? { options } : {}
+    });
+  }
+  /** GET that returns bytes rather than JSON, for downloading a file. */
+  async getBytes(path, query, options) {
+    return this.#request({
+      method: "GET",
+      path,
+      rawResponse: true,
+      ...query ? { query } : {},
+      ...options ? { options } : {}
+    });
+  }
   async patch(path, body, options) {
     return this.#request({
       method: "PATCH",
@@ -286,11 +307,20 @@ var HttpClient = class {
         this.#fetch(url, {
           method: request.method,
           headers: this.#headers(request),
-          ...request.body !== void 0 ? { body: JSON.stringify(request.body) } : {},
+          ...request.rawBody !== void 0 ? { body: request.rawBody } : request.body !== void 0 ? { body: JSON.stringify(request.body) } : {},
           signal: deadline.signal
         }),
         deadline.signal
       );
+      if (request.rawResponse && response.ok) {
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const named = /filename="([^"]+)"/.exec(disposition)?.[1];
+        return {
+          bytes: new Uint8Array(await response.arrayBuffer()),
+          contentType: response.headers.get("content-type") ?? "application/octet-stream",
+          ...named ? { filename: named } : {}
+        };
+      }
       const payload = await readBody(response);
       if (!response.ok) throw errorFromResponse(response.status, payload, response.headers);
       return payload;
@@ -311,9 +341,11 @@ var HttpClient = class {
     return {
       // The only place the key is ever read.
       authorization: `Bearer ${this.#apiKey}`,
-      accept: "application/json",
+      // A download route answers with the file's own type, so `*/*` rather
+      // than a promise to accept only JSON that the server would have to break.
+      accept: request.rawResponse ? "*/*" : "application/json",
       "user-agent": this.#userAgent,
-      ...request.body !== void 0 ? { "content-type": "application/json" } : {},
+      ...request.rawBody !== void 0 ? { "content-type": request.contentType ?? "application/octet-stream" } : request.body !== void 0 ? { "content-type": "application/json" } : {},
       ...request.options?.idempotencyKey ? { "idempotency-key": request.options.idempotencyKey } : {}
     };
   }
@@ -344,7 +376,7 @@ var SignalFired = class extends Error {
 };
 function untilAborted(work, signal) {
   work.catch(() => void 0);
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     if (signal.aborted) {
       reject(new SignalFired());
       return;
@@ -354,7 +386,7 @@ function untilAborted(work, signal) {
     work.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve7(value);
+        resolve8(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -364,14 +396,14 @@ function untilAborted(work, signal) {
   });
 }
 function defaultSleep(ms, signal) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     if (signal?.aborted) {
       reject(new AbortError());
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve7();
+      resolve8();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
@@ -890,6 +922,119 @@ var Conversations = class {
     );
   }
 };
+var Google = class {
+  #http;
+  constructor(http) {
+    this.#http = http;
+  }
+  /** Files by name, newest first. Omit the query for recently changed ones. */
+  async searchDrive(params = {}, options) {
+    return this.#http.get(
+      "/api/v1/google/drive/files",
+      {
+        ...params.query !== void 0 ? { query: params.query } : {},
+        ...params.limit !== void 0 ? { limit: params.limit } : {}
+      },
+      options
+    );
+  }
+  async getDriveFile(fileId, options) {
+    return this.#http.get(
+      `/api/v1/google/drive/files/${encodeURIComponent(fileId)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * The bytes of a Drive file.
+   *
+   * A Google Doc, Sheet or Slide holds no bytes of its own and is exported on
+   * the way - a document as PDF, a spreadsheet as CSV - so `filename` comes
+   * back describing what it BECAME. Writing it under the id instead produces a
+   * file nothing will open.
+   */
+  async downloadDriveFile(fileId, options) {
+    return this.#http.getBytes(
+      `/api/v1/google/drive/files/${encodeURIComponent(fileId)}/content`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Writes a file into the user's Drive.
+   *
+   * Needs one of the Drive write permissions on their connection. A read-only
+   * grant is refused by Google, and the error names the missing permission
+   * rather than reporting a failed upload - one is fixed with a checkbox and
+   * the other sends somebody looking for a bug.
+   */
+  async saveToDrive(params, options) {
+    return this.#http.postBytes(
+      "/api/v1/google/drive/files",
+      params.bytes,
+      params.contentType ?? "application/octet-stream",
+      {
+        name: params.name,
+        ...params.folderId !== void 0 ? { folderId: params.folderId } : {}
+      },
+      options
+    );
+  }
+  /**
+   * Recent messages - senders, subjects and a one-line preview, never bodies.
+   *
+   * `query` is Gmail's own syntax passed through as written: `from:priya`,
+   * `has:attachment`, `newer_than:7d`. It selects within the connected mailbox
+   * and cannot reach another one.
+   */
+  async searchMail(params = {}, options) {
+    return this.#http.get(
+      "/api/v1/google/mail",
+      {
+        ...params.query !== void 0 ? { query: params.query } : {},
+        ...params.limit !== void 0 ? { limit: params.limit } : {}
+      },
+      options
+    );
+  }
+  /** One message, with its body and the names of what is attached. */
+  async readMail(messageId, options) {
+    return this.#http.get(
+      `/api/v1/google/mail/${encodeURIComponent(messageId)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * The bytes of one attachment.
+   *
+   * Separate from `readMail` so listing a mailbox never drags attachments
+   * across the network: a message with a 40 MB deck should not cost 40 MB to
+   * summarise.
+   */
+  async downloadAttachment(messageId, attachmentId, options) {
+    return this.#http.getBytes(
+      `/api/v1/google/mail/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,
+      void 0,
+      options
+    );
+  }
+  /** Sends as the connected account. Needs the send permission. */
+  async sendMail(params, options) {
+    return this.#http.post("/api/v1/google/mail/send", params, options);
+  }
+  /** People in the user's contacts. Omit the query to list them. */
+  async contacts(params = {}, options) {
+    return this.#http.get(
+      "/api/v1/google/contacts",
+      {
+        ...params.query !== void 0 ? { query: params.query } : {},
+        ...params.limit !== void 0 ? { limit: params.limit } : {}
+      },
+      options
+    );
+  }
+};
 var Integrations = class {
   #http;
   constructor(http) {
@@ -1020,6 +1165,8 @@ var PersistMemory = class {
   conflicts;
   conversations;
   integrations;
+  /** Drive, mail and contacts on the user's connected Google account. */
+  google;
   health;
   agent;
   #http;
@@ -1036,6 +1183,7 @@ var PersistMemory = class {
     this.conflicts = new Conflicts(this.#http);
     this.conversations = new Conversations(this.#http);
     this.integrations = new Integrations(this.#http);
+    this.google = new Google(this.#http);
     this.health = new Health(this.#http);
     this.agent = new Agent(this.#http);
   }
@@ -1379,7 +1527,7 @@ function shortDate(iso) {
 }
 
 // src/help.ts
-var VERSION = "0.1.2";
+var VERSION = true ? "0.2.1" : versionFromManifest();
 var PACKAGE = "@persistmemory/cli";
 var HELP = `
   pm \u2014 PersistMemory from your terminal
@@ -1424,6 +1572,12 @@ var HELP = `
     list spaces                      your Spaces
     get memory <id>                  one memory, in full
 
+    drive [name]                     search your Google Drive
+    drive get <id> [--out path]      download one file here
+    drive put <file> [--name n]      save a file into Drive
+    mail [search]                    recent mail \u2014 from:priya, has:attachment
+    mail read <id>                   one message, with its body
+
     status                           is the service healthy
     requests                         file requests waiting for you to approve
     requests get <id>                write a finished one to a file here
@@ -1570,8 +1724,8 @@ async function startLoopback(options = {}) {
   const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
   let resolveCallback;
   let rejectCallback;
-  const received = new Promise((resolve7, reject) => {
-    resolveCallback = resolve7;
+  const received = new Promise((resolve8, reject) => {
+    resolveCallback = resolve8;
     rejectCallback = reject;
   });
   const server = createServer((request, response) => {
@@ -1597,9 +1751,9 @@ async function startLoopback(options = {}) {
     response.end(donePage(callback));
     resolveCallback?.(callback);
   });
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve8, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve7);
+    server.listen(0, "127.0.0.1", resolve8);
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
@@ -1861,7 +2015,7 @@ function safeEqual(a, b) {
 }
 async function openBrowser(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve8, reject) => {
     const child = spawn(command, args, {
       stdio: "ignore",
       // Detached so closing the terminal does not close the browser, and so
@@ -1870,7 +2024,7 @@ async function openBrowser(url) {
     });
     child.once("error", reject);
     child.unref();
-    resolve7();
+    resolve8();
   });
 }
 async function describe(response) {
@@ -1932,13 +2086,13 @@ async function currentCredential(resolved, deps) {
 // src/context.ts
 import { createInterface } from "node:readline";
 async function askOnTty(prompt) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const readline = createInterface({ input: process.stdin, output: process.stdout });
     readline.question(prompt, (answer3) => {
       readline.close();
-      resolve7(answer3.trim());
+      resolve8(answer3.trim());
     });
-    readline.once("close", () => resolve7(""));
+    readline.once("close", () => resolve8(""));
   });
 }
 var ETX = "";
@@ -1947,13 +2101,13 @@ var BACKSPACE = "\b";
 async function readSecretFromTty(prompt) {
   const input = process.stdin;
   if (!input.isTTY) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       const readline = createInterface({ input });
       readline.once("line", (line) => {
         readline.close();
-        resolve7(line.trim());
+        resolve8(line.trim());
       });
-      readline.once("close", () => resolve7(""));
+      readline.once("close", () => resolve8(""));
     });
   }
   process.stdout.write(prompt);
@@ -1961,14 +2115,14 @@ async function readSecretFromTty(prompt) {
   input.setRawMode?.(true);
   input.resume();
   input.setEncoding("utf8");
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let value = "";
     const finish2 = () => {
       input.removeListener("data", onData);
       input.setRawMode?.(previouslyRaw);
       input.pause();
       process.stdout.write("\n");
-      resolve7(value.trim());
+      resolve8(value.trim());
     };
     const onData = (chunk) => {
       for (const character of chunk) {
@@ -2005,8 +2159,8 @@ async function readStdin() {
 // src/commands/agent.ts
 import { hostname } from "node:os";
 import { homedir as homedir2 } from "node:os";
-import { join as join4, resolve as resolve3 } from "node:path";
-import { readFileSync as readFileSync4, readdirSync, statSync as statSync2 } from "node:fs";
+import { basename, join as join4, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
 
 // src/files.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
@@ -2131,6 +2285,17 @@ function locate(roots, requested) {
   }
   throw new Error(`${requested} is not inside any allowed folder (${roots.join(", ")})`);
 }
+function uncontested(target) {
+  if (!existsSync4(target)) return target;
+  const dot = target.lastIndexOf(".");
+  const stem = dot > target.lastIndexOf("/") && dot !== -1 ? target.slice(0, dot) : target;
+  const extension = stem === target ? "" : target.slice(dot);
+  for (let n = 1; n < 1e3; n += 1) {
+    const candidate = `${stem} (${n})${extension}`;
+    if (!existsSync4(candidate)) return candidate;
+  }
+  throw new Error(`${target} and a thousand names beside it are taken.`);
+}
 async function answer(context, apiUrl, token, roots, request) {
   let located;
   try {
@@ -2138,6 +2303,43 @@ async function answer(context, apiUrl, token, roots, request) {
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : "refused" };
   }
+  if (request.kind === "write_file") {
+    if (!request.sourceUrl) return { ok: false, error: "There was nothing to write." };
+    let downloaded;
+    let fetched;
+    try {
+      fetched = await fetch(request.sourceUrl);
+      if (!fetched.ok) {
+        return { ok: false, error: await said(fetched, "The file could not be fetched") };
+      }
+      downloaded = Buffer.from(await fetched.arrayBuffer());
+    } catch {
+      return { ok: false, error: "The file could not be fetched from the service." };
+    }
+    try {
+      let target = located;
+      if (existsSync4(located) && statSync2(located).isDirectory()) {
+        const disposition = fetched.headers.get("content-disposition") ?? "";
+        const named = /filename="([^"]+)"/.exec(disposition)?.[1];
+        target = join4(located, basename(named ?? "file"));
+      }
+      target = uncontested(target);
+      writeFileSync4(target, downloaded, { flag: "wx" });
+      return upload(
+        apiUrl,
+        token,
+        "written.txt",
+        Buffer.from(`Saved to ${target}
+${downloaded.length} bytes
+`, "utf8")
+      );
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "could not write it"
+      };
+    }
+  }
   let bytes;
   let filename = request.path.split("/").pop() ?? "file";
   if (request.kind === "list_dir") {
@@ -2267,7 +2469,7 @@ async function agentCommand(context) {
     body: JSON.stringify(body)
   });
   let complaint;
-  const complain = (message2) => {
+  const complain2 = (message2) => {
     if (complaint === message2) return;
     complaint = message2;
     context.error(`  ${message2}`);
@@ -2282,7 +2484,7 @@ async function agentCommand(context) {
     try {
       const beat = await call("heartbeat", { hostname: name, platform: process.platform });
       if (!beat.ok) {
-        complain(await said(beat, "the service refused this machine"));
+        complain2(await said(beat, "the service refused this machine"));
       } else {
         working();
         const state = await beat.json();
@@ -2297,7 +2499,7 @@ async function agentCommand(context) {
       }
       const claimed = await call("claim", { hostname: name, limit: 5 });
       if (!claimed.ok) {
-        complain(await said(claimed, "could not pick up work"));
+        complain2(await said(claimed, "could not pick up work"));
       } else {
         const { items } = await claimed.json();
         for (const request of items) {
@@ -2322,9 +2524,172 @@ async function agentCommand(context) {
   return 0;
 }
 
+// src/commands/google.ts
+import { writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename2, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+async function callApi(context, path, init = {}) {
+  const credential = context.resolved.credential;
+  if (!credential) {
+    context.error("Sign in first: pm auth login");
+    return void 0;
+  }
+  const apiUrl = context.resolved.apiUrl.replace(/\/+$/, "");
+  return fetch(`${apiUrl}${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${credential.token}`,
+      ...init.headers ?? {}
+    }
+  });
+}
+async function complain(context, response) {
+  const body = await response.json().catch(() => void 0);
+  context.error(body?.error?.message ?? `That failed (${response.status}).`);
+  return response.status === 409 ? 3 : 1;
+}
+async function driveCommand(context) {
+  const [, noun, ...rest] = context.args.words;
+  if (noun === "get") return driveGet(context, rest.join(" ").trim());
+  if (noun === "put" || noun === "save") return drivePut(context, rest.join(" ").trim());
+  const query = [noun, ...rest].filter(Boolean).join(" ").trim();
+  const response = await callApi(
+    context,
+    `/api/v1/google/drive/files?limit=20${query ? `&query=${encodeURIComponent(query)}` : ""}`
+  );
+  if (!response) return 1;
+  if (!response.ok) return complain(context, response);
+  const { data } = await response.json();
+  if (data.length === 0) {
+    context.print(query ? `Nothing in Drive matches "${query}".` : "That Drive is empty.");
+    return 0;
+  }
+  if (context.flags.output === "json") {
+    context.print(JSON.stringify(data, void 0, 2));
+    return 0;
+  }
+  for (const file of data) {
+    context.print(`  ${file.name}`);
+    context.print(
+      `    ${file.id}${file.size ? ` \xB7 ${Math.round(file.size / 1024)} KB` : ""}${file.modifiedTime ? ` \xB7 ${file.modifiedTime.slice(0, 10)}` : ""}`
+    );
+  }
+  context.print("");
+  context.print("Fetch one with: pm drive get <id>");
+  return 0;
+}
+async function driveGet(context, fileId) {
+  if (!fileId) {
+    context.error("Say which file: pm drive get <id>");
+    return 2;
+  }
+  const response = await callApi(
+    context,
+    `/api/v1/google/drive/files/${encodeURIComponent(fileId)}/content`
+  );
+  if (!response) return 1;
+  if (!response.ok) return complain(context, response);
+  const disposition = response.headers.get("content-disposition") ?? "";
+  const named = /filename="([^"]+)"/.exec(disposition)?.[1];
+  const out = stringFlag(context.args, "out");
+  const target = resolve4(out ?? basename2(named ?? fileId));
+  writeFileSync5(target, Buffer.from(await response.arrayBuffer()));
+  context.print(target);
+  return 0;
+}
+async function drivePut(context, path) {
+  if (!path) {
+    context.error("Say which file: pm drive put ./notes.md");
+    return 2;
+  }
+  let bytes;
+  try {
+    bytes = readFileSync5(resolve4(path));
+  } catch {
+    context.error(`Cannot read ${path}.`);
+    return 1;
+  }
+  const name = stringFlag(context.args, "name") ?? basename2(path);
+  const response = await callApi(
+    context,
+    `/api/v1/google/drive/files?name=${encodeURIComponent(name)}`,
+    {
+      method: "POST",
+      // The bytes as bytes. Base64 in JSON would be a third larger and would
+      // make the limit somebody was told about stop matching the one they hit.
+      headers: { "content-type": "application/octet-stream" },
+      body: new Uint8Array(bytes)
+    }
+  );
+  if (!response) return 1;
+  if (!response.ok) return complain(context, response);
+  const saved = await response.json();
+  context.print(`Saved "${saved.name}" to Drive.${saved.link ? ` ${saved.link}` : ""}`);
+  return 0;
+}
+async function mailCommand(context) {
+  const [, noun, ...rest] = context.args.words;
+  if (noun === "read" || noun === "get") {
+    const messageId = rest.join(" ").trim();
+    if (!messageId) {
+      context.error("Say which message: pm mail read <id>");
+      return 2;
+    }
+    const response2 = await callApi(
+      context,
+      `/api/v1/google/mail/${encodeURIComponent(messageId)}`
+    );
+    if (!response2) return 1;
+    if (!response2.ok) return complain(context, response2);
+    const message2 = await response2.json();
+    if (context.flags.output === "json") {
+      context.print(JSON.stringify(message2, void 0, 2));
+      return 0;
+    }
+    context.print(`From:    ${message2.from ?? "unknown"}`);
+    context.print(`Subject: ${message2.subject ?? "(none)"}`);
+    if (message2.date) context.print(`Date:    ${message2.date}`);
+    context.print("");
+    context.print(message2.body);
+    if (message2.attachments.length > 0) {
+      context.print("");
+      context.print("Attached:");
+      for (const one of message2.attachments) context.print(`  ${one.filename} (${one.mimeType})`);
+    }
+    return 0;
+  }
+  const query = [noun, ...rest].filter(Boolean).join(" ").trim();
+  const response = await callApi(
+    context,
+    `/api/v1/google/mail?limit=20${query ? `&query=${encodeURIComponent(query)}` : ""}`
+  );
+  if (!response) return 1;
+  if (!response.ok) return complain(context, response);
+  const { data } = await response.json();
+  if (data.length === 0) {
+    context.print(query ? `No mail matches "${query}".` : "Nothing in that mailbox.");
+    return 0;
+  }
+  if (context.flags.output === "json") {
+    context.print(JSON.stringify(data, void 0, 2));
+    return 0;
+  }
+  for (const message2 of data) {
+    const marks = [message2.unread ? "unread" : "", message2.hasAttachments ? "attachment" : ""].filter(Boolean).join(", ");
+    context.print(`  ${message2.subject ?? "(no subject)"}${marks ? `  [${marks}]` : ""}`);
+    context.print(
+      `    ${message2.from ?? "unknown"}${message2.date ? ` \xB7 ${message2.date.slice(0, 10)}` : ""}`
+    );
+    context.print(`    ${message2.id}`);
+  }
+  context.print("");
+  context.print("Read one with: pm mail read <id>");
+  return 0;
+}
+
 // src/commands/requests.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { existsSync as existsSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 async function requestsCommand(context) {
   if (context.args.words[1] === "get") return collectCommand(context);
   const credential = context.resolved.credential;
@@ -2392,25 +2757,25 @@ async function collectCommand(context) {
     return 1;
   }
   const name = stringFlag(context.args, "output", "o") ?? filename;
-  const target = resolve4(name);
-  if (existsSync4(target)) {
+  const target = resolve5(name);
+  if (existsSync5(target)) {
     context.error(`${target} already exists. Pass --output to write somewhere else.`);
     return 1;
   }
-  writeFileSync4(target, new Uint8Array(await file.arrayBuffer()));
+  writeFileSync6(target, new Uint8Array(await file.arrayBuffer()));
   context.print(`Wrote ${target}`);
   return 0;
 }
 
 // src/workspace.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname3, join as join5, resolve as resolvePath } from "node:path";
 var WORKSPACE_FILE = ".persistmemory.json";
 function findWorkspace(from = process.cwd()) {
   let dir = resolvePath(from);
   for (; ; ) {
     const file = join5(dir, WORKSPACE_FILE);
-    if (existsSync5(file)) {
+    if (existsSync6(file)) {
       const config = readWorkspace(file);
       if (config) return { file, dir, config };
     }
@@ -2421,7 +2786,7 @@ function findWorkspace(from = process.cwd()) {
 }
 function readWorkspace(file) {
   try {
-    const parsed = JSON.parse(readFileSync5(file, "utf8"));
+    const parsed = JSON.parse(readFileSync6(file, "utf8"));
     const space = parsed.space;
     if (space && typeof space === "object" && typeof space.id === "string" && space.id !== "" && typeof space.name === "string") {
       return { space: { id: space.id, name: space.name } };
@@ -2433,7 +2798,7 @@ function readWorkspace(file) {
 }
 function writeWorkspace(dir, config) {
   const file = join5(dir, WORKSPACE_FILE);
-  writeFileSync5(file, `${JSON.stringify(config, null, 2)}
+  writeFileSync7(file, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   return file;
 }
@@ -2702,9 +3067,9 @@ function message(error) {
 }
 
 // src/commands/maintain.ts
-import { existsSync as existsSync6, rmSync } from "node:fs";
+import { existsSync as existsSync7, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { dirname as dirname4, resolve as resolve6 } from "node:path";
+import { dirname as dirname4, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function updateCommand(context) {
   const manager = installer();
@@ -2746,7 +3111,7 @@ Delete the file it runs from: ${processPath()}`
   return 0;
 }
 async function deleteCommand(context) {
-  if (!existsSync6(context.paths.dir)) {
+  if (!existsSync7(context.paths.dir)) {
     context.print(`Nothing to delete: ${context.paths.dir} does not exist.`);
     return 0;
   }
@@ -2775,7 +3140,7 @@ async function deleteCommand(context) {
   return 0;
 }
 function removeEverything(context) {
-  const dir = resolve6(context.paths.dir);
+  const dir = resolve7(context.paths.dir);
   if (dir === "/" || dir.split("/").filter(Boolean).length < 2) {
     context.error(`Refusing to delete ${dir}: that does not look like a data directory.`);
     return;
@@ -2787,7 +3152,7 @@ function installer() {
 }
 function processPath() {
   try {
-    return resolve6(dirname4(fileURLToPath(import.meta.url)));
+    return resolve7(dirname4(fileURLToPath(import.meta.url)));
   } catch {
     return process.argv[1] ?? "";
   }
@@ -2799,7 +3164,7 @@ import { randomUUID } from "node:crypto";
 import { relative as relative2 } from "node:path";
 
 // src/events.ts
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "node:fs";
 import { join as join6 } from "node:path";
 function openSessionLog(paths, id) {
   const directory = join6(paths.dir, "sessions");
@@ -2816,8 +3181,8 @@ function openSessionLog(paths, id) {
       }
     },
     read() {
-      if (!existsSync7(path)) return [];
-      return readFileSync6(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      if (!existsSync8(path)) return [];
+      return readFileSync7(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
         try {
           return [JSON.parse(line)];
         } catch {
@@ -2894,9 +3259,9 @@ async function sessionCommand(context) {
   context.print(`  Ask anything. /help for commands, /exit to leave.
 `);
   const readline = createInterface2({ input: process.stdin, output: process.stdout });
-  const ask = (prompt) => new Promise((resolve7) => {
-    readline.question(prompt, resolve7);
-    readline.once("close", () => resolve7(void 0));
+  const ask = (prompt) => new Promise((resolve8) => {
+    readline.question(prompt, resolve8);
+    readline.once("close", () => resolve8(void 0));
   });
   const root = process.cwd();
   let running = true;
@@ -3080,7 +3445,7 @@ async function write2(args) {
 }
 
 // src/commands/memory.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 
 // src/spaces.ts
 async function spacesFor(context, client, env = process.env) {
@@ -3144,7 +3509,7 @@ async function rememberCommand(context) {
   let text;
   if (file) {
     try {
-      text = readFileSync7(file, "utf8");
+      text = readFileSync8(file, "utf8");
     } catch {
       context.error(`Could not read ${file}.`);
       return 1;
@@ -3432,6 +3797,16 @@ async function dispatch(context) {
     case "setup":
     case "init":
       return setupCommand(context);
+    /*
+          `pm version` as well as `--version`.
+    
+          It is what people type, and answering "Unknown command" to somebody
+          asking which version they are running — while a flag two characters away
+          answers it — is a needless dead end.
+        */
+    case "version":
+      context.print(VERSION);
+      return 0;
     case "update":
     case "upgrade":
       return updateCommand(context);
@@ -3452,6 +3827,18 @@ async function dispatch(context) {
       return statusCommand(context);
     case "requests":
       return requestsCommand(context);
+    /*
+          Google, through the API rather than through Google.
+    
+          A laptop holds a bearer token and no database connection, so the
+          credential it can prove is the one the API accepts. Google's own tokens
+          never leave the deployment — which is what stops a stolen
+          `~/.persistmemory` from being a stolen mailbox.
+        */
+    case "drive":
+      return driveCommand(context);
+    case "mail":
+      return mailCommand(context);
     /**
      * `pm <verb> <noun>`, the grammar the Harness CLI uses.
      *