@digitalpresence/cliclaw 0.1.0

package/src/cron/progress.ts

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { getAgentsDir } from "@digitalpresence/cliclaw-auth";
+import type { TranscriptBlock } from "./ralph-wiggum.js";
+
+export interface CronRunLog {
+  jobId: string;
+  agentName: string;
+  startedAt: string;
+  finishedAt: string;
+  iterations: number;
+  completed: boolean;
+  totalCostUsd: number;
+  error?: string;
+  transcript?: TranscriptBlock[];
+}
+
+export function getCronDir(agentName: string, jobId: string): string {
+  return join(getAgentsDir(), agentName, "cron", jobId);
+}
+
+export function getProgressFilePath(agentName: string, jobId: string): string {
+  return join(getCronDir(agentName, jobId), "progress.md");
+}
+
+export function ensureCronDirs(agentName: string, jobId: string): void {
+  const cronDir = getCronDir(agentName, jobId);
+  const runsDir = join(cronDir, "runs");
+  if (!existsSync(runsDir)) {
+    mkdirSync(runsDir, { recursive: true });
+  }
+}
+
+export function writeRunLog(agentName: string, jobId: string, log: CronRunLog): void {
+  ensureCronDirs(agentName, jobId);
+  const runsDir = join(getCronDir(agentName, jobId), "runs");
+  const filename = `${log.startedAt.replace(/[:.]/g, "-")}.json`;
+  writeFileSync(join(runsDir, filename), JSON.stringify(log, null, 2), "utf-8");
+}
+
+export interface RunningMarker {
+  startedAt: string;
+  pid: number;
+}
+
+export function writeRunningMarker(agentName: string, jobId: string, startedAt: string): void {
+  ensureCronDirs(agentName, jobId);
+  const marker: RunningMarker = { startedAt, pid: process.pid };
+  writeFileSync(join(getCronDir(agentName, jobId), "running.json"), JSON.stringify(marker), "utf-8");
+}
+
+export function clearRunningMarker(agentName: string, jobId: string): void {
+  const path = join(getCronDir(agentName, jobId), "running.json");
+  if (existsSync(path)) unlinkSync(path);
+}
+
+export function getRunningMarker(agentName: string, jobId: string): RunningMarker | null {
+  const path = join(getCronDir(agentName, jobId), "running.json");
+  if (!existsSync(path)) return null;
+  try {
+    const marker = JSON.parse(readFileSync(path, "utf-8")) as RunningMarker;
+    // Verify the process is still alive
+    try {
+      process.kill(marker.pid, 0);
+      return marker;
+    } catch {
+      // Process is dead — stale marker, clean up
+      unlinkSync(path);
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+export function listRunLogs(agentName: string, jobId: string): CronRunLog[] {
+  const runsDir = join(getCronDir(agentName, jobId), "runs");
+  if (!existsSync(runsDir)) return [];
+  return readdirSync(runsDir)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      try {
+        return JSON.parse(readFileSync(join(runsDir, f), "utf-8")) as CronRunLog;
+      } catch {
+        return null;
+      }
+    })
+    .filter((l): l is CronRunLog => l !== null);
+}

package/src/cron/ralph-wiggum.ts

@@ -0,0 +1,172 @@
+import { query, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, realpathSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import type { AgentStore, CronJobConfig } from "@digitalpresence/cliclaw-auth";
+import { getProgressFilePath, ensureCronDirs, writeRunningMarker, clearRunningMarker } from "./progress.js";
+import { cronLog } from "./logger.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CONTINUE_MARKER = "NEEDS_MORE_ITERATIONS";
+
+export type TranscriptBlock =
+  | { type: "assistant"; content: string }
+  | { type: "tool"; name: string; input?: string; done: boolean };
+
+export interface RalphWiggumResult {
+  completed: boolean;
+  iterations: number;
+  totalCostUsd: number;
+  transcript: TranscriptBlock[];
+}
+
+export async function executeRalphWiggumLoop(
+  store: AgentStore,
+  agentName: string,
+  job: CronJobConfig,
+  startedAt?: string,
+): Promise<RalphWiggumResult> {
+  ensureCronDirs(agentName, job.id);
+  writeRunningMarker(agentName, job.id, startedAt ?? new Date().toISOString());
+
+  const workspacePath = store.workspacePath(agentName);
+  const progressFile = getProgressFilePath(agentName, job.id);
+
+  try {
+    // Ensure cliclaw CLI is in PATH
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+
+    const monorepoRoot = join(__dirname, "..", "..", "..");
+    const binScript = join(monorepoRoot, "packages", "cliclaw", "dist", "cli.js");
+    if (existsSync(binScript)) {
+      const resolvedBin = realpathSync(binScript);
+      const localBin = join(workspacePath, ".bin");
+      if (!existsSync(localBin)) mkdirSync(localBin, { recursive: true });
+      const wrapper = join(localBin, "cliclaw");
+      writeFileSync(wrapper, `#!/bin/sh\nexec node "${resolvedBin}" "$@"\n`, { mode: 0o755 });
+      cleanEnv.PATH = `${localBin}:${cleanEnv.PATH ?? ""}`;
+    }
+
+    let totalCostUsd = 0;
+    let sessionId: string | undefined;
+    const transcript: TranscriptBlock[] = [];
+
+    for (let iteration = 1; iteration <= job.maxIterations; iteration++) {
+      cronLog("info", `Iteration ${iteration}/${job.maxIterations}`, agentName, job.id);
+
+      // Clear the continue marker before each iteration
+      if (existsSync(progressFile)) {
+        const content = readFileSync(progressFile, "utf-8");
+        if (content.includes(CONTINUE_MARKER)) {
+          writeFileSync(progressFile, content.replace(CONTINUE_MARKER, "").trim() + "\n", "utf-8");
+        }
+      }
+
+      let prompt: string;
+      if (iteration === 1) {
+        prompt = [
+          `You are executing a scheduled task. Here are your instructions:`,
+          ``,
+          `${job.task}`,
+          ``,
+          `Write your output/progress to: ${progressFile}`,
+          ``,
+          `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in ${progressFile}. Otherwise, just complete the task normally — no special signal is needed.`,
+        ].join("\n");
+      } else {
+        prompt = [
+          `You are continuing a scheduled task. Read your progress file at: ${progressFile}`,
+          `Continue from where you left off.`,
+          ``,
+          `Original task: ${job.task}`,
+          ``,
+          `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in ${progressFile}. Otherwise, just complete the task normally — no special signal is needed.`,
+        ].join("\n");
+      }
+
+      const conversation = query({
+        prompt,
+        options: {
+          cwd: workspacePath,
+          env: cleanEnv,
+          systemPrompt: { type: "preset" as const, preset: "claude_code" as const },
+          settingSources: ["project"],
+          includePartialMessages: true,
+          allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+          ...(sessionId ? { resume: sessionId } : {}),
+        },
+      });
+
+      let currentToolInput = "";
+
+      for await (const event of conversation) {
+        const msg = event as SDKMessage;
+
+        if (msg.type === "stream_event" && (msg as any).event) {
+          const streamEvent = (msg as any).event as {
+            type: string;
+            content_block?: { type: string; name?: string; id?: string };
+            delta?: { type: string; text?: string; partial_json?: string };
+          };
+
+          if (streamEvent.type === "content_block_start" && streamEvent.content_block?.type === "tool_use") {
+            transcript.push({ type: "tool", name: streamEvent.content_block.name ?? "unknown", done: false });
+            currentToolInput = "";
+          } else if (streamEvent.type === "content_block_delta") {
+            if (streamEvent.delta?.type === "text_delta" && streamEvent.delta.text) {
+              const last = transcript[transcript.length - 1];
+              if (last?.type === "assistant") {
+                last.content += streamEvent.delta.text;
+              } else {
+                transcript.push({ type: "assistant", content: streamEvent.delta.text });
+              }
+            } else if (streamEvent.delta?.type === "input_json_delta" && streamEvent.delta.partial_json) {
+              currentToolInput += streamEvent.delta.partial_json;
+            }
+          } else if (streamEvent.type === "content_block_stop" && currentToolInput) {
+            const lastTool = [...transcript].reverse().find((b) => b.type === "tool" && !b.done);
+            if (lastTool && lastTool.type === "tool") {
+              try {
+                lastTool.input = JSON.stringify(JSON.parse(currentToolInput));
+              } catch {
+                // incomplete JSON
+              }
+            }
+            currentToolInput = "";
+          }
+        } else if ((msg as any).type === "tool_result") {
+          const lastTool = [...transcript].reverse().find((b) => b.type === "tool" && !b.done);
+          if (lastTool && lastTool.type === "tool") {
+            lastTool.done = true;
+          }
+        } else if (msg.type === "result") {
+          if ("total_cost_usd" in msg) {
+            totalCostUsd += (msg.total_cost_usd as number) ?? 0;
+          }
+          if (msg.session_id) {
+            sessionId = msg.session_id;
+          }
+        }
+      }
+
+      // Check if the agent needs more iterations by reading the progress file
+      const needsMore = existsSync(progressFile) &&
+        readFileSync(progressFile, "utf-8").includes(CONTINUE_MARKER);
+
+      if (!needsMore) {
+        cronLog("info", `Task completed at iteration ${iteration}`, agentName, job.id);
+        return { completed: true, iterations: iteration, totalCostUsd, transcript };
+      }
+
+      cronLog("info", `Agent requested continuation (${CONTINUE_MARKER} found in progress file)`, agentName, job.id);
+    }
+
+    cronLog("warn", `Max iterations (${job.maxIterations}) reached`, agentName, job.id);
+    return { completed: false, iterations: job.maxIterations, totalCostUsd, transcript };
+  } finally {
+    clearRunningMarker(agentName, job.id);
+  }
+}

package/src/forms/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 formsAccounts = allAccounts.filter((a) => a.startsWith("forms:"));
+
+  const accounts = await Promise.all(
+    formsAccounts.map(async (tokenKey) => {
+      const account = tokenKey.replace("forms:", "");
+      try {
+        const client = clientManager.getClient(tokenKey);
+        const oauth2 = google.oauth2({ version: "v2", auth: client });
+        const res = await oauth2.userinfo.get();
+        return { account, email: res.data.email ?? null };
+      } catch {
+        return { account, email: null };
+      }
+    }),
+  );
+
+  outputJson({ accounts });
+}

package/src/forms/auth.ts

@@ -0,0 +1,45 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { waitForOAuthCallback, getFormsAuthUrl } 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 = `forms:${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 });
+      await drive.files.list({ pageSize: 1, q: "mimeType='application/vnd.google-apps.form'" });
+      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 Forms authentication...`);
+      console.error(url);
+      open(url).catch(() => {
+        console.error("Could not open browser. Please visit the URL above manually.");
+      });
+    }, getFormsAuthUrl);
+
+    clientManager.setCredentials(tokenKey, tokens);
+
+    outputJson({ status: "authenticated", account });
+  } catch (err) {
+    outputError("auth_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/forms/create.ts

@@ -0,0 +1,34 @@
+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 handleCreateForm(
+  clientManager: OAuthClientManager,
+  account: string,
+  title: string,
+  documentTitle?: string,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+    const res = await forms.forms.create({
+      requestBody: {
+        info: {
+          title,
+          documentTitle: documentTitle ?? title,
+        },
+      },
+    });
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("create_form_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/forms/get.ts

@@ -0,0 +1,26 @@
+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 handleGetForm(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+    const res = await forms.forms.get({ formId });
+    outputJson(res.data);
+  } catch (err) {
+    outputError("get_form_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/forms/list.ts

@@ -0,0 +1,38 @@
+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("forms");
+  }
+  return google.drive({ version: "v3", auth: client });
+}
+
+export async function handleList(
+  clientManager: OAuthClientManager,
+  account: string,
+  maxResults: number,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const drive = getDrive(clientManager, tokenKey);
+    const res = await drive.files.list({
+      pageSize: maxResults,
+      q: "mimeType='application/vnd.google-apps.form' and trashed=false",
+      fields: "files(id,name,createdTime,modifiedTime,webViewLink)",
+      orderBy: "modifiedTime desc",
+    });
+    const forms = (res.data.files ?? []).map((f) => ({
+      id: f.id,
+      name: f.name,
+      createdTime: f.createdTime,
+      modifiedTime: f.modifiedTime,
+      webViewLink: f.webViewLink,
+    }));
+    outputJson(forms);
+  } catch (err) {
+    outputError("list_forms_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/forms/questions.ts

@@ -0,0 +1,209 @@
+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 handleQuestions(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+    const res = await forms.forms.get({ formId });
+    const items = res.data.items ?? [];
+    const questions = items
+      .filter((item) => item.questionItem)
+      .map((item) => ({
+        itemId: item.itemId,
+        title: item.title,
+        description: item.description,
+        questionId: item.questionItem?.question?.questionId,
+        required: item.questionItem?.question?.required ?? false,
+        type: getQuestionType(item.questionItem?.question),
+      }));
+    outputJson(questions);
+  } catch (err) {
+    outputError("questions_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+function getQuestionType(question: unknown): string {
+  if (!question || typeof question !== "object") return "unknown";
+  const q = question as Record<string, unknown>;
+  if (q.choiceQuestion) return "choice";
+  if (q.textQuestion) return "text";
+  if (q.scaleQuestion) return "scale";
+  if (q.dateQuestion) return "date";
+  if (q.timeQuestion) return "time";
+  if (q.fileUploadQuestion) return "fileUpload";
+  return "unknown";
+}
+
+export async function handleAddQuestion(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+  title: string,
+  type: string,
+  required: boolean,
+  options?: string[],
+  index?: number,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+
+    const question: Record<string, unknown> = { required };
+
+    switch (type) {
+      case "text":
+        question.textQuestion = { paragraph: false };
+        break;
+      case "paragraph":
+        question.textQuestion = { paragraph: true };
+        break;
+      case "choice":
+        question.choiceQuestion = {
+          type: "RADIO",
+          options: (options ?? ["Option 1"]).map((o) => ({ value: o })),
+        };
+        break;
+      case "checkbox":
+        question.choiceQuestion = {
+          type: "CHECKBOX",
+          options: (options ?? ["Option 1"]).map((o) => ({ value: o })),
+        };
+        break;
+      case "dropdown":
+        question.choiceQuestion = {
+          type: "DROP_DOWN",
+          options: (options ?? ["Option 1"]).map((o) => ({ value: o })),
+        };
+        break;
+      case "scale":
+        question.scaleQuestion = { low: 1, high: 5 };
+        break;
+      case "date":
+        question.dateQuestion = {};
+        break;
+      case "time":
+        question.timeQuestion = {};
+        break;
+      default:
+        question.textQuestion = { paragraph: false };
+    }
+
+    const res = await forms.forms.batchUpdate({
+      formId,
+      requestBody: {
+        requests: [
+          {
+            createItem: {
+              item: {
+                title,
+                questionItem: { question },
+              },
+              location: { index: index ?? 0 },
+            },
+          },
+        ],
+      },
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("add_question_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleUpdateQuestion(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+  itemIndex: number,
+  title?: string,
+  required?: boolean,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+
+    // First get the current form to find the item
+    const current = await forms.forms.get({ formId });
+    const items = current.data.items ?? [];
+    if (itemIndex >= items.length) {
+      outputError("update_question_failed", `Item index ${itemIndex} out of range (form has ${items.length} items)`);
+    }
+
+    const item = items[itemIndex];
+    const updateMasks: string[] = [];
+
+    if (title !== undefined) {
+      item.title = title;
+      updateMasks.push("title");
+    }
+    if (required !== undefined && item.questionItem?.question) {
+      item.questionItem.question.required = required;
+      updateMasks.push("questionItem.question.required");
+    }
+
+    if (updateMasks.length === 0) {
+      outputError("update_question_failed", "No fields to update.");
+    }
+
+    const res = await forms.forms.batchUpdate({
+      formId,
+      requestBody: {
+        requests: [
+          {
+            updateItem: {
+              item,
+              location: { index: itemIndex },
+              updateMask: updateMasks.join(","),
+            },
+          },
+        ],
+      },
+    });
+
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("update_question_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDeleteQuestion(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+  itemIndex: number,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+    const res = await forms.forms.batchUpdate({
+      formId,
+      requestBody: {
+        requests: [
+          {
+            deleteItem: {
+              location: { index: itemIndex },
+            },
+          },
+        ],
+      },
+    });
+    outputJson({ success: true, ...res.data });
+  } catch (err) {
+    outputError("delete_question_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/src/forms/responses.ts

@@ -0,0 +1,50 @@
+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 handleResponses(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+    const res = await forms.forms.responses.list({ formId });
+    const responses = (res.data.responses ?? []).map((r) => ({
+      responseId: r.responseId,
+      createTime: r.createTime,
+      lastSubmittedTime: r.lastSubmittedTime,
+      respondentEmail: r.respondentEmail,
+      totalScore: r.totalScore,
+      answers: r.answers,
+    }));
+    outputJson(responses);
+  } catch (err) {
+    outputError("responses_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleGetResponse(
+  clientManager: OAuthClientManager,
+  account: string,
+  formId: string,
+  responseId: string,
+): Promise<void> {
+  const tokenKey = `forms:${account}`;
+  try {
+    const forms = getForms(clientManager, tokenKey);
+    const res = await forms.forms.responses.get({ formId, responseId });
+    outputJson(res.data);
+  } catch (err) {
+    outputError("get_response_failed", err instanceof Error ? err.message : String(err));
+  }
+}