@digitalpresence/cliclaw 0.1.0

package/src/__tests__/gslides.integration.test.ts

@@ -0,0 +1,195 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { join } from "path";
+import { describe, it, expect } from "vitest";
+
+const execFileAsync = promisify(execFile);
+const CLI = join(import.meta.dirname, "../../dist/cli.js");
+
+interface CliResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+async function run(...args: string[]): Promise<CliResult> {
+  try {
+    const { stdout, stderr } = await execFileAsync("node", [CLI, ...args], {
+      timeout: 30000,
+    });
+    return { stdout, stderr, exitCode: 0 };
+  } catch (err: any) {
+    return {
+      stdout: err.stdout ?? "",
+      stderr: err.stderr ?? "",
+      exitCode: err.code ?? 1,
+    };
+  }
+}
+
+function parseJson(result: CliResult): any {
+  return JSON.parse(result.stdout);
+}
+
+describe.sequential("Google Slides CLI integration", () => {
+  const timestamp = Date.now();
+
+  let presentationId: string;
+  let firstSlideId: string;
+  let addedSlideId: string;
+
+  it("accounts — returns a list of gslides accounts", async () => {
+    const result = await run("gslides", "accounts");
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data).toHaveProperty("accounts");
+    expect(Array.isArray(data.accounts)).toBe(true);
+  });
+
+  it("create — creates a test presentation", async () => {
+    const title = `cliclaw-test-${timestamp}`;
+    const result = await run("gslides", "create", "--title", title);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.presentationId).toBeTruthy();
+    expect(data.title).toBe(title);
+    expect(data.slideCount).toBeGreaterThanOrEqual(1);
+
+    presentationId = data.presentationId;
+  });
+
+  it("list — returns presentations including our test presentation", async () => {
+    const result = await run("gslides", "list", "--max-results", "10");
+    expect(result.exitCode).toBe(0);
+
+    const files = parseJson(result);
+    expect(Array.isArray(files)).toBe(true);
+
+    const ids = files.map((f: any) => f.id);
+    expect(ids).toContain(presentationId);
+  });
+
+  it("get — returns presentation details", async () => {
+    const result = await run("gslides", "get", "--id", presentationId);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.presentationId).toBe(presentationId);
+    expect(data.title).toBe(`cliclaw-test-${timestamp}`);
+    expect(data.slideCount).toBeGreaterThanOrEqual(1);
+    expect(Array.isArray(data.slides)).toBe(true);
+
+    firstSlideId = data.slides[0].objectId;
+  });
+
+  it("get-slide — returns details of the first slide", async () => {
+    const result = await run(
+      "gslides", "get-slide",
+      "--id", presentationId,
+      "--index", "0",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.objectId).toBe(firstSlideId);
+    expect(data.index).toBe(0);
+  });
+
+  it("add-slide — adds a blank slide", async () => {
+    const result = await run(
+      "gslides", "add-slide",
+      "--id", presentationId,
+      "--layout", "BLANK",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.objectId).toBeTruthy();
+
+    addedSlideId = data.objectId;
+  });
+
+  it("add-text — adds a text box to the added slide", async () => {
+    const result = await run(
+      "gslides", "add-text",
+      "--id", presentationId,
+      "--slide-id", addedSlideId,
+      "--text", `Test text ${timestamp}`,
+      "--x", "50",
+      "--y", "50",
+      "--width", "300",
+      "--height", "40",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.objectId).toBeTruthy();
+  });
+
+  it("add-shape — adds a rectangle shape to the added slide", async () => {
+    const result = await run(
+      "gslides", "add-shape",
+      "--id", presentationId,
+      "--slide-id", addedSlideId,
+      "--shape", "RECTANGLE",
+      "--x", "50",
+      "--y", "150",
+      "--width", "200",
+      "--height", "100",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.objectId).toBeTruthy();
+  });
+
+  it("duplicate-slide — duplicates the added slide", async () => {
+    const result = await run(
+      "gslides", "duplicate-slide",
+      "--id", presentationId,
+      "--slide-id", addedSlideId,
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.originalId).toBe(addedSlideId);
+    expect(data.newId).toBeTruthy();
+  });
+
+  it("get — confirms presentation now has more slides", async () => {
+    const result = await run("gslides", "get", "--id", presentationId);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    // Original slide + added slide + duplicated slide = at least 3
+    expect(data.slideCount).toBeGreaterThanOrEqual(3);
+  });
+
+  it("delete-slide — deletes the added slide", async () => {
+    const result = await run(
+      "gslides", "delete-slide",
+      "--id", presentationId,
+      "--slide-id", addedSlideId,
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.objectId).toBe(addedSlideId);
+  });
+
+  it("delete — permanently deletes the test presentation", async () => {
+    const result = await run("gslides", "delete", "--id", presentationId);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.presentationId).toBe(presentationId);
+  });
+});

