@digitalpresence/cliclaw 0.1.0

package/src/sheets/format.ts

@@ -0,0 +1,114 @@
+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 });
+}
+
+function hexToColor(hex: string): { red: number; green: number; blue: number } {
+  const h = hex.replace("#", "");
+  return {
+    red: parseInt(h.substring(0, 2), 16) / 255,
+    green: parseInt(h.substring(2, 4), 16) / 255,
+    blue: parseInt(h.substring(4, 6), 16) / 255,
+  };
+}
+
+function parseA1Range(range: string): { sheetId: number; startRow: number; endRow: number; startCol: number; endCol: number } | null {
+  // Simple A1 parser: "Sheet1!A1:D10" or "A1:D10"
+  const match = range.match(/^(?:.*!)?([A-Z]+)(\d+):([A-Z]+)(\d+)$/);
+  if (!match) return null;
+
+  function colToIndex(col: string): number {
+    let idx = 0;
+    for (let i = 0; i < col.length; i++) {
+      idx = idx * 26 + (col.charCodeAt(i) - 64);
+    }
+    return idx - 1;
+  }
+
+  return {
+    sheetId: 0, // Default to first sheet; caller may override
+    startRow: parseInt(match[2]) - 1,
+    endRow: parseInt(match[4]),
+    startCol: colToIndex(match[1]),
+    endCol: colToIndex(match[3]) + 1,
+  };
+}
+
+export async function handleFormat(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  range: string,
+  options: { bold?: boolean; bgColor?: string; textColor?: string; sheetId?: number },
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+
+    const parsed = parseA1Range(range);
+    if (!parsed) {
+      outputError("format_failed", `Could not parse range: ${range}`);
+    }
+
+    if (options.sheetId !== undefined) {
+      parsed!.sheetId = options.sheetId;
+    }
+
+    const cellFormat: Record<string, unknown> = {};
+    const fields: string[] = [];
+
+    if (options.bold !== undefined) {
+      cellFormat.textFormat = { bold: options.bold };
+      fields.push("userEnteredFormat.textFormat.bold");
+    }
+
+    if (options.bgColor) {
+      cellFormat.backgroundColor = hexToColor(options.bgColor);
+      fields.push("userEnteredFormat.backgroundColor");
+    }
+
+    if (options.textColor) {
+      if (cellFormat.textFormat) {
+        (cellFormat.textFormat as Record<string, unknown>).foregroundColor = hexToColor(options.textColor);
+      } else {
+        cellFormat.textFormat = { foregroundColor: hexToColor(options.textColor) };
+      }
+      fields.push("userEnteredFormat.textFormat.foregroundColor");
+    }
+
+    if (fields.length === 0) {
+      outputError("format_failed", "No formatting options specified");
+    }
+
+    await sheets.spreadsheets.batchUpdate({
+      spreadsheetId,
+      requestBody: {
+        requests: [{
+          repeatCell: {
+            range: {
+              sheetId: parsed!.sheetId,
+              startRowIndex: parsed!.startRow,
+              endRowIndex: parsed!.endRow,
+              startColumnIndex: parsed!.startCol,
+              endColumnIndex: parsed!.endCol,
+            },
+            cell: { userEnteredFormat: cellFormat },
+            fields: fields.join(","),
+          },
+        }],
+      },
+    });
+
+    outputJson({ success: true, range, formatting: options });
+  } catch (err) {
+    if ((err as Error).message?.includes("format_failed")) throw err;
+    outputError("format_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/sheets/sheets-tab.ts

@@ -0,0 +1,109 @@
+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 handleListSheets(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.get({
+      spreadsheetId,
+      fields: "sheets(properties)",
+    });
+    const tabList = res.data.sheets?.map((s) => ({
+      sheetId: s.properties?.sheetId,
+      title: s.properties?.title,
+      index: s.properties?.index,
+    })) ?? [];
+    outputJson(tabList);
+  } catch (err) {
+    outputError("list_sheets_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleAddSheet(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  title: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.batchUpdate({
+      spreadsheetId,
+      requestBody: {
+        requests: [{ addSheet: { properties: { title } } }],
+      },
+    });
+    const reply = res.data.replies?.[0]?.addSheet?.properties;
+    outputJson({
+      success: true,
+      sheetId: reply?.sheetId,
+      title: reply?.title,
+      index: reply?.index,
+    });
+  } catch (err) {
+    outputError("add_sheet_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDeleteSheet(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  sheetId: number,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    await sheets.spreadsheets.batchUpdate({
+      spreadsheetId,
+      requestBody: {
+        requests: [{ deleteSheet: { sheetId } }],
+      },
+    });
+    outputJson({ success: true, sheetId });
+  } catch (err) {
+    outputError("delete_sheet_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleRenameSheet(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+  sheetId: number,
+  title: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    await sheets.spreadsheets.batchUpdate({
+      spreadsheetId,
+      requestBody: {
+        requests: [{
+          updateSheetProperties: {
+            properties: { sheetId, title },
+            fields: "title",
+          },
+        }],
+      },
+    });
+    outputJson({ success: true, sheetId, title });
+  } catch (err) {
+    outputError("rename_sheet_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/sheets/spreadsheets.ts

@@ -0,0 +1,106 @@
+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 });
+}
+
+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 = `gsheets:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.files.list({
+      q: "mimeType='application/vnd.google-apps.spreadsheet' 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 handleCreate(
+  clientManager: OAuthClientManager,
+  account: string,
+  title: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.create({
+      requestBody: {
+        properties: { title },
+      },
+      fields: "spreadsheetId,spreadsheetUrl,properties",
+    });
+    outputJson({
+      success: true,
+      spreadsheetId: res.data.spreadsheetId,
+      url: res.data.spreadsheetUrl,
+      title: res.data.properties?.title,
+    });
+  } catch (err) {
+    outputError("create_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleGet(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const sheets = getSheets(clientManager, tokenKey);
+    const res = await sheets.spreadsheets.get({
+      spreadsheetId,
+      fields: "spreadsheetId,spreadsheetUrl,properties,sheets(properties)",
+    });
+    outputJson({
+      spreadsheetId: res.data.spreadsheetId,
+      url: res.data.spreadsheetUrl,
+      title: res.data.properties?.title,
+      locale: res.data.properties?.locale,
+      sheets: res.data.sheets?.map((s) => ({
+        sheetId: s.properties?.sheetId,
+        title: s.properties?.title,
+        index: s.properties?.index,
+        rowCount: s.properties?.gridProperties?.rowCount,
+        columnCount: s.properties?.gridProperties?.columnCount,
+      })),
+    });
+  } catch (err) {
+    outputError("get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDelete(
+  clientManager: OAuthClientManager,
+  account: string,
+  spreadsheetId: string,
+): Promise<void> {
+  const tokenKey = `gsheets:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    await drive.files.delete({ fileId: spreadsheetId });
+    outputJson({ success: true, spreadsheetId });
+  } catch (err) {
+    outputError("delete_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    testTimeout: 30000,
+  },
+});