@digitalpresence/cliclaw 0.2.1 → 0.3.0

package/src/cron/ralph-wiggum.ts

@@ -3,6 +3,7 @@ import { createInterface } from "readline";
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
 import { join } from "path";
 import type { AgentStore, CronJobConfig } from "@digitalpresence/cliclaw-auth";
+import { generateUniversalClaudeMd, generateContextMd } from "@digitalpresence/cliclaw-auth";
 import { getProgressFilePath, ensureCronDirs, writeRunningMarker, clearRunningMarker } from "./progress.js";
 import { cronLog } from "./logger.js";
 
@@ -18,9 +19,18 @@ export interface RalphWiggumResult {
   completed: boolean;
   iterations: number;
   totalCostUsd: number;
+  report?: string;
   transcript: TranscriptBlock[];
 }
 
+function readReport(instancePath: string): string | undefined {
+  const reportPath = join(instancePath, "workspace", "REPORT.md");
+  if (existsSync(reportPath)) {
+    return readFileSync(reportPath, "utf-8").trim() || undefined;
+  }
+  return undefined;
+}
+
 function loadTaskContent(store: AgentStore, agentName: string, job: CronJobConfig): string {
   const taskFilePath = join(store.workspacePath(agentName), "cron-tasks", job.taskFile);
   if (existsSync(taskFilePath)) {
@@ -45,18 +55,39 @@ async function runContainerIteration(
     "utf-8",
   );
 
+  // Ensure persistent Claude state directory for session resumption
+  const claudeStatePath = join(instancePath, ".claude-state");
+  if (!existsSync(claudeStatePath)) {
+    mkdirSync(claudeStatePath, { recursive: true });
+  }
+
+  // Mount cliclaw config if available (portal injects this for Google OAuth)
+  const cliclawConfigPath = join(instancePath, ".cliclaw-config");
+
   const args = [
     "run", "--rm", "-i",
     "-v", `${instancePath}:/instance`,
+    "-v", `${claudeStatePath}:/home/agent/.claude`,
+    ...(existsSync(cliclawConfigPath)
+      ? ["-v", `${cliclawConfigPath}:/home/agent/.cliclaw`]
+      : []),
     "--network=host",
     "--cpus=2", "--memory=2g",
   ];
 
-  // Pass API key
-  if (process.env.ANTHROPIC_API_KEY) {
+  // Pass auth env vars
+  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+    args.push("-e", `CLAUDE_CODE_OAUTH_TOKEN=${process.env.CLAUDE_CODE_OAUTH_TOKEN}`);
+  } else if (process.env.ANTHROPIC_API_KEY) {
     args.push("-e", `ANTHROPIC_API_KEY=${process.env.ANTHROPIC_API_KEY}`);
   }
 
+  // Pass tokens path if set (portal injects this for client integrations)
+  if (process.env.CLICLAW_TOKENS_PATH) {
+    const containerTokensPath = process.env.CLICLAW_TOKENS_PATH.replace(instancePath, "/instance");
+    args.push("-e", `CLICLAW_TOKENS_PATH=${containerTokensPath}`);
+  }
+
   args.push(CONTAINER_IMAGE);
 
   return new Promise((resolve) => {
@@ -109,20 +140,21 @@ export async function executeRalphWiggumLoop(
   const instancesDir = join(store.workspacePath(agentName), "..", "..", "instances");
   const cronInstancePath = join(instancesDir, agentName, "_cron");
 
-  // Ensure cron instance exists with necessary files
-  if (!existsSync(cronInstancePath)) {
-    mkdirSync(join(cronInstancePath, "workspace"), { recursive: true });
-    mkdirSync(join(cronInstancePath, "memory"), { recursive: true });
-
-    // Copy template files
-    const agentDir = store.workspacePath(agentName);
-    for (const file of ["SOUL.md", "ROLE.md"]) {
-      const src = join(agentDir, file);
-      if (existsSync(src)) {
-        writeFileSync(join(cronInstancePath, file), readFileSync(src, "utf-8"));
-      }
-    }
-  }
+  // Ensure cron instance exists with unified CLAUDE.md
+  mkdirSync(join(cronInstancePath, "workspace"), { recursive: true });
+  mkdirSync(join(cronInstancePath, "memory"), { recursive: true });
+
+  // Generate unified CLAUDE.md with soul/role/context inlined
+  const config = store.get(agentName)!;
+  const agentDir = store.workspacePath(agentName);
+  const soul = existsSync(join(agentDir, "SOUL.md")) ? readFileSync(join(agentDir, "SOUL.md"), "utf-8") : "";
+  const role = existsSync(join(agentDir, "ROLE.md")) ? readFileSync(join(agentDir, "ROLE.md"), "utf-8") : "";
+  const context = generateContextMd(config, []);
+  writeFileSync(
+    join(cronInstancePath, "CLAUDE.md"),
+    generateUniversalClaudeMd({ soul, role, context }),
+    "utf-8",
+  );
 
   const progressFile = getProgressFilePath(agentName, job.id);
   const taskContent = loadTaskContent(store, agentName, job);
@@ -150,7 +182,9 @@ export async function executeRalphWiggumLoop(
           ``,
           taskContent,
           ``,
-          `Write your output/progress to: /instance/workspace/progress.md`,
+          `You MUST write two files:`,
+          `1. /instance/workspace/progress.md — working notes and intermediate state`,
+          `2. /instance/workspace/REPORT.md — a clean, final summary of what you did and found (this is shown to the user)`,
           ``,
           `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in the progress file. Otherwise, just complete the task normally — no special signal is needed.`,
         ].join("\n");
@@ -162,6 +196,10 @@ export async function executeRalphWiggumLoop(
           `Original task:`,
           taskContent,
           ``,
+          `You MUST write two files:`,
+          `1. /instance/workspace/progress.md — working notes and intermediate state`,
+          `2. /instance/workspace/REPORT.md — a clean, final summary of what you did and found (this is shown to the user)`,
+          ``,
           `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in the progress file. Otherwise, just complete the task normally — no special signal is needed.`,
         ].join("\n");
       }
@@ -199,7 +237,19 @@ export async function executeRalphWiggumLoop(
             }
             currentToolInput = "";
           }
-        } else if (event.type === "tool_result") {
+        } else if (event.type === "assistant" && event.message?.content) {
+          // Full assistant message — extract text blocks
+          for (const block of event.message.content) {
+            if (block.type === "text" && block.text) {
+              const last = transcript[transcript.length - 1];
+              if (last?.type === "assistant") {
+                last.content = block.text; // Replace with full text
+              } else {
+                transcript.push({ type: "assistant", content: block.text });
+              }
+            }
+          }
+        } else if (event.type === "tool_result" || event.type === "tool_use_summary") {
           const lastTool = [...transcript].reverse().find((b) => b.type === "tool" && !b.done);
           if (lastTool && lastTool.type === "tool") {
             lastTool.done = true;
@@ -226,14 +276,16 @@ export async function executeRalphWiggumLoop(
 
       if (!needsMore && !needsMoreOriginal) {
         cronLog("info", `Task completed at iteration ${iteration}`, agentName, job.id);
-        return { completed: true, iterations: iteration, totalCostUsd, transcript };
+        const report = readReport(cronInstancePath);
+        return { completed: true, iterations: iteration, totalCostUsd, report, 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 };
+    const report = readReport(cronInstancePath);
+    return { completed: false, iterations: job.maxIterations, totalCostUsd, report, transcript };
   } finally {
     clearRunningMarker(agentName, job.id);
   }

package/src/github/api.ts

@@ -0,0 +1,73 @@
+import { TokenStore } from "@digitalpresence/cliclaw-auth";
+import { outputAuthRequired, outputError } from "../lib/output.js";
+
+const GITHUB_API = "https://api.github.com";
+
+export function getToken(tokenStore: TokenStore, account: string): string {
+  const tokenKey = `github:${account}`;
+  const creds = tokenStore.get(tokenKey);
+  if (!creds?.access_token) {
+    outputAuthRequired("github");
+  }
+  return creds.access_token as string;
+}
+
+export async function githubFetch(
+  token: string,
+  path: string,
+  options: RequestInit = {},
+): Promise<unknown> {
+  const url = path.startsWith("http") ? path : `${GITHUB_API}${path}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...options.headers,
+    },
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    outputError("github_api_error", `${res.status} ${res.statusText}: ${body}`);
+  }
+
+  return res.json();
+}
+
+export async function githubFetchPaginated(
+  token: string,
+  path: string,
+  maxResults: number,
+): Promise<unknown[]> {
+  const results: unknown[] = [];
+  const separator = path.includes("?") ? "&" : "?";
+  let url: string | null = `${path}${separator}per_page=${Math.min(maxResults, 100)}`;
+
+  while (url && results.length < maxResults) {
+    const fullUrl: string = url.startsWith("http") ? url : `${GITHUB_API}${url}`;
+    const res: Response = await fetch(fullUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+    });
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      outputError("github_api_error", `${res.status} ${res.statusText}: ${body}`);
+    }
+
+    const data = await res.json();
+    results.push(...(Array.isArray(data) ? data : [data]));
+
+    // Parse Link header for next page
+    const link: string | null = res.headers.get("link");
+    const next: RegExpMatchArray | null | undefined = link?.match(/<([^>]+)>;\s*rel="next"/);
+    url = next ? next[1] : null;
+  }
+
+  return results.slice(0, maxResults);
+}

package/src/github/handlers.ts

@@ -0,0 +1,325 @@
+import type { TokenStore } from "@digitalpresence/cliclaw-auth";
+import { getToken, githubFetch, githubFetchPaginated } from "./api.js";
+import { outputJson, outputError } from "../lib/output.js";
+
+// --- User ---
+
+export async function handleWhoami(tokenStore: TokenStore, account: string): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const user = await githubFetch(token, "/user");
+    outputJson(user);
+  } catch (err) {
+    outputError("whoami_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Repos ---
+
+export async function handleRepos(
+  tokenStore: TokenStore,
+  account: string,
+  maxResults: number,
+  type: string,
+  sort: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const repos = await githubFetchPaginated(
+      token,
+      `/user/repos?type=${type}&sort=${sort}`,
+      maxResults,
+    );
+    outputJson(repos);
+  } catch (err) {
+    outputError("repos_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleRepoGet(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const data = await githubFetch(token, `/repos/${owner}/${repo}`);
+    outputJson(data);
+  } catch (err) {
+    outputError("repo_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Issues ---
+
+export async function handleIssues(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  state: string,
+  maxResults: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const issues = await githubFetchPaginated(
+      token,
+      `/repos/${owner}/${repo}/issues?state=${state}`,
+      maxResults,
+    );
+    outputJson(issues);
+  } catch (err) {
+    outputError("issues_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleIssueGet(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  number: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const issue = await githubFetch(token, `/repos/${owner}/${repo}/issues/${number}`);
+    outputJson(issue);
+  } catch (err) {
+    outputError("issue_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleIssueCreate(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  title: string,
+  body?: string,
+  labels?: string[],
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const payload: Record<string, unknown> = { title };
+    if (body) payload.body = body;
+    if (labels?.length) payload.labels = labels;
+    const issue = await githubFetch(token, `/repos/${owner}/${repo}/issues`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    outputJson(issue);
+  } catch (err) {
+    outputError("issue_create_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleIssueComment(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  number: number,
+  body: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const comment = await githubFetch(
+      token,
+      `/repos/${owner}/${repo}/issues/${number}/comments`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ body }),
+      },
+    );
+    outputJson(comment);
+  } catch (err) {
+    outputError("issue_comment_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleIssueClose(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  number: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const issue = await githubFetch(token, `/repos/${owner}/${repo}/issues/${number}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ state: "closed" }),
+    });
+    outputJson(issue);
+  } catch (err) {
+    outputError("issue_close_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Pull Requests ---
+
+export async function handlePulls(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  state: string,
+  maxResults: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const prs = await githubFetchPaginated(
+      token,
+      `/repos/${owner}/${repo}/pulls?state=${state}`,
+      maxResults,
+    );
+    outputJson(prs);
+  } catch (err) {
+    outputError("pulls_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handlePullGet(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  number: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const pr = await githubFetch(token, `/repos/${owner}/${repo}/pulls/${number}`);
+    outputJson(pr);
+  } catch (err) {
+    outputError("pull_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handlePullReviews(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  number: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const reviews = await githubFetch(
+      token,
+      `/repos/${owner}/${repo}/pulls/${number}/reviews`,
+    );
+    outputJson(reviews);
+  } catch (err) {
+    outputError("pull_reviews_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handlePullMerge(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  number: number,
+  method: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await githubFetch(
+      token,
+      `/repos/${owner}/${repo}/pulls/${number}/merge`,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ merge_method: method }),
+      },
+    );
+    outputJson(result);
+  } catch (err) {
+    outputError("pull_merge_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Notifications ---
+
+export async function handleNotifications(
+  tokenStore: TokenStore,
+  account: string,
+  maxResults: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const notifications = await githubFetchPaginated(
+      token,
+      "/notifications",
+      maxResults,
+    );
+    outputJson(notifications);
+  } catch (err) {
+    outputError("notifications_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Search ---
+
+export async function handleSearch(
+  tokenStore: TokenStore,
+  account: string,
+  query: string,
+  type: string,
+  maxResults: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const data = await githubFetch(
+      token,
+      `/search/${type}?q=${encodeURIComponent(query)}&per_page=${Math.min(maxResults, 100)}`,
+    );
+    outputJson(data);
+  } catch (err) {
+    outputError("search_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Actions ---
+
+export async function handleWorkflowRuns(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  maxResults: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const data = await githubFetch(
+      token,
+      `/repos/${owner}/${repo}/actions/runs?per_page=${Math.min(maxResults, 100)}`,
+    );
+    outputJson(data);
+  } catch (err) {
+    outputError("workflow_runs_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleWorkflowRunLogs(
+  tokenStore: TokenStore,
+  account: string,
+  owner: string,
+  repo: string,
+  runId: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const jobs = await githubFetch(
+      token,
+      `/repos/${owner}/${repo}/actions/runs/${runId}/jobs`,
+    );
+    outputJson(jobs);
+  } catch (err) {
+    outputError("workflow_logs_failed", err instanceof Error ? err.message : String(err));
+  }
+}

package/.turbo/turbo-dev.log

@@ -1,7 +0,0 @@
-
-> @digitalpresence/cliclaw@0.1.0 dev /Users/markshteyn/emdash-projects/worktrees/dark-doodles-rest-8y8/packages/cliclaw
-> tsx src/cli.ts
-
-sh: tsx: command not found
- ELIFECYCLE  Command failed.
- WARN   Local package.json exists, but node_modules missing, did you mean to install?