@mastra/google-drive 0.0.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @mastra/google-drive

package/README.md

@@ -0,0 +1,52 @@
+# @mastra/google-drive
+
+Google Drive filesystem provider for Mastra workspaces. Mounts a Google Drive folder as an agent workspace, exposing it through the standard `WorkspaceFilesystem` interface so agents can read, write, list, copy, move, and delete files in Drive.
+
+## Installation
+
+```bash
+npm install @mastra/google-drive
+```
+
+## Usage
+
+```typescript
+import { Agent } from '@mastra/core/agent';
+import { Workspace } from '@mastra/core/workspace';
+import { GoogleDriveFilesystem } from '@mastra/google-drive';
+
+const workspace = new Workspace({
+  filesystem: new GoogleDriveFilesystem({
+    folderId: process.env.GOOGLE_DRIVE_FOLDER_ID!,
+    accessToken: process.env.GOOGLE_DRIVE_ACCESS_TOKEN!,
+  }),
+});
+
+const agent = new Agent({
+  name: 'my-agent',
+  model: 'anthropic/claude-opus-4-5',
+  workspace,
+});
+```
+
+## Authentication
+
+Supply one of:
+
+- **`accessToken`** — A pre-obtained OAuth access token (use the `https://www.googleapis.com/auth/drive` scope).
+- **`getAccessToken`** — A callback that returns a token; useful when tokens are refreshed externally.
+- **`serviceAccount`** — A Google service account. Share the target folder with the service account email.
+
+```typescript
+new GoogleDriveFilesystem({
+  folderId: process.env.GOOGLE_DRIVE_FOLDER_ID!,
+  serviceAccount: {
+    clientEmail: process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL!,
+    privateKey: process.env.GOOGLE_SERVICE_ACCOUNT_KEY!,
+  },
+});
+```
+
+## Documentation
+
+For more information, see the [Mastra Workspaces documentation](https://mastra.ai/docs/workspace/overview) and the [GoogleDriveFilesystem reference](https://mastra.ai/reference/workspace/google-drive-filesystem).

package/dist/filesystem/index.d.ts

@@ -0,0 +1,78 @@
+import { MastraFilesystem } from '@mastra/core/workspace';
+import type { CopyOptions, FileContent, FileEntry, FileStat, FilesystemInfo, InstructionsOption, ListOptions, MastraFilesystemOptions, ProviderStatus, ReadOptions, RemoveOptions, WriteOptions } from '@mastra/core/workspace';
+import type { RequestContext } from '@mastra/core/request-context';
+export interface GoogleDriveServiceAccount {
+    clientEmail: string;
+    privateKey: string;
+    privateKeyId?: string;
+    scopes?: string[];
+    subject?: string;
+}
+export interface GoogleDriveFilesystemOptions extends MastraFilesystemOptions {
+    id?: string;
+    folderId: string;
+    accessToken?: string;
+    getAccessToken?: () => string | Promise<string>;
+    serviceAccount?: GoogleDriveServiceAccount;
+    readOnly?: boolean;
+    instructions?: InstructionsOption;
+}
+export declare class GoogleDriveFilesystem extends MastraFilesystem {
+    readonly id: string;
+    readonly name = "GoogleDriveFilesystem";
+    readonly provider = "google-drive";
+    readonly readOnly?: boolean;
+    readonly icon = "drive";
+    readonly displayName = "Google Drive";
+    status: ProviderStatus;
+    private accessToken?;
+    private tokenExpiresAt;
+    private readonly folderId;
+    private readonly getAccessToken?;
+    private readonly serviceAccount?;
+    private readonly instructionsOverride?;
+    constructor(options: GoogleDriveFilesystemOptions);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isReady(): Promise<boolean>;
+    getInfo(): FilesystemInfo;
+    getInstructions(opts?: {
+        requestContext?: RequestContext;
+    }): string;
+    readFile(path: string, options?: ReadOptions): Promise<string | Buffer>;
+    writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void>;
+    appendFile(path: string, content: FileContent): Promise<void>;
+    deleteFile(path: string, options?: RemoveOptions): Promise<void>;
+    copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: RemoveOptions): Promise<void>;
+    readdir(path: string, options?: ListOptions): Promise<FileEntry[]>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    realpath(path: string): Promise<string>;
+    private assertWritable;
+    private toBuffer;
+    private normalize;
+    private getFile;
+    private findFile;
+    private rootFile;
+    private resolveParent;
+    private resolveDir;
+    private createFolder;
+    private findChild;
+    private listChildren;
+    private readdirRecursive;
+    private deleteAny;
+    private upload;
+    private escapeQuery;
+    private request;
+    private fetch;
+    private getToken;
+    private getServiceAccountToken;
+    private base64Url;
+    private normalizePrivateKey;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/filesystem/index.ts"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,474 @@
+'use strict';
+
+var crypto = require('crypto');
+var workspace = require('@mastra/core/workspace');
+
+// src/filesystem/index.ts
+var DRIVE_API = "https://www.googleapis.com/drive/v3";
+var DRIVE_UPLOAD_API = "https://www.googleapis.com/upload/drive/v3";
+var OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+var DEFAULT_SCOPES = ["https://www.googleapis.com/auth/drive"];
+function resolveInstructions(override, getDefault, requestContext) {
+  if (typeof override === "string") return override;
+  const defaultInstructions = getDefault();
+  if (override === void 0) return defaultInstructions;
+  return override({ defaultInstructions, requestContext });
+}
+var GoogleDriveFilesystem = class extends workspace.MastraFilesystem {
+  id;
+  name = "GoogleDriveFilesystem";
+  provider = "google-drive";
+  readOnly;
+  icon = "drive";
+  displayName = "Google Drive";
+  status = "pending";
+  accessToken;
+  tokenExpiresAt = 0;
+  folderId;
+  getAccessToken;
+  serviceAccount;
+  instructionsOverride;
+  constructor(options) {
+    super({ name: "GoogleDriveFilesystem", ...options });
+    this.id = options.id ?? `google-drive:${options.folderId}`;
+    this.folderId = options.folderId;
+    this.accessToken = options.accessToken;
+    this.getAccessToken = options.getAccessToken;
+    this.serviceAccount = options.serviceAccount;
+    this.readOnly = options.readOnly;
+    this.instructionsOverride = options.instructions;
+  }
+  async init() {
+    const driveFile = await this.request(`${DRIVE_API}/files/${encodeURIComponent(this.folderId)}`, {
+      searchParams: { fields: "id,name,mimeType,trashed", supportsAllDrives: "true" }
+    });
+    if (driveFile.trashed) {
+      throw new Error(`Google Drive folder ${this.folderId} is trashed and cannot be used as a filesystem root.`);
+    }
+    if (driveFile.mimeType !== FOLDER_MIME_TYPE) {
+      throw new Error(
+        `Google Drive root ${this.folderId} must be a folder, but received mimeType ${driveFile.mimeType ?? "unknown"}.`
+      );
+    }
+  }
+  async destroy() {
+  }
+  async isReady() {
+    return this.status === "ready";
+  }
+  getInfo() {
+    return {
+      id: this.id,
+      name: this.name,
+      provider: this.provider,
+      status: this.status,
+      error: this.error,
+      readOnly: this.readOnly,
+      icon: this.icon,
+      metadata: { folderId: this.folderId }
+    };
+  }
+  getInstructions(opts) {
+    const defaultInstructions = [
+      "Google Drive filesystem mounted to a single folder.",
+      "Use POSIX-style paths relative to that folder, for example /notes/todo.txt.",
+      "Directories are Google Drive folders. File names must be unique within each folder for path-based operations.",
+      this.readOnly ? "This Google Drive filesystem is read-only." : "You can read, create, update, move, copy, and delete files in this folder."
+    ].join("\n");
+    return resolveInstructions(this.instructionsOverride, () => defaultInstructions, opts?.requestContext);
+  }
+  async readFile(path, options) {
+    await this.ensureReady();
+    const file = await this.getFile(path);
+    if (file.mimeType === FOLDER_MIME_TYPE) throw new workspace.IsDirectoryError(path);
+    const response = await this.fetch(`${DRIVE_API}/files/${encodeURIComponent(file.id)}?alt=media`, { method: "GET" });
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return options?.encoding ? buffer.toString(options.encoding) : buffer;
+  }
+  async writeFile(path, content, options) {
+    await this.ensureReady();
+    this.assertWritable("writeFile");
+    const existing = await this.findFile(path);
+    if (existing) {
+      if (existing.mimeType === FOLDER_MIME_TYPE) throw new workspace.IsDirectoryError(path);
+      if (options?.overwrite === false) throw new workspace.FileExistsError(path);
+      if (options?.expectedMtime) {
+        if (!existing.modifiedTime) throw new workspace.StaleFileError(path, options.expectedMtime, /* @__PURE__ */ new Date(0));
+        const actual = new Date(existing.modifiedTime);
+        if (actual.getTime() !== options.expectedMtime.getTime())
+          throw new workspace.StaleFileError(path, options.expectedMtime, actual);
+      }
+      await this.upload(existing.id, content, options?.mimeType, "PATCH");
+      return;
+    }
+    const { parentId, name } = await this.resolveParent(path, options?.recursive ?? true);
+    await this.upload(void 0, content, options?.mimeType, "POST", { name, parents: [parentId] });
+  }
+  async appendFile(path, content) {
+    const current = await this.exists(path) ? await this.readFile(path) : Buffer.alloc(0);
+    await this.writeFile(path, Buffer.concat([this.toBuffer(current), this.toBuffer(content)]), { recursive: true });
+  }
+  async deleteFile(path, options) {
+    await this.ensureReady();
+    this.assertWritable("deleteFile");
+    const file = await this.findFile(path);
+    if (!file) {
+      if (options?.force) return;
+      throw new workspace.FileNotFoundError(path);
+    }
+    if (file.mimeType === FOLDER_MIME_TYPE) throw new workspace.IsDirectoryError(path);
+    await this.request(`${DRIVE_API}/files/${encodeURIComponent(file.id)}`, { method: "DELETE" });
+  }
+  async copyFile(src, dest, options) {
+    await this.ensureReady();
+    this.assertWritable("copyFile");
+    const source = await this.getFile(src);
+    if (source.mimeType === FOLDER_MIME_TYPE) throw new workspace.IsDirectoryError(src);
+    const existing = await this.findFile(dest);
+    if (existing) {
+      if (existing.mimeType === FOLDER_MIME_TYPE || options?.overwrite === false) throw new workspace.FileExistsError(dest);
+      await this.deleteAny(existing, dest, true);
+    }
+    const { parentId, name } = await this.resolveParent(dest, options?.recursive ?? true);
+    await this.request(`${DRIVE_API}/files/${encodeURIComponent(source.id)}/copy`, {
+      method: "POST",
+      body: JSON.stringify({ name, parents: [parentId] })
+    });
+  }
+  async moveFile(src, dest, options) {
+    await this.ensureReady();
+    this.assertWritable("moveFile");
+    const source = await this.getFile(src);
+    if (options?.overwrite === false && await this.exists(dest)) throw new workspace.FileExistsError(dest);
+    const existing = await this.findFile(dest);
+    if (existing && existing.id !== source.id) {
+      if (existing.mimeType === FOLDER_MIME_TYPE || options?.overwrite === false) throw new workspace.FileExistsError(dest);
+      await this.deleteAny(existing, dest, true);
+    }
+    const { parentId, name } = await this.resolveParent(dest, options?.recursive ?? true);
+    const searchParams = { addParents: parentId, fields: "id", supportsAllDrives: "true" };
+    const oldParents = source.parents?.join(",");
+    if (oldParents) searchParams.removeParents = oldParents;
+    await this.request(`${DRIVE_API}/files/${encodeURIComponent(source.id)}`, {
+      method: "PATCH",
+      searchParams,
+      body: JSON.stringify({ name })
+    });
+  }
+  async mkdir(path, options) {
+    await this.ensureReady();
+    this.assertWritable("mkdir");
+    if (this.normalize(path) === "/") return;
+    const existing = await this.findFile(path);
+    if (existing) {
+      if (existing.mimeType !== FOLDER_MIME_TYPE) throw new workspace.FileExistsError(path);
+      return;
+    }
+    const { parentId, name } = await this.resolveParent(path, options?.recursive ?? false);
+    await this.createFolder(parentId, name);
+  }
+  async rmdir(path, options) {
+    await this.ensureReady();
+    this.assertWritable("rmdir");
+    const dir = await this.findFile(path);
+    if (!dir) {
+      if (options?.force) return;
+      throw new workspace.DirectoryNotFoundError(path);
+    }
+    if (dir.mimeType !== FOLDER_MIME_TYPE) throw new workspace.NotDirectoryError(path);
+    const children = await this.listChildren(dir.id);
+    if (children.length && !options?.recursive) throw new workspace.DirectoryNotEmptyError(path);
+    await this.request(`${DRIVE_API}/files/${encodeURIComponent(dir.id)}`, { method: "DELETE" });
+  }
+  async readdir(path, options) {
+    await this.ensureReady();
+    const dir = await this.getFile(path);
+    if (dir.mimeType !== FOLDER_MIME_TYPE) throw new workspace.NotDirectoryError(path);
+    const entries = await this.readdirRecursive(dir.id, options, 0);
+    const extensions = Array.isArray(options?.extension) ? options.extension : options?.extension ? [options.extension] : void 0;
+    return extensions ? entries.filter((entry) => entry.type === "directory" || extensions.some((ext) => entry.name.endsWith(ext))) : entries;
+  }
+  async exists(path) {
+    await this.ensureReady();
+    return Boolean(await this.findFile(path));
+  }
+  async stat(path) {
+    await this.ensureReady();
+    const file = await this.getFile(path);
+    const isDirectory = file.mimeType === FOLDER_MIME_TYPE;
+    return {
+      name: file.name,
+      path: this.normalize(path),
+      type: isDirectory ? "directory" : "file",
+      size: Number(file.size ?? 0),
+      createdAt: file.createdTime ? new Date(file.createdTime) : /* @__PURE__ */ new Date(0),
+      modifiedAt: file.modifiedTime ? new Date(file.modifiedTime) : /* @__PURE__ */ new Date(0),
+      mimeType: isDirectory ? void 0 : file.mimeType
+    };
+  }
+  async realpath(path) {
+    return this.normalize(path);
+  }
+  assertWritable(operation) {
+    if (this.readOnly) throw new workspace.WorkspaceReadOnlyError(operation);
+  }
+  toBuffer(content) {
+    if (Buffer.isBuffer(content)) return content;
+    if (content instanceof Uint8Array) return Buffer.from(content);
+    return Buffer.from(content, "utf-8");
+  }
+  normalize(path) {
+    const parts = path.split("/").filter(Boolean);
+    const stack = [];
+    for (const part of parts) {
+      if (part === ".") continue;
+      if (part === "..") stack.pop();
+      else stack.push(part);
+    }
+    return `/${stack.join("/")}`;
+  }
+  async getFile(path) {
+    const file = await this.findFile(path);
+    if (!file) throw new workspace.FileNotFoundError(path);
+    return file;
+  }
+  async findFile(path) {
+    const normalized = this.normalize(path);
+    if (normalized === "/") return this.rootFile();
+    const names = normalized.split("/").filter(Boolean);
+    let parentId = this.folderId;
+    let file;
+    for (const name of names) {
+      file = await this.findChild(parentId, name);
+      if (!file) return void 0;
+      parentId = file.id;
+    }
+    return file;
+  }
+  async rootFile() {
+    return this.request(`${DRIVE_API}/files/${encodeURIComponent(this.folderId)}`, {
+      searchParams: { fields: "id,name,mimeType,size,createdTime,modifiedTime,parents", supportsAllDrives: "true" }
+    });
+  }
+  async resolveParent(path, recursive) {
+    const normalized = this.normalize(path);
+    const parts = normalized.split("/").filter(Boolean);
+    const name = parts.pop();
+    if (!name) throw new workspace.IsDirectoryError(path);
+    const parentPath = `/${parts.join("/")}`;
+    const parent = recursive ? await this.resolveDir(parentPath, true) : await this.findFile(parentPath);
+    if (!parent) throw new workspace.DirectoryNotFoundError(parentPath);
+    if (parent.mimeType !== FOLDER_MIME_TYPE) throw new workspace.NotDirectoryError(parentPath);
+    return { parentId: parent.id, name };
+  }
+  async resolveDir(path, recursive) {
+    const normalized = this.normalize(path);
+    if (normalized === "/") return this.rootFile();
+    const names = normalized.split("/").filter(Boolean);
+    let parentId = this.folderId;
+    let current;
+    for (const name of names) {
+      current = await this.findChild(parentId, name);
+      if (current) {
+        if (current.mimeType !== FOLDER_MIME_TYPE) throw new workspace.NotDirectoryError(name);
+        parentId = current.id;
+        continue;
+      }
+      if (!recursive) throw new workspace.DirectoryNotFoundError(normalized);
+      current = await this.createFolder(parentId, name);
+      parentId = current.id;
+    }
+    return current;
+  }
+  async createFolder(parentId, name) {
+    return this.request(`${DRIVE_API}/files`, {
+      method: "POST",
+      searchParams: { fields: "id,name,mimeType,size,createdTime,modifiedTime,parents", supportsAllDrives: "true" },
+      body: JSON.stringify({ name, mimeType: FOLDER_MIME_TYPE, parents: [parentId] })
+    });
+  }
+  async findChild(parentId, name) {
+    const files = await this.listChildren(parentId, `name = '${this.escapeQuery(name)}'`);
+    return files[0];
+  }
+  async listChildren(parentId, extraQuery) {
+    const query = [`'${this.escapeQuery(parentId)}' in parents`, "trashed = false", extraQuery].filter(Boolean).join(" and ");
+    const files = [];
+    let pageToken;
+    do {
+      const result = await this.request(`${DRIVE_API}/files`, {
+        searchParams: {
+          q: query,
+          fields: "nextPageToken,files(id,name,mimeType,size,createdTime,modifiedTime,parents)",
+          pageSize: "1000",
+          supportsAllDrives: "true",
+          includeItemsFromAllDrives: "true",
+          ...pageToken ? { pageToken } : {}
+        }
+      });
+      files.push(...result.files ?? []);
+      pageToken = result.nextPageToken;
+    } while (pageToken);
+    return files;
+  }
+  async readdirRecursive(parentId, options, depth) {
+    const children = await this.listChildren(parentId);
+    const entries = [];
+    for (const child of children) {
+      const isDirectory = child.mimeType === FOLDER_MIME_TYPE;
+      entries.push({ name: child.name, type: isDirectory ? "directory" : "file", size: Number(child.size ?? 0) });
+      const shouldDescend = isDirectory && options?.recursive && (options.maxDepth === void 0 || depth < options.maxDepth);
+      if (shouldDescend) {
+        const nested = await this.readdirRecursive(child.id, options, depth + 1);
+        entries.push(...nested.map((entry) => ({ ...entry, name: `${child.name}/${entry.name}` })));
+      }
+    }
+    return entries;
+  }
+  async deleteAny(file, path, recursive) {
+    if (file.mimeType === FOLDER_MIME_TYPE) await this.rmdir(path, { recursive, force: true });
+    else await this.deleteFile(path, { force: true });
+  }
+  async upload(fileId, content, mimeType = "application/octet-stream", method, metadata) {
+    const boundary = `mastra-${Date.now()}`;
+    const body = Buffer.concat([
+      Buffer.from(
+        `--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${JSON.stringify(metadata ?? {})}\r
+`
+      ),
+      Buffer.from(`--${boundary}\r
+Content-Type: ${mimeType}\r
+\r
+`),
+      this.toBuffer(content),
+      Buffer.from(`\r
+--${boundary}--`)
+    ]);
+    const url = fileId ? `${DRIVE_UPLOAD_API}/files/${encodeURIComponent(fileId)}` : `${DRIVE_UPLOAD_API}/files`;
+    await this.request(url, {
+      method,
+      searchParams: { uploadType: "multipart", fields: "id", supportsAllDrives: "true" },
+      headers: { "Content-Type": `multipart/related; boundary=${boundary}` },
+      body
+    });
+  }
+  escapeQuery(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  }
+  async request(url, init = {}) {
+    const response = await this.fetch(url, init);
+    if (response.status === 204) return void 0;
+    return await response.json();
+  }
+  async fetch(url, init = {}) {
+    const token = await this.getToken();
+    const target = new URL(url);
+    for (const [key, value] of Object.entries(init.searchParams ?? {})) target.searchParams.set(key, value);
+    const response = await globalThis.fetch(target, {
+      ...init,
+      headers: { Authorization: `Bearer ${token}`, ...init.headers }
+    });
+    if (!response.ok) {
+      const message = await response.text().catch(() => response.statusText);
+      throw new Error(`Google Drive API request failed (${response.status}): ${message}`);
+    }
+    return response;
+  }
+  async getToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiresAt - 6e4) return this.accessToken;
+    if (this.getAccessToken) return this.getAccessToken();
+    if (this.serviceAccount) return this.getServiceAccountToken();
+    if (this.accessToken) return this.accessToken;
+    throw new Error("GoogleDriveFilesystem requires accessToken, getAccessToken, or serviceAccount authentication.");
+  }
+  async getServiceAccountToken() {
+    const account = this.serviceAccount;
+    const now = Math.floor(Date.now() / 1e3);
+    const header = { alg: "RS256", typ: "JWT", ...account.privateKeyId ? { kid: account.privateKeyId } : {} };
+    const claim = {
+      iss: account.clientEmail,
+      scope: (account.scopes ?? DEFAULT_SCOPES).join(" "),
+      aud: OAUTH_TOKEN_URL,
+      exp: now + 3600,
+      iat: now,
+      ...account.subject ? { sub: account.subject } : {}
+    };
+    const unsigned = `${this.base64Url(JSON.stringify(header))}.${this.base64Url(JSON.stringify(claim))}`;
+    const privateKey = this.normalizePrivateKey(account.privateKey);
+    let signature;
+    try {
+      signature = crypto.createSign("RSA-SHA256").update(unsigned).sign(privateKey, "base64url");
+    } catch (err) {
+      const hasBegin = privateKey.includes("-----BEGIN");
+      const hasEnd = privateKey.includes("-----END");
+      throw new Error(
+        `Google service account private key signing failed (${err.message}). Key has BEGIN marker: ${hasBegin}, END marker: ${hasEnd}. Ensure your .env value contains the raw PEM with \\n for newlines, without extra surrounding quotes or commas.`
+      );
+    }
+    const response = await globalThis.fetch(OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        assertion: `${unsigned}.${signature}`
+      })
+    });
+    if (!response.ok)
+      throw new Error(`Google service account token request failed (${response.status}): ${await response.text()}`);
+    const json = await response.json();
+    this.accessToken = json.access_token;
+    this.tokenExpiresAt = Date.now() + json.expires_in * 1e3;
+    return json.access_token;
+  }
+  base64Url(value) {
+    return Buffer.from(value).toString("base64url");
+  }
+  normalizePrivateKey(key) {
+    let out = key.trim();
+    for (let i = 0; i < 5; i++) {
+      const before = out;
+      if (out.endsWith(",")) out = out.slice(0, -1).trim();
+      if (out.startsWith('"') && out.endsWith('"') || out.startsWith("'") && out.endsWith("'")) {
+        out = out.slice(1, -1);
+      }
+      if (out.startsWith('\\"') && out.endsWith('\\"') || out.startsWith("\\'") && out.endsWith("\\'")) {
+        out = out.slice(2, -2);
+      }
+      if (out === before) break;
+    }
+    out = out.replace(/\\n/g, "\n");
+    out = out.replace(/\\"/g, '"').replace(/\\'/g, "'");
+    out = out.replace(/\r\n?/g, "\n");
+    if (!out.endsWith("\n")) out += "\n";
+    return out;
+  }
+};
+
+// src/provider.ts
+var googleDriveFilesystemProvider = {
+  id: "google-drive",
+  name: "Google Drive",
+  description: "Google Drive folder mounted as a filesystem",
+  configSchema: {
+    type: "object",
+    required: ["folderId"],
+    properties: {
+      folderId: { type: "string", description: "Google Drive folder ID to mount as the workspace root" },
+      accessToken: {
+        type: "string",
+        description: "OAuth access token with the https://www.googleapis.com/auth/drive scope"
+      },
+      readOnly: { type: "boolean", description: "Mount as read-only", default: false }
+    }
+  },
+  createFilesystem: (config) => new GoogleDriveFilesystem(config)
+};
+
+exports.GoogleDriveFilesystem = GoogleDriveFilesystem;
+exports.googleDriveFilesystemProvider = googleDriveFilesystemProvider;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map