package/src/__tests__/sheets.integration.test.ts

@@ -0,0 +1,234 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { join } from "path";
+import { describe, it, expect } from "vitest";
+
+const execFileAsync = promisify(execFile);
+const CLI = join(import.meta.dirname, "../../dist/cli.js");
+
+interface CliResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+async function run(...args: string[]): Promise<CliResult> {
+  try {
+    const { stdout, stderr } = await execFileAsync("node", [CLI, ...args], {
+      timeout: 30000,
+    });
+    return { stdout, stderr, exitCode: 0 };
+  } catch (err: any) {
+    return {
+      stdout: err.stdout ?? "",
+      stderr: err.stderr ?? "",
+      exitCode: err.code ?? 1,
+    };
+  }
+}
+
+function parseJson(result: CliResult): any {
+  return JSON.parse(result.stdout);
+}
+
+describe.sequential("Google Sheets CLI integration", () => {
+  const timestamp = Date.now();
+
+  let spreadsheetId: string;
+  let addedSheetId: number;
+
+  it("accounts — returns a list of gsheets accounts", async () => {
+    const result = await run("sheets", "accounts");
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data).toHaveProperty("accounts");
+    expect(Array.isArray(data.accounts)).toBe(true);
+  });
+
+  it("create — creates a test spreadsheet", async () => {
+    const title = `cliclaw-test-${timestamp}`;
+    const result = await run("sheets", "create", "--title", title);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.spreadsheetId).toBeTruthy();
+    expect(data.title).toBe(title);
+
+    spreadsheetId = data.spreadsheetId;
+  });
+
+  it("list — returns spreadsheets including our test spreadsheet", async () => {
+    const result = await run("sheets", "list", "--max-results", "10");
+    expect(result.exitCode).toBe(0);
+
+    const files = parseJson(result);
+    expect(Array.isArray(files)).toBe(true);
+    expect(files.length).toBeGreaterThan(0);
+
+    const ids = files.map((f: any) => f.id);
+    expect(ids).toContain(spreadsheetId);
+  });
+
+  it("get — returns spreadsheet metadata", async () => {
+    const result = await run("sheets", "get", "--id", spreadsheetId);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.spreadsheetId).toBe(spreadsheetId);
+    expect(data.title).toBe(`cliclaw-test-${timestamp}`);
+    expect(Array.isArray(data.sheets)).toBe(true);
+    expect(data.sheets.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("list-sheets — lists sheets/tabs in the spreadsheet", async () => {
+    const result = await run("sheets", "list-sheets", "--id", spreadsheetId);
+    expect(result.exitCode).toBe(0);
+
+    const tabs = parseJson(result);
+    expect(Array.isArray(tabs)).toBe(true);
+    expect(tabs.length).toBeGreaterThanOrEqual(1);
+    expect(tabs[0]).toHaveProperty("sheetId");
+    expect(tabs[0]).toHaveProperty("title");
+  });
+
+  it("add-sheet — adds a new sheet/tab", async () => {
+    const sheetTitle = `TestTab-${timestamp}`;
+    const result = await run("sheets", "add-sheet", "--id", spreadsheetId, "--title", sheetTitle);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.title).toBe(sheetTitle);
+    expect(data.sheetId).toBeTruthy();
+
+    addedSheetId = data.sheetId;
+  });
+
+  it("rename-sheet — renames the added sheet", async () => {
+    const newTitle = `RenamedTab-${timestamp}`;
+    const result = await run(
+      "sheets", "rename-sheet",
+      "--id", spreadsheetId,
+      "--sheet-id", String(addedSheetId),
+      "--title", newTitle,
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.title).toBe(newTitle);
+  });
+
+  it("write — writes values to cells", async () => {
+    const result = await run(
+      "sheets", "write",
+      "--id", spreadsheetId,
+      "--range", "Sheet1!A1:B2",
+      "--values", '[["Name","Score"],["Alice","100"]]',
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.updatedCells).toBe(4);
+  });
+
+  it("read — reads values back from cells", async () => {
+    const result = await run(
+      "sheets", "read",
+      "--id", spreadsheetId,
+      "--range", "Sheet1!A1:B2",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.values).toBeTruthy();
+    expect(data.values.length).toBe(2);
+    expect(data.values[0]).toEqual(["Name", "Score"]);
+    expect(data.values[1]).toEqual(["Alice", "100"]);
+  });
+
+  it("append — appends rows after existing data", async () => {
+    const result = await run(
+      "sheets", "append",
+      "--id", spreadsheetId,
+      "--range", "Sheet1!A1:B1",
+      "--values", '[["Bob","200"]]',
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.updatedRows).toBe(1);
+  });
+
+  it("read — confirms appended data appears", async () => {
+    const result = await run(
+      "sheets", "read",
+      "--id", spreadsheetId,
+      "--range", "Sheet1!A3:B3",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.values).toBeTruthy();
+    expect(data.values[0]).toEqual(["Bob", "200"]);
+  });
+
+  it("clear — clears a range of cells", async () => {
+    const result = await run(
+      "sheets", "clear",
+      "--id", spreadsheetId,
+      "--range", "Sheet1!A1:B3",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+  });
+
+  it("format — applies bold formatting to a range", async () => {
+    // Write some data first
+    await run(
+      "sheets", "write",
+      "--id", spreadsheetId,
+      "--range", "Sheet1!A1",
+      "--values", '[["Header"]]',
+    );
+
+    const result = await run(
+      "sheets", "format",
+      "--id", spreadsheetId,
+      "--range", "A1:A1",
+      "--bold",
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+  });
+
+  it("delete-sheet — deletes the added sheet", async () => {
+    const result = await run(
+      "sheets", "delete-sheet",
+      "--id", spreadsheetId,
+      "--sheet-id", String(addedSheetId),
+    );
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.sheetId).toBe(addedSheetId);
+  });
+
+  it("delete — permanently deletes the test spreadsheet", async () => {
+    const result = await run("sheets", "delete", "--id", spreadsheetId);
+    expect(result.exitCode).toBe(0);
+
+    const data = parseJson(result);
+    expect(data.success).toBe(true);
+    expect(data.spreadsheetId).toBe(spreadsheetId);
+  });
+});

