@digitalpresence/cliclaw 0.1.0

package/src/gslides/presentations.ts

@@ -0,0 +1,384 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+function getSlides(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+    outputAuthRequired("gslides");
+  }
+  return google.slides({ version: "v1", auth: client });
+}
+
+function getDrive(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  return google.drive({ version: "v3", auth: client });
+}
+
+export async function handleList(
+  clientManager: OAuthClientManager,
+  account: string,
+  maxResults: number,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.files.list({
+      q: "mimeType='application/vnd.google-apps.presentation' and trashed = false",
+      pageSize: maxResults,
+      fields: "files(id, name, modifiedTime, 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,
+  presentationId: string,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const res = await slides.presentations.get({ presentationId });
+    const data = res.data;
+    outputJson({
+      presentationId: data.presentationId,
+      title: data.title,
+      locale: data.locale,
+      slideCount: data.slides?.length ?? 0,
+      slides: data.slides?.map((s, i) => ({
+        index: i,
+        objectId: s.objectId,
+        elementCount: s.pageElements?.length ?? 0,
+      })),
+    });
+  } catch (err) {
+    outputError("get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleCreate(
+  clientManager: OAuthClientManager,
+  account: string,
+  title: string,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const res = await slides.presentations.create({
+      requestBody: { title },
+    });
+    outputJson({
+      presentationId: res.data.presentationId,
+      title: res.data.title,
+      slideCount: res.data.slides?.length ?? 0,
+    });
+  } catch (err) {
+    outputError("create_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDelete(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    await drive.files.delete({ fileId: presentationId });
+    outputJson({ success: true, presentationId });
+  } catch (err) {
+    outputError("delete_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleGetSlide(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  slideIndex: number,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const res = await slides.presentations.get({ presentationId });
+    const allSlides = res.data.slides ?? [];
+    if (slideIndex < 0 || slideIndex >= allSlides.length) {
+      outputError("invalid_index", `Slide index ${slideIndex} out of range (0-${allSlides.length - 1})`);
+    }
+    const slide = allSlides[slideIndex];
+    outputJson({
+      objectId: slide.objectId,
+      index: slideIndex,
+      elements: slide.pageElements?.map((el) => ({
+        objectId: el.objectId,
+        type: el.shape ? "shape" : el.image ? "image" : el.table ? "table" : el.video ? "video" : "other",
+        title: el.title,
+        description: el.description,
+        size: el.size,
+        transform: el.transform,
+        text: el.shape?.text?.textElements?.map((te) => te.textRun?.content).filter(Boolean).join("") ?? null,
+      })),
+    });
+  } catch (err) {
+    if ((err as Error).message?.includes("out of range")) throw err;
+    outputError("get_slide_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleAddSlide(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  layout?: string,
+  insertionIndex?: number,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const objectId = `slide_${Date.now()}`;
+    const request: any = {
+      objectId,
+    };
+    if (layout) {
+      request.slideLayoutReference = { predefinedLayout: layout };
+    }
+    if (insertionIndex !== undefined) {
+      request.insertionIndex = insertionIndex;
+    }
+    await slides.presentations.batchUpdate({
+      presentationId,
+      requestBody: {
+        requests: [{ createSlide: request }],
+      },
+    });
+    outputJson({ success: true, objectId });
+  } catch (err) {
+    outputError("add_slide_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDeleteSlide(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  slideObjectId: string,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    await slides.presentations.batchUpdate({
+      presentationId,
+      requestBody: {
+        requests: [{ deleteObject: { objectId: slideObjectId } }],
+      },
+    });
+    outputJson({ success: true, objectId: slideObjectId });
+  } catch (err) {
+    outputError("delete_slide_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleAddText(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  slideObjectId: string,
+  text: string,
+  opts: { x?: number; y?: number; width?: number; height?: number; fontSize?: number },
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const boxId = `textbox_${Date.now()}`;
+    const x = opts.x ?? 100;
+    const y = opts.y ?? 100;
+    const width = opts.width ?? 400;
+    const height = opts.height ?? 50;
+
+    const requests: any[] = [
+      {
+        createShape: {
+          objectId: boxId,
+          shapeType: "TEXT_BOX",
+          elementProperties: {
+            pageObjectId: slideObjectId,
+            size: {
+              width: { magnitude: width, unit: "PT" },
+              height: { magnitude: height, unit: "PT" },
+            },
+            transform: {
+              scaleX: 1,
+              scaleY: 1,
+              translateX: x,
+              translateY: y,
+              unit: "PT",
+            },
+          },
+        },
+      },
+      {
+        insertText: {
+          objectId: boxId,
+          text,
+          insertionIndex: 0,
+        },
+      },
+    ];
+
+    if (opts.fontSize) {
+      requests.push({
+        updateTextStyle: {
+          objectId: boxId,
+          style: {
+            fontSize: { magnitude: opts.fontSize, unit: "PT" },
+          },
+          textRange: { type: "ALL" },
+          fields: "fontSize",
+        },
+      });
+    }
+
+    await slides.presentations.batchUpdate({
+      presentationId,
+      requestBody: { requests },
+    });
+    outputJson({ success: true, objectId: boxId });
+  } catch (err) {
+    outputError("add_text_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleAddImage(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  slideObjectId: string,
+  imageUrl: string,
+  opts: { x?: number; y?: number; width?: number; height?: number },
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const imgId = `image_${Date.now()}`;
+    const x = opts.x ?? 100;
+    const y = opts.y ?? 100;
+    const width = opts.width ?? 300;
+    const height = opts.height ?? 200;
+
+    await slides.presentations.batchUpdate({
+      presentationId,
+      requestBody: {
+        requests: [
+          {
+            createImage: {
+              objectId: imgId,
+              url: imageUrl,
+              elementProperties: {
+                pageObjectId: slideObjectId,
+                size: {
+                  width: { magnitude: width, unit: "PT" },
+                  height: { magnitude: height, unit: "PT" },
+                },
+                transform: {
+                  scaleX: 1,
+                  scaleY: 1,
+                  translateX: x,
+                  translateY: y,
+                  unit: "PT",
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+    outputJson({ success: true, objectId: imgId });
+  } catch (err) {
+    outputError("add_image_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleAddShape(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  slideObjectId: string,
+  shapeType: string,
+  opts: { x?: number; y?: number; width?: number; height?: number },
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const shapeId = `shape_${Date.now()}`;
+    const x = opts.x ?? 100;
+    const y = opts.y ?? 100;
+    const width = opts.width ?? 200;
+    const height = opts.height ?? 200;
+
+    await slides.presentations.batchUpdate({
+      presentationId,
+      requestBody: {
+        requests: [
+          {
+            createShape: {
+              objectId: shapeId,
+              shapeType: shapeType,
+              elementProperties: {
+                pageObjectId: slideObjectId,
+                size: {
+                  width: { magnitude: width, unit: "PT" },
+                  height: { magnitude: height, unit: "PT" },
+                },
+                transform: {
+                  scaleX: 1,
+                  scaleY: 1,
+                  translateX: x,
+                  translateY: y,
+                  unit: "PT",
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+    outputJson({ success: true, objectId: shapeId });
+  } catch (err) {
+    outputError("add_shape_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDuplicateSlide(
+  clientManager: OAuthClientManager,
+  account: string,
+  presentationId: string,
+  slideObjectId: string,
+): Promise<void> {
+  const tokenKey = `gslides:${account}`;
+  try {
+    const slides = getSlides(clientManager, tokenKey);
+    const newId = `slide_dup_${Date.now()}`;
+    await slides.presentations.batchUpdate({
+      presentationId,
+      requestBody: {
+        requests: [
+          {
+            duplicateObject: {
+              objectId: slideObjectId,
+              objectIds: { [slideObjectId]: newId },
+            },
+          },
+        ],
+      },
+    });
+    outputJson({ success: true, originalId: slideObjectId, newId });
+  } catch (err) {
+    outputError("duplicate_slide_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/lib/config.ts

@@ -0,0 +1,14 @@
+import { loadConfig as loadConfigBase, getConfigDir, getTokensPath } from "@digitalpresence/cliclaw-auth";
+import type { CliclawConfig } from "@digitalpresence/cliclaw-auth";
+
+export type { CliclawConfig };
+export { getConfigDir, getTokensPath };
+
+export function loadConfig(): CliclawConfig {
+  try {
+    return loadConfigBase();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}

package/src/lib/media-utils.ts

@@ -0,0 +1,82 @@
+import { existsSync, mkdirSync } from "fs";
+
+export function ensureDir(dir: string): void {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function mimeToExt(mime: string): string {
+  const map: Record<string, string> = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/svg+xml": ".svg",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tiff",
+    "application/pdf": ".pdf",
+    "video/mp4": ".mp4",
+    "video/webm": ".webm",
+    "video/quicktime": ".mov",
+    "audio/mpeg": ".mp3",
+    "audio/wav": ".wav",
+    "audio/ogg": ".ogg",
+    "application/msword": ".doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.ms-powerpoint": ".ppt",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "application/zip": ".zip",
+    "application/gzip": ".gz",
+    "text/plain": ".txt",
+    "text/csv": ".csv",
+    "text/html": ".html",
+    "application/json": ".json",
+    "application/xml": ".xml",
+    "application/octet-stream": ".bin",
+  };
+  return map[mime] ?? ".bin";
+}
+
+export function extToMime(ext: string): string {
+  const map: Record<string, string> = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".tiff": "image/tiff",
+    ".pdf": "application/pdf",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".zip": "application/zip",
+    ".gz": "application/gzip",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".html": "text/html",
+    ".json": "application/json",
+    ".xml": "application/xml",
+  };
+  return map[ext.toLowerCase()] ?? "application/octet-stream";
+}
+
+export function sanitizeFilename(name: string): string {
+  return name
+    .replace(/[<>:"/\\|?*\x00-\x1f]/g, "_")
+    .replace(/_{2,}/g, "_")
+    .slice(0, 200);
+}

package/src/lib/output.ts

@@ -0,0 +1,13 @@
+export function outputJson(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function outputError(error: string, message?: string): never {
+  console.log(JSON.stringify({ error, message: message ?? error }));
+  process.exit(1);
+}
+
+export function outputAuthRequired(integration: string = "gmail"): never {
+  console.log(JSON.stringify({ error: "auth_required", action: `Run: cliclaw ${integration} auth` }));
+  process.exit(1);
+}

package/src/sheets/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 gsheetsAccounts = allAccounts.filter((a) => a.startsWith("gsheets:"));
+
+  const accounts = await Promise.all(
+    gsheetsAccounts.map(async (tokenKey) => {
+      const account = tokenKey.replace("gsheets:", "");
+      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/sheets/auth.ts

@@ -0,0 +1,60 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { waitForOAuthCallback, getGSheetsAuthUrl } 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 = `gsheets:${account}`;
+
+  try {
+    const client = clientManager.getClient(tokenKey);
+    const creds = client.credentials;
+    if (creds && (creds.refresh_token || creds.access_token)) {
+      const sheets = google.sheets({ version: "v4", auth: client });
+      // Validate by getting a simple response
+      await sheets.spreadsheets.create({
+        requestBody: { properties: { title: "__auth_check__" } },
+      }).then(() => {}).catch(() => {});
+      // Actually just check drive about for email
+      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 Sheets authentication...`);
+      console.error(url);
+      open(url).catch(() => {
+        console.error("Could not open browser. Please visit the URL above manually.");
+      });
+    }, getGSheetsAuthUrl);
+
+    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/sheets/cells.ts

@@ -0,0 +1,112 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError, outputAuthRequired } from "../lib/output.js";
+
+function getSheets(clientManager: OAuthClientManager, tokenKey: string) {
+  const client = clientManager.getClient(tokenKey);
+  if (!client.credentials?.access_token && !client.credentials?.refresh_token) {
+    outputAuthRequired("sheets");
+  }
+  return google.sheets({ version: "v4", auth: client });
+}
+
+export async function handleRead(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  range: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.values.get({
+      spreadsheetId,
+      range,
+    });
+    outputJson({
+      range: res.data.range,
+      values: res.data.values ?? [],
+    });
+  } catch (err) {
+    outputError("read_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleWrite(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  range: string,
+  values: string[][],
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.values.update({
+      spreadsheetId,
+      range,
+      valueInputOption: "USER_ENTERED",
+      requestBody: { values },
+    });
+    outputJson({
+      success: true,
+      updatedRange: res.data.updatedRange,
+      updatedRows: res.data.updatedRows,
+      updatedColumns: res.data.updatedColumns,
+      updatedCells: res.data.updatedCells,
+    });
+  } catch (err) {
+    outputError("write_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleAppend(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  range: string,
+  values: string[][],
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.values.append({
+      spreadsheetId,
+      range,
+      valueInputOption: "USER_ENTERED",
+      requestBody: { values },
+    });
+    outputJson({
+      success: true,
+      updatedRange: res.data.updates?.updatedRange,
+      updatedRows: res.data.updates?.updatedRows,
+      updatedColumns: res.data.updates?.updatedColumns,
+      updatedCells: res.data.updates?.updatedCells,
+    });
+  } catch (err) {
+    outputError("append_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleClear(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  range: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.values.clear({
+      spreadsheetId,
+      range,
+      requestBody: {},
+    });
+    outputJson({
+      success: true,
+      clearedRange: res.data.clearedRange,
+    });
+  } catch (err) {
+    outputError("clear_failed", err instanceof Error ? err.message : String(err));
+  }
+}