@tdxvolt/volt-drive-mcp 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,290 @@
-# Temporary Holding Version
+# @tdxvolt/volt-drive-mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [MCP](https://modelcontextprotocol.io) server that lets AI assistants (Cursor,
+Claude Code, Claude Desktop, ...) browse, search and edit your **VoltDrive**
+drives.
+
+```
+AI client  --MCP (stdio or HTTP)-->  volt-drive-mcp  --gRPC-->  your Volt  <--sync-->  VoltDrive
+```
+
+It connects to a Volt using your `volt.config.json`, so it acts as the identity
+in that file and sees the drives that identity can access. Edits go through
+Volt's sync layer, so they merge with concurrent edits and appear on every
+device that has the drive.
+
+**Requirements:** Node.js 20 or later, and a `volt.config.json` for a Volt that
+can access the drive(s) you want to use.
+
+## Quick start
+
+### 1. Check it works
+
+Run this once from a terminal (use the real path to your config):
+
+```sh
+npx -y @tdxvolt/volt-drive-mcp --config /absolute/path/to/volt.config.json --read-only
+```
+
+You should see something like:
+
+```
+[volt-drive-mcp] info: serving VoltDrive over stdio (read-only)
+[volt-drive-mcp] info: connecting to the Volt using /absolute/path/to/volt.config.json
+[volt-drive-mcp] info: connected to <your volt>
+```
+
+It then waits silently: it is an MCP server and speaks JSON-RPC on stdin/stdout,
+so it isn't meant to be used interactively. Press Ctrl+C to stop it. To try the
+tools by hand, see [Trying the tools](#trying-the-tools).
+
+### 2. Add it to your AI client
+
+Always use an **absolute path** for `--config`: clients start the server from a
+directory you don't control, so relative paths won't resolve.
+
+**Cursor**: add to `~/.cursor/mcp.json` (all projects) or `.cursor/mcp.json`
+(one project), then check *Settings → Tools & MCP* for a green dot:
+
+```json
+{
+  "mcpServers": {
+    "voltdrive": {
+      "command": "npx",
+      "args": [
+        "-y", "@tdxvolt/volt-drive-mcp",
+        "--config", "/absolute/path/to/volt.config.json",
+        "--read-only"
+      ]
+    }
+  }
+}
+```
+
+**Claude Code**:
+
+```sh
+claude mcp add voltdrive -- npx -y @tdxvolt/volt-drive-mcp \
+  --config /absolute/path/to/volt.config.json --read-only
+```
+
+**Claude Desktop**: add the same `command` and `args` as the Cursor example under
+`mcpServers` in `claude_desktop_config.json`, then restart the app.
+
+### 3. Use it
+
+Ask the assistant to use your drive in plain language. It calls the tools
+itself, and most clients show each call and ask for approval first.
+
+- "List my drives, then show me the top-level folders of *Project Files*."
+- "Read `notes/meeting.md` from my VoltDrive and summarise the action items."
+- "Search my drive for files that mention 'invoice'."
+- With writes enabled: "Create `notes/summary.md` in my drive with a summary of
+  this conversation", or "Move `drafts/old.md` to `archive/old.md`".
+
+Mention the drive ("on my VoltDrive", "in the *Project Files* drive") so the
+assistant picks these tools rather than searching your local workspace.
+
+### Enabling writes
+
+The examples above use `--read-only`, which removes every tool that changes a
+drive. Once you're happy, remove `--read-only` from `args` and restart the
+server. Keep your client's per-call approval on for write tools, and see
+[Safety](#safety-and-identity).
+
+### Limiting which drives are visible
+
+By default every drive the identity can see is available. To restrict it, add
+`--drive` (repeatable) with a drive id, alias or name:
+
+```json
+"args": ["-y", "@tdxvolt/volt-drive-mcp", "--config", "/absolute/path/to/volt.config.json",
+         "--drive", "3bfde0b4-04c0-4620-8027-1b191b048503", "--read-only"]
+```
+
+Run the assistant's `list_drives` tool (or the command in
+[Trying the tools](#trying-the-tools)) to find ids and names.
+
+## Options
+
+| Option | Environment variable | Meaning |
+| --- | --- | --- |
+| `-c, --config <file>` | `VOLT_DRIVE_MCP_CONFIG` | Path to `volt.config.json`. Default `./volt.config.json` in the working directory. |
+| `--read-only` | `VOLT_DRIVE_MCP_READ_ONLY=1` | Do not offer any tool that changes a drive. |
+| `-d, --drive <id\|alias\|name>` | `VOLT_DRIVE_MCP_DRIVES=a,b` | Only expose these drives (repeatable). |
+| `--max-file-bytes <n>` | | Largest file that can be read or written. Default 10 MiB. A drive's own maximum file size also applies if it is smaller. |
+| `--max-response-chars <n>` | | Most characters one read returns. Default 100000. Longer files come back in pages. |
+| `-h, --help` | | Show usage. |
+
+Logs go to **stderr** only (stdout carries the protocol). Set
+`VOLT_DRIVE_MCP_LOG=debug` for more detail. Your client's MCP log shows them.
+
+The server connects to the Volt in the background. The client's handshake
+completes immediately, and if the Volt can't be reached each tool call retries
+and reports why.
+
+## Tools
+
+Every tool takes a `drive` argument (id, alias or name). Paths are relative to
+the drive root, use `/`, and cannot contain `..`.
+
+**Read tools** (always available):
+
+| Tool | What it does |
+| --- | --- |
+| `list_drives` | The drives this identity can see. Start here. |
+| `get_drive_status` | File and folder counts, size, drive settings, sync state. |
+| `list_directory` | Files and folders in a folder, optionally recursive. |
+| `read_file` | A file's text, in pages for large files, or base64 bytes for binary files. |
+| `search_files` | Find files by name or glob, and/or by text inside them. |
+| `list_file_versions` | Saved versions of a file (needs file versions enabled on the drive). |
+| `read_file_version` | A file's text as of a saved version. |
+
+**Write tools** (omitted with `--read-only`):
+
+| Tool | What it does |
+| --- | --- |
+| `write_file` | Create a file, or replace one with `overwrite: true`. Text changes are applied as a minimal diff so they merge with concurrent edits. |
+| `create_folder` | Create a folder and any missing parents. |
+| `move_path` | Rename or move a file or folder. The destination must not exist. |
+| `delete_path` | Delete a file, or a folder with `recursive: true`. |
+| `create_file_version` | Save a named version of a file. |
+| `revert_file_version` | Restore a file's content from a saved version. |
+
+Behaviour worth knowing:
+
+- **Large files** are returned in pieces of up to `--max-response-chars`. The
+  result says when it is truncated and gives the `offset` to continue from.
+- **Binary files** are stored as blobs. `read_file` returns their metadata, or
+  the bytes with `encoding: "base64"`. Whether a drive accepts binary files is
+  its *include binary files* setting, which the connector respects: writing
+  binary data to a drive that ignores them fails with an explanation.
+- **Files still syncing** to your Volt (for example just after cloning a large
+  drive) are waited for, and reported as not yet synced if they don't arrive,
+  rather than returned empty.
+- **File versions** only work on drives with versioning enabled; otherwise the
+  tools say so.
+- **Search** scans text files only. Binary and very large files are skipped and
+  counted in the result.
+
+## Trying the tools
+
+To exercise the server without an AI client:
+
+```sh
+# Web UI: pick a tool, fill in arguments, see the result
+npx @modelcontextprotocol/inspector npx -y @tdxvolt/volt-drive-mcp -- \
+  --config /absolute/path/to/volt.config.json --read-only
+
+# One call from the terminal, no browser
+npx @modelcontextprotocol/inspector --cli --method tools/call --tool-name list_drives \
+  npx -y @tdxvolt/volt-drive-mcp -- --config /absolute/path/to/volt.config.json --read-only
+```
+
+The Inspector has its own `--config` option, so the connector's flags must come
+after the `--`. The Inspector's web UI prints a `http://127.0.0.1:6274?…` URL
+to open; click **Connect**, then **Tools**.
+
+## Streamable HTTP (shared service)
+
+By default the AI client starts its own copy of the server over stdio, which is
+simplest. To run one shared server that several clients connect to instead:
+
+```sh
+export VOLT_DRIVE_MCP_TOKEN="$(openssl rand -hex 32)"
+npx -y -p @tdxvolt/volt-drive-mcp volt-drive-mcp-http \
+  --config /absolute/path/to/volt.config.json --read-only --port 3333
+```
+
+Clients then use the URL and token (Cursor shown):
+
+```json
+{
+  "mcpServers": {
+    "voltdrive": {
+      "url": "http://127.0.0.1:3333/mcp",
+      "headers": { "Authorization": "Bearer <the token>" }
+    }
+  }
+}
+```
+
+| Option | Meaning |
+| --- | --- |
+| `--host <addr>` | Address to listen on. Default `127.0.0.1` (this machine only). |
+| `-p, --port <n>` | Port. Default `3333`. |
+| `--path <path>` | Endpoint path. Default `/mcp`. |
+| `--token <secret>` / `VOLT_DRIVE_MCP_TOKEN` | Bearer token clients must send. **Required** when `--host` is not a loopback address. |
+| `--allowed-host <name>` | Extra `Host` header value to accept (repeatable), for use behind a reverse proxy. |
+
+All options above also apply (`--config`, `--read-only`, `--drive`, ...). The
+HTTP server is stateless and shares one Volt connection between requests. It
+accepts only `POST`, compares the token in constant time, and on loopback
+rejects unexpected `Host` and `Origin` headers (DNS rebinding protection). It
+does **not** provide TLS: put it behind a reverse proxy before exposing it
+beyond your own machine. Everyone with the token shares the one Volt identity.
+
+## Safety and identity
+
+- **The connector acts as the identity in `volt.config.json`.** Anything that
+  identity can do in a drive, the AI client can do through the connector.
+  Prefer a dedicated identity that has only the drives you want to expose, and
+  use `--read-only` and `--drive` to narrow things further. Volt's own access
+  policy still applies: permission failures come back as tool errors.
+- Write tools carry MCP annotations (`readOnlyHint`, `destructiveHint`,
+  `idempotentHint`) so clients can ask before running them. `delete_path` won't
+  remove a non-empty folder unless `recursive: true`, and `write_file` won't
+  replace a file unless `overwrite: true`. Changes sync to everyone who has the
+  drive; use `create_file_version` first if you may want to roll back.
+- File contents are untrusted input to the assistant: a document can contain
+  instructions aimed at it. Only grant write access to drives you trust.
+- Never put the token or `volt.config.json` in a shared or committed
+  configuration file.
+
+## Troubleshooting
+
+| Symptom | Likely cause and fix |
+| --- | --- |
+| Server shows red / "failed to start" in the client | Run the command from [step 1](#1-check-it-works) in a terminal to see the error. Check Node is 20+ (`node -v`) and `npx` is on the PATH the client uses. |
+| Tool calls fail with "could not connect to the Volt: …" | The config path is wrong or relative, or the Volt isn't running or reachable. The message includes the underlying reason; the server retries on the next call. |
+| `list_drives` returns no drives | The identity in the config has no access to any drive on that Volt, or `--drive` doesn't match any of them. |
+| "File versions are disabled on this drive" | Turn on file versions in the drive's settings. |
+| "this drive ignores binary files" | Enable *include binary files* in the drive's settings, or write text only. |
+| "not finished syncing to this Volt yet" | The file's content hasn't arrived from the other devices. Try again shortly. |
+| `permission denied` style errors on write | The identity can read the drive but not write it. |
+
+## Development
+
+```sh
+git clone https://github.com/tdxvolt/tdxvolt-volt-drive-mcp
+cd tdxvolt-volt-drive-mcp
+npm install
+npm test                                  # unit and protocol tests, no Volt needed
+npm run inspect -- --config /path/to/volt.config.json --read-only   # MCP Inspector
+node bin/stdio.js --config /path/to/volt.config.json                # run directly
+```
+
+`npm test` runs the whole stack (MCP client, server, drive logic, sync) against
+an in-memory fake Volt in `test/helpers/fake-volt.js`.
+
+`scripts/e2e.js` checks the real thing. It creates a throwaway drive on a
+running Volt, drives every tool through a spawned stdio server, then deletes
+the drive:
+
+```sh
+npm run e2e -- --config /path/to/volt.config.json
+# --keep keeps the drive afterwards; --no-binary skips the binary-file step
+```
+
+Layout: `src/drive-service.js` holds the transport-independent logic,
+`src/server.js` defines the MCP tools on top of it, and `bin/stdio.js` and
+`bin/http.js` (with `src/http.js`) are the two entry points.
+
+### Data model
+
+A drive is a Volt synapse of kind `volt:drive-database`. Its `__meta` document
+has an `idx` map of `documentId -> { json: { name, s }, __hash, __schema,
+__timestamp }`; folders live in a `folders` document. Text files are a Yjs
+`content` text per document; binary files are blobs addressed by SHA-256.
+Metadata is written with `SetSynapseDocumentMetadata`, which must restate the
+document's schema on every call, even for a rename.

package/bin/http.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * Serve VoltDrive to MCP clients over Streamable HTTP. Unlike the stdio
+ * entry point this runs as a long-lived service that several clients can
+ * share; see the README for the security notes.
+ */
+
+import { COMMON_USAGE, HTTP_USAGE, parseConfig } from "../src/config.js";
+import { createDriveService } from "../src/connect.js";
+import { startHttpServer } from "../src/http.js";
+import { createLogger, redirectConsoleToStderr } from "../src/logger.js";
+
+redirectConsoleToStderr();
+const logger = createLogger();
+
+const usage = `Usage: volt-drive-mcp-http [options]\n\n${COMMON_USAGE}\n\n${HTTP_USAGE}\n`;
+
+async function main() {
+  let config;
+  try {
+    config = parseConfig(process.argv.slice(2), { http: true });
+  } catch (err) {
+    logger.error(err.message);
+    process.stderr.write(`\n${usage}`);
+    process.exit(2);
+  }
+
+  if (config.help) {
+    process.stderr.write(usage);
+    process.exit(0);
+  }
+
+  const service = createDriveService(config.configPath, {
+    options: config.options,
+    logger
+  });
+
+  let started;
+  try {
+    started = await startHttpServer(service, config.http, { logger });
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+
+  const { httpServer, port, settings } = started;
+  logger.info(
+    `serving VoltDrive at http://${settings.host}:${port}${settings.path}` +
+      `${service.readOnly ? " (read-only)" : ""}` +
+      `${settings.token ? " (bearer token required)" : " (no token: loopback only)"}`
+  );
+
+  service.ensureConnected().catch((err) => logger.error(err.message));
+
+  let shuttingDown = false;
+  const shutdown = async (signal) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logger.info(`shutting down (${signal})`);
+    httpServer.close();
+    httpServer.closeAllConnections?.();
+    try {
+      await service.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+
+main().catch((err) => {
+  logger.error(err?.stack ?? String(err));
+  process.exit(1);
+});

package/bin/stdio.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+/**
+ * Serve VoltDrive to an MCP client over stdio. The client (Cursor, Claude
+ * Desktop, ...) spawns this process and talks to it over stdin/stdout, so
+ * nothing else may ever write to stdout.
+ */
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { COMMON_USAGE, parseConfig } from "../src/config.js";
+import { createDriveService } from "../src/connect.js";
+import { createLogger, redirectConsoleToStderr } from "../src/logger.js";
+import { createServer } from "../src/server.js";
+
+redirectConsoleToStderr();
+const logger = createLogger();
+
+async function main() {
+  let config;
+  try {
+    config = parseConfig(process.argv.slice(2));
+  } catch (err) {
+    logger.error(err.message);
+    process.stderr.write(`\nUsage: volt-drive-mcp [options]\n\n${COMMON_USAGE}\n`);
+    process.exit(2);
+  }
+
+  if (config.help) {
+    process.stderr.write(`Usage: volt-drive-mcp [options]\n\n${COMMON_USAGE}\n`);
+    process.exit(0);
+  }
+
+  const service = createDriveService(config.configPath, {
+    options: config.options,
+    logger
+  });
+
+  const server = createServer(service, { logger });
+  await server.connect(new StdioServerTransport());
+  logger.info(
+    `serving VoltDrive over stdio${service.readOnly ? " (read-only)" : ""}`
+  );
+
+  // Connect to the Volt in the background: the MCP handshake must not wait for
+  // it. If it fails here, each tool call will retry and report the reason.
+  service.ensureConnected().catch((err) => logger.error(err.message));
+
+  let shuttingDown = false;
+  const shutdown = async (signal) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logger.info(`shutting down (${signal})`);
+    try {
+      await server.close();
+      await service.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  // The client closing our stdin is the normal way a stdio server is stopped.
+  process.stdin.on("end", () => shutdown("stdin closed"));
+}
+
+main().catch((err) => {
+  logger.error(err?.stack ?? String(err));
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@tdxvolt/volt-drive-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Model Context Protocol (MCP) server that exposes VoltDrive drives to AI clients",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "voltdrive",
+    "tdxvolt",
+    "volt"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tdxvolt/tdxvolt-volt-drive-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tdxvolt/tdxvolt-volt-drive-mcp/issues"
+  },
+  "homepage": "https://github.com/tdxvolt/tdxvolt-volt-drive-mcp#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "bin": {
+    "volt-drive-mcp": "bin/stdio.js",
+    "volt-drive-mcp-http": "bin/http.js"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "start": "node ./bin/stdio.js",
+    "start:http": "node ./bin/http.js",
+    "inspect": "npx @modelcontextprotocol/inspector node ./bin/stdio.js --",
+    "test": "node --test \"test/*.test.js\"",
+    "e2e": "node ./scripts/e2e.js",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "author": "toby.ealden@gmail.com",
+  "license": "ISC",
+  "dependencies": {
+    "@grpc/grpc-js": "^1.12.6",
+    "@modelcontextprotocol/sdk": "^1.20.0",
+    "@tdxvolt/volt-client-grpc": "^0.20.36",
+    "yjs": "^13.6.18",
+    "zod": "^3.25.0"
+  }
+}

package/src/blob.js

@@ -0,0 +1,192 @@
+import { concatBytes, toBytes } from "./bytes.js";
+import { DriveError, timeout as timeoutError } from "./errors.js";
+
+/** Match the native client's file transfer block size. */
+const BLOB_CHUNK_BYTES = 512 * 1024;
+
+/** Abort a transfer when nothing has happened for this long. */
+const STALL_TIMEOUT_MS = 60_000;
+
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+
+function statusMessage(response) {
+  const message = response?.status?.message;
+  return message ? String(message) : "";
+}
+
+/**
+ * Whether the synapse blob store already holds `hash`.
+ *
+ * Passing `documentId` authorises the call against that one document, so an
+ * identity holding access to just that document can use its blob.
+ */
+export async function hasBlob(client, synapseId, hash, documentId) {
+  const response = await client.HasSynapseBlob({
+    synapse_id: synapseId,
+    hash,
+    ...(documentId ? { document_id: documentId } : {})
+  });
+  return Boolean(response?.exists);
+}
+
+/** Upload `bytes` to the blob store (streamed in blocks). */
+export async function putBlob(client, synapseId, hash, bytes, documentId) {
+  if (bytes.byteLength === 0) {
+    return;
+  }
+
+  const call = client.PutSynapseBlob({
+    start: {
+      synapse_id: synapseId,
+      hash,
+      size: bytes.byteLength,
+      ...(documentId ? { document_id: documentId } : {})
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    let stallTimer = null;
+
+    const finish = (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(stallTimer);
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    };
+
+    const armStall = () => {
+      clearTimeout(stallTimer);
+      stallTimer = setTimeout(
+        () => finish(timeoutError("blob upload stalled")),
+        STALL_TIMEOUT_MS
+      );
+    };
+
+    call.on("error", (err) => finish(toError(err)));
+    call.on("data", (payload) => {
+      const message = statusMessage(payload);
+      if (message) {
+        finish(new DriveError(message));
+      }
+    });
+    call.on("end", () => finish());
+
+    armStall();
+
+    (async () => {
+      // The initial `start` message is written on the next tick, so let it go
+      // out before any data blocks.
+      await tick();
+      for (let offset = 0; offset < bytes.byteLength; offset += BLOB_CHUNK_BYTES) {
+        if (settled) {
+          return;
+        }
+        call.write({
+          block: Buffer.from(
+            bytes.buffer,
+            bytes.byteOffset + offset,
+            Math.min(BLOB_CHUNK_BYTES, bytes.byteLength - offset)
+          )
+        });
+        armStall();
+        await tick();
+      }
+      call.end();
+    })().catch((err) => finish(toError(err)));
+  });
+}
+
+/** Upload `bytes` unless a blob with this hash already exists. */
+export async function ensureBlob(client, synapseId, hash, bytes, documentId) {
+  if (bytes.byteLength === 0) {
+    return;
+  }
+  if (await hasBlob(client, synapseId, hash, documentId)) {
+    return;
+  }
+  await putBlob(client, synapseId, hash, bytes, documentId);
+}
+
+/** Download the blob `hash`. */
+export function getBlob(client, synapseId, hash, documentId, { maxBytes } = {}) {
+  if (!hash) {
+    return Promise.resolve(new Uint8Array());
+  }
+
+  const call = client.GetSynapseBlob({
+    synapse_id: synapseId,
+    hash,
+    ...(documentId ? { document_id: documentId } : {})
+  });
+
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let received = 0;
+    let settled = false;
+    let stallTimer = null;
+
+    const finish = (err, bytes) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(stallTimer);
+      if (err) {
+        try {
+          call.end();
+        } catch {
+          // stream already closed
+        }
+        reject(err);
+      } else {
+        resolve(bytes);
+      }
+    };
+
+    const armStall = () => {
+      clearTimeout(stallTimer);
+      stallTimer = setTimeout(
+        () => finish(timeoutError(`file transfer stalled after ${received} bytes`)),
+        STALL_TIMEOUT_MS
+      );
+    };
+
+    call.on("error", (err) => finish(toError(err)));
+    call.on("data", (payload) => {
+      const message = statusMessage(payload);
+      if (message) {
+        finish(new DriveError(message));
+        return;
+      }
+      if (payload?.block && payload.block.length !== 0) {
+        try {
+          const block = toBytes(payload.block);
+          chunks.push(block);
+          received += block.length;
+        } catch (err) {
+          finish(toError(err));
+          return;
+        }
+        if (maxBytes && received > maxBytes) {
+          finish(new DriveError(`file exceeds the ${maxBytes} byte limit`, "too_large"));
+          return;
+        }
+        armStall();
+      }
+    });
+    call.on("end", () => finish(null, concatBytes(chunks)));
+
+    armStall();
+  });
+}