package/src/agent/crud.ts

@@ -0,0 +1,54 @@
+import type { AgentStore } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError } from "../lib/output.js";
+
+export async function handleAgentCreate(
+  store: AgentStore,
+  name: string,
+  displayName: string,
+  role: string,
+): Promise<void> {
+  if (store.get(name)) {
+    outputError("agent_exists", `Agent "${name}" already exists`);
+  }
+
+  const now = new Date().toISOString();
+  store.scaffoldWorkspace({
+    name,
+    displayName,
+    role,
+    permissions: [],
+    memory: [],
+    cronJobs: [],
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  outputJson({ status: "created", name, displayName });
+}
+
+export async function handleAgentList(store: AgentStore): Promise<void> {
+  const agents = store.list();
+  outputJson(
+    agents.map((a) => ({
+      name: a.name,
+      displayName: a.displayName,
+      permissions: a.permissions.length,
+      memory: a.memory.length,
+    })),
+  );
+}
+
+export async function handleAgentShow(store: AgentStore, name: string): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+  outputJson(agent);
+}
+
+export async function handleAgentDelete(store: AgentStore, name: string): Promise<void> {
+  if (!store.delete(name)) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+  outputJson({ status: "deleted", name });
+}

package/src/agent/memory.ts

@@ -0,0 +1,95 @@
+import type { AgentStore } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError } from "../lib/output.js";
+
+export async function handleAgentMemory(
+  store: AgentStore,
+  name: string,
+  opts?: { tag?: string; recent?: number },
+): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+  const memoryStore = store.getMemoryStore(name);
+  const entries = memoryStore.list({ tag: opts?.tag, limit: opts?.recent });
+  outputJson({ name, count: entries.length, memories: entries });
+}
+
+export async function handleAgentMemoryAdd(
+  store: AgentStore,
+  name: string,
+  fact: string,
+  opts?: { tags?: string; source?: string; importance?: string },
+): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+
+  const memoryStore = store.getMemoryStore(name);
+  const tags = opts?.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  const source = (opts?.source as "user" | "agent" | "system") ?? "user";
+  const importance = opts?.importance ? (parseInt(opts.importance, 10) as 1 | 2 | 3) : 2;
+
+  const entry = memoryStore.add(fact, { tags, source, importance });
+  store.regenerateClaudeMd(name);
+
+  outputJson({ status: "added", name, entry });
+}
+
+export async function handleAgentMemoryRemove(
+  store: AgentStore,
+  name: string,
+  id?: string,
+  tag?: string,
+): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+
+  const memoryStore = store.getMemoryStore(name);
+
+  if (tag) {
+    const removed = memoryStore.removeByTag(tag);
+    store.regenerateClaudeMd(name);
+    outputJson({ status: "removed", name, removedByTag: tag, count: removed });
+  } else if (id) {
+    const removed = memoryStore.remove(id);
+    if (!removed) {
+      outputError("memory_not_found", `Memory "${id}" not found`);
+    }
+    store.regenerateClaudeMd(name);
+    outputJson({ status: "removed", name, id });
+  } else {
+    outputError("invalid_args", "Provide an ID or --tag to remove");
+  }
+}
+
+export async function handleAgentMemorySearch(
+  store: AgentStore,
+  name: string,
+  query: string,
+): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+
+  const memoryStore = store.getMemoryStore(name);
+  const results = memoryStore.search(query);
+  outputJson({ name, query, count: results.length, memories: results });
+}
+
+export async function handleAgentMemoryClear(store: AgentStore, name: string): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+
+  const memoryStore = store.getMemoryStore(name);
+  const cleared = memoryStore.clear();
+  store.regenerateClaudeMd(name);
+
+  outputJson({ status: "cleared", name, cleared });
+}

