@digitalpresence/cliclaw 0.1.0

package/src/forms/update.ts

@@ -0,0 +1,57 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+function getForms(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+    outputAuthRequired("forms");
+  }
+  return google.forms({ version: "v1", auth: client });
+}
+
+export async function handleUpdateForm(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+  title?: string,
+  description?: string,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+
+    const requests: Array<Record<string, unknown>> = [];
+
+    if (title) {
+      requests.push({
+        updateFormInfo: {
+          info: { title },
+          updateMask: "title",
+        },
+      });
+    }
+
+    if (description) {
+      requests.push({
+        updateFormInfo: {
+          info: { description },
+          updateMask: "description",
+        },
+      });
+    }
+
+    if (requests.length === 0) {
+      outputError("update_form_failed", "No fields to update. Provide --title or --description.");
+    }
+
+    const res = await forms.forms.batchUpdate({
+      formId,
+      requestBody: { requests },
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("update_form_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gdrive/about.ts

@@ -0,0 +1,36 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+export async function handleAbout(
+  clientManager: OAuthClientManager,
+  account: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const client = clientManager.getClient(tokenKey);
+    if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+      outputAuthRequired("gdrive");
+    }
+    const drive = google.drive({ version: "v3", auth: client });
+
+    const res = await drive.about.get({
+      fields: "user, storageQuota",
+    });
+
+    const quota = res.data.storageQuota;
+    outputJson({
+      user: res.data.user,
+      storageQuota: quota
+        ? {
+            limit: quota.limit ? `${(Number(quota.limit) / 1e9).toFixed(2)} GB` : "unlimited",
+            usage: `${(Number(quota.usage ?? 0) / 1e9).toFixed(2)} GB`,
+            usageInDrive: `${(Number(quota.usageInDrive ?? 0) / 1e9).toFixed(2)} GB`,
+            usageInDriveTrash: `${(Number(quota.usageInDriveTrash ?? 0) / 1e9).toFixed(2)} GB`,
+          }
+        : null,
+    });
+  } catch (err) {
+    outputError("about_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gdrive/accounts.ts

@@ -0,0 +1,24 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson } from "../lib/output.js";
+
+export async function handleAccounts(clientManager: OAuthClientManager): Promise<void> {
+  const allAccounts = clientManager.listAccounts();
+  const gdriveAccounts = allAccounts.filter((a) => a.startsWith("gdrive:"));
+
+  const accounts = await Promise.all(
+    gdriveAccounts.map(async (tokenKey) => {
+      const account = tokenKey.replace("gdrive:", "");
+      try {
+        const client = clientManager.getClient(tokenKey);
+        const drive = google.drive({ version: "v3", auth: client });
+        const about = await drive.about.get({ fields: "user" });
+        return { account, email: about.data.user?.emailAddress ?? null };
+      } catch {
+        return { account, email: null };
+      }
+    }),
+  );
+
+  outputJson({ accounts });
+}

package/src/gdrive/auth.ts

@@ -0,0 +1,55 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { waitForOAuthCallback, getGDriveAuthUrl } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError } from "../lib/output.js";
+
+export async function handleAuth(clientManager: OAuthClientManager, port: number, account: string): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+
+  // Check if already authenticated
+  try {
+    const client = clientManager.getClient(tokenKey);
+    const creds = client.credentials;
+    if (creds && (creds.refresh_token || creds.access_token)) {
+      const drive = google.drive({ version: "v3", auth: client });
+      const about = await drive.about.get({ fields: "user" });
+      outputJson({
+        status: "already_authenticated",
+        account,
+        email: about.data.user?.emailAddress ?? "unknown",
+        message: "Existing session is still valid. No re-authentication needed.",
+      });
+      return;
+    }
+  } catch {
+    // Tokens invalid — proceed with re-auth
+  }
+
+  try {
+    const open = (await import("open")).default;
+    const rawClient = clientManager.getRawClient();
+
+    const tokens = await waitForOAuthCallback(rawClient, port, (url) => {
+      console.error(`Opening browser for Google Drive authentication...`);
+      console.error(url);
+      open(url).catch(() => {
+        console.error("Could not open browser. Please visit the URL above manually.");
+      });
+    }, getGDriveAuthUrl);
+
+    const client = clientManager.setCredentials(tokenKey, tokens);
+
+    const drive = google.drive({ version: "v3", auth: client });
+    let email = "unknown";
+    try {
+      const about = await drive.about.get({ fields: "user" });
+      email = about.data.user?.emailAddress ?? "unknown";
+    } catch {
+      // Non-fatal
+    }
+
+    outputJson({ status: "authenticated", account, email });
+  } catch (err) {
+    outputError("auth_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gdrive/files.ts

@@ -0,0 +1,237 @@
+import { google } from "googleapis";
+import { createReadStream, createWriteStream, statSync } from "fs";
+import { basename, join } from "path";
+import { lookup } from "mime-types";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+function getDrive(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+    outputAuthRequired("gdrive");
+  }
+  return google.drive({ version: "v3", auth: client });
+}
+
+export async function handleList(
+  clientManager: OAuthClientManager,
+  account: string,
+  maxResults: number,
+  query?: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const q = query ? query : "trashed = false";
+    const res = await drive.files.list({
+      q,
+      pageSize: maxResults,
+      fields: "files(id, name, mimeType, size, modifiedTime, parents, webViewLink)",
+      orderBy: "modifiedTime desc",
+    });
+    outputJson(res.data.files ?? []);
+  } catch (err) {
+    outputError("list_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleGet(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.files.get({
+      fileId,
+      fields: "id, name, mimeType, size, modifiedTime, createdTime, parents, webViewLink, description, starred, trashed, owners, permissions",
+    });
+    outputJson(res.data);
+  } catch (err) {
+    outputError("get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDownload(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+  saveDir: string,
+  filename?: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+
+    // Get file metadata for name
+    const meta = await drive.files.get({ fileId, fields: "name, mimeType" });
+    const saveName = filename ?? meta.data.name ?? fileId;
+    const savePath = join(saveDir, saveName);
+
+    const res = await drive.files.get(
+      { fileId, alt: "media" },
+      { responseType: "stream" },
+    );
+
+    await new Promise<void>((resolve, reject) => {
+      const dest = createWriteStream(savePath);
+      (res.data as NodeJS.ReadableStream)
+        .pipe(dest)
+        .on("finish", resolve)
+        .on("error", reject);
+    });
+
+    outputJson({ success: true, path: savePath, name: saveName });
+  } catch (err) {
+    outputError("download_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleUpload(
+  clientManager: OAuthClientManager,
+  account: string,
+  filePath: string,
+  name?: string,
+  parentId?: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const fileName = name ?? basename(filePath);
+    const mimeType = lookup(filePath) || "application/octet-stream";
+
+    const fileMetadata: { name: string; parents?: string[] } = { name: fileName };
+    if (parentId) fileMetadata.parents = [parentId];
+
+    const res = await drive.files.create({
+      requestBody: fileMetadata,
+      media: {
+        mimeType,
+        body: createReadStream(filePath),
+      },
+      fields: "id, name, mimeType, size, webViewLink",
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("upload_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDelete(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    await drive.files.delete({ fileId });
+    outputJson({ success: true, fileId });
+  } catch (err) {
+    outputError("delete_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleTrash(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    await drive.files.update({ fileId, requestBody: { trashed: true } });
+    outputJson({ success: true, fileId, action: "trash" });
+  } catch (err) {
+    outputError("trash_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleUntrash(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    await drive.files.update({ fileId, requestBody: { trashed: false } });
+    outputJson({ success: true, fileId, action: "untrash" });
+  } catch (err) {
+    outputError("untrash_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleMove(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+  newParentId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+
+    // Get current parents
+    const file = await drive.files.get({ fileId, fields: "parents" });
+    const previousParents = (file.data.parents ?? []).join(",");
+
+    const res = await drive.files.update({
+      fileId,
+      addParents: newParentId,
+      removeParents: previousParents,
+      fields: "id, name, parents",
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("move_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleCopy(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+  name?: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const requestBody: { name?: string } = {};
+    if (name) requestBody.name = name;
+
+    const res = await drive.files.copy({
+      fileId,
+      requestBody,
+      fields: "id, name, mimeType, size, webViewLink",
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("copy_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleRename(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+  name: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.files.update({
+      fileId,
+      requestBody: { name },
+      fields: "id, name, mimeType",
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("rename_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gdrive/folders.ts

@@ -0,0 +1,58 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+function getDrive(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+    outputAuthRequired("gdrive");
+  }
+  return google.drive({ version: "v3", auth: client });
+}
+
+export async function handleMkdir(
+  clientManager: OAuthClientManager,
+  account: string,
+  name: string,
+  parentId?: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const fileMetadata: { name: string; mimeType: string; parents?: string[] } = {
+      name,
+      mimeType: "application/vnd.google-apps.folder",
+    };
+    if (parentId) fileMetadata.parents = [parentId];
+
+    const res = await drive.files.create({
+      requestBody: fileMetadata,
+      fields: "id, name, mimeType, webViewLink",
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("mkdir_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleListFolder(
+  clientManager: OAuthClientManager,
+  account: string,
+  folderId: string,
+  maxResults: number,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.files.list({
+      q: `'${folderId}' in parents and trashed = false`,
+      pageSize: maxResults,
+      fields: "files(id, name, mimeType, size, modifiedTime, webViewLink)",
+      orderBy: "folder,name",
+    });
+    outputJson(res.data.files ?? []);
+  } catch (err) {
+    outputError("list_folder_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gdrive/search.ts

@@ -0,0 +1,30 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+export async function handleSearch(
+  clientManager: OAuthClientManager,
+  account: string,
+  query: string,
+  maxResults: number,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const client = clientManager.getClient(tokenKey);
+    if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+      outputAuthRequired("gdrive");
+    }
+    const drive = google.drive({ version: "v3", auth: client });
+
+    const res = await drive.files.list({
+      q: `fullText contains '${query.replace(/'/g, "\\'")}' and trashed = false`,
+      pageSize: maxResults,
+      fields: "files(id, name, mimeType, size, modifiedTime, parents, webViewLink)",
+      orderBy: "modifiedTime desc",
+    });
+
+    outputJson(res.data.files ?? []);
+  } catch (err) {
+    outputError("search_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gdrive/sharing.ts

@@ -0,0 +1,72 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+function getDrive(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+    outputAuthRequired("gdrive");
+  }
+  return google.drive({ version: "v3", auth: client });
+}
+
+export async function handleShare(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+  email: string,
+  role: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.permissions.create({
+      fileId,
+      requestBody: {
+        type: "user",
+        role,
+        emailAddress: email,
+      },
+      fields: "id, type, role, emailAddress",
+    });
+
+    outputJson({ success: true, fileId, permission: res.data });
+  } catch (err) {
+    outputError("share_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleUnshare(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+  permissionId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    await drive.permissions.delete({ fileId, permissionId });
+    outputJson({ success: true, fileId, permissionId });
+  } catch (err) {
+    outputError("unshare_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handlePermissions(
+  clientManager: OAuthClientManager,
+  account: string,
+  fileId: string,
+): Promise<void> {
+  const tokenKey = `gdrive:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.permissions.list({
+      fileId,
+      fields: "permissions(id, type, role, emailAddress, displayName)",
+    });
+
+    outputJson({ fileId, permissions: res.data.permissions ?? [] });
+  } catch (err) {
+    outputError("permissions_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/gmail/accounts.ts

@@ -0,0 +1,22 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson } from "../lib/output.js";
+
+export async function handleAccounts(clientManager: OAuthClientManager): Promise<void> {
+  const accountNames = clientManager.listAccounts();
+
+  const accounts = await Promise.all(
+    accountNames.map(async (account) => {
+      try {
+        const client = clientManager.getClient(account);
+        const gmail = google.gmail({ version: "v1", auth: client });
+        const res = await gmail.users.getProfile({ userId: "me" });
+        return { account, email: res.data.emailAddress ?? null };
+      } catch {
+        return { account, email: null };
+      }
+    }),
+  );
+
+  outputJson({ accounts });
+}

package/src/gmail/auth.ts

@@ -0,0 +1,53 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { waitForOAuthCallback } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError } from "../lib/output.js";
+
+export async function handleAuth(clientManager: OAuthClientManager, port: number, account: string): Promise<void> {
+  // Check if already authenticated
+  try {
+    const client = clientManager.getClient(account);
+    const creds = client.credentials;
+    if (creds && (creds.refresh_token || creds.access_token)) {
+      const oauth2 = google.oauth2({ version: "v2", auth: client });
+      const info = await oauth2.userinfo.get();
+      outputJson({
+        status: "already_authenticated",
+        account,
+        email: info.data.email ?? "unknown",
+        message: "Existing session is still valid. No re-authentication needed.",
+      });
+      return;
+    }
+  } catch {
+    // Tokens invalid — proceed with re-auth
+  }
+
+  try {
+    const open = (await import("open")).default;
+    const rawClient = clientManager.getRawClient();
+
+    const tokens = await waitForOAuthCallback(rawClient, port, (url) => {
+      console.error(`Opening browser for authentication...`);
+      console.error(url);
+      open(url).catch(() => {
+        console.error("Could not open browser. Please visit the URL above manually.");
+      });
+    });
+
+    const client = clientManager.setCredentials(account, tokens);
+
+    const oauth2 = google.oauth2({ version: "v2", auth: client });
+    let email = "unknown";
+    try {
+      const info = await oauth2.userinfo.get();
+      email = info.data.email ?? "unknown";
+    } catch {
+      // Non-fatal
+    }
+
+    outputJson({ status: "authenticated", account, email });
+  } catch (err) {
+    outputError("auth_failed", err instanceof Error ? err.message : String(err));
+  }
+}