package/src/agent/permissions.ts

@@ -0,0 +1,54 @@
+import type { AgentStore } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputError } from "../lib/output.js";
+
+export async function handleAgentGrant(
+  store: AgentStore,
+  name: string,
+  integration: string,
+  account: string,
+): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+
+  const exists = agent.permissions.some(
+    (p) => p.integration === integration && p.account === account,
+  );
+  if (exists) {
+    outputError("permission_exists", `Agent "${name}" already has ${integration}:${account}`);
+  }
+
+  agent.permissions.push({ integration, account });
+  agent.updatedAt = new Date().toISOString();
+  store.save(agent);
+  store.regenerateClaudeMd(name);
+
+  outputJson({ status: "granted", name, integration, account });
+}
+
+export async function handleAgentRevoke(
+  store: AgentStore,
+  name: string,
+  integration: string,
+  account: string,
+): Promise<void> {
+  const agent = store.get(name);
+  if (!agent) {
+    outputError("agent_not_found", `Agent "${name}" not found`);
+  }
+
+  const idx = agent.permissions.findIndex(
+    (p) => p.integration === integration && p.account === account,
+  );
+  if (idx === -1) {
+    outputError("permission_not_found", `Agent "${name}" does not have ${integration}:${account}`);
+  }
+
+  agent.permissions.splice(idx, 1);
+  agent.updatedAt = new Date().toISOString();
+  store.save(agent);
+  store.regenerateClaudeMd(name);
+
+  outputJson({ status: "revoked", name, integration, account });
+}

package/src/calendar/accounts.ts

@@ -0,0 +1,25 @@
+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 calendarAccounts = allAccounts.filter((a) => a.startsWith("calendar:"));
+
+  const accounts = await Promise.all(
+    calendarAccounts.map(async (tokenKey) => {
+      const account = tokenKey.replace("calendar:", "");
+      try {
+        const client = clientManager.getClient(tokenKey);
+        const calendar = google.calendar({ version: "v3", auth: client });
+        const res = await calendar.calendarList.list({ maxResults: 1 });
+        const primary = res.data.items?.find((c) => c.primary);
+        return { account, email: primary?.id ?? null };
+      } catch {
+        return { account, email: null };
+      }
+    }),
+  );
+
+  outputJson({ accounts });
+}

package/src/calendar/auth.ts

@@ -0,0 +1,45 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { waitForOAuthCallback, getCalendarAuthUrl } 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 = `calendar:${account}`;
+
+  // Check if already authenticated
+  try {
+    const client = clientManager.getClient(tokenKey);
+    const creds = client.credentials;
+    if (creds && (creds.refresh_token || creds.access_token)) {
+      const calendar = google.calendar({ version: "v3", auth: client });
+      const res = await calendar.calendarList.list({ maxResults: 1 });
+      outputJson({
+        status: "already_authenticated",
+        account,
+        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 Calendar authentication...`);
+      console.error(url);
+      open(url).catch(() => {
+        console.error("Could not open browser. Please visit the URL above manually.");
+      });
+    }, getCalendarAuthUrl);
+
+    clientManager.setCredentials(tokenKey, tokens);
+
+    outputJson({ status: "authenticated", account });
+  } catch (err) {
+    outputError("auth_failed", err instanceof Error ? err.message : String(err));
+  }
+}