the-campfire 0.1.0

package/server/usage-limits.ts

@@ -0,0 +1,192 @@
+import { execSync, execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export interface UsageLimits {
+  five_hour: { utilization: number; resets_at: string | null } | null;
+  seven_day: { utilization: number; resets_at: string | null } | null;
+  extra_usage: {
+    is_enabled: boolean;
+    monthly_limit: number;
+    used_credits: number;
+    utilization: number | null;
+  } | null;
+}
+
+const OAUTH_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+// In-memory cache (60s TTL)
+const CACHE_DURATION_MS = 60 * 1000;
+let cache: { data: UsageLimits; timestamp: number } | null = null;
+
+interface OAuthCredentials {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+  [key: string]: unknown;
+}
+
+function readRawCredentials(): { raw: string; parsed: Record<string, unknown>; oauth: OAuthCredentials } | null {
+  try {
+    if (process.platform === "win32") {
+      const home =
+        process.env.USERPROFILE || process.env.HOME || homedir() || "";
+      const credPath = join(home, ".claude", ".credentials.json");
+      if (!existsSync(credPath)) return null;
+      const raw = readFileSync(credPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed?.claudeAiOauth?.accessToken) return null;
+      return { raw, parsed, oauth: parsed.claudeAiOauth };
+    }
+
+    const raw = execSync(
+      'security find-generic-password -s "Claude Code-credentials" -w',
+      { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+    ).trim();
+
+    const decoded = raw.startsWith("{")
+      ? raw
+      : Buffer.from(raw, "hex").toString("utf-8");
+
+    const parsed = JSON.parse(decoded);
+    if (!parsed?.claudeAiOauth?.accessToken) return null;
+    return { raw: decoded, parsed, oauth: parsed.claudeAiOauth };
+  } catch {
+    return null;
+  }
+}
+
+function writeCredentials(creds: Record<string, unknown>): void {
+  try {
+    const json = JSON.stringify(creds);
+    if (process.platform === "win32") {
+      const home =
+        process.env.USERPROFILE || process.env.HOME || homedir() || "";
+      const credPath = join(home, ".claude", ".credentials.json");
+      require("node:fs").writeFileSync(credPath, json, "utf-8");
+    } else {
+      execFileSync(
+        "security",
+        ["add-generic-password", "-U", "-s", "Claude Code-credentials", "-a", "Claude Code", "-w", json],
+        { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+      );
+    }
+  } catch {
+    // best-effort
+  }
+}
+
+async function refreshAccessToken(refreshToken: string): Promise<{
+  accessToken: string;
+  refreshToken: string;
+  expiresIn: number;
+} | null> {
+  try {
+    const res = await fetch(OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: OAUTH_CLIENT_ID,
+      }),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresIn: data.expires_in,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function getCredentials(): string | null {
+  const creds = readRawCredentials();
+  return creds?.oauth.accessToken ?? null;
+}
+
+async function getValidAccessToken(): Promise<string | null> {
+  const creds = readRawCredentials();
+  if (!creds) return null;
+
+  const { oauth } = creds;
+
+  // Token still valid (with 5min buffer)
+  if (oauth.expiresAt && Date.now() < oauth.expiresAt - 5 * 60 * 1000) {
+    return oauth.accessToken;
+  }
+
+  // Token expired — try to refresh
+  if (!oauth.refreshToken) return null;
+
+  const refreshed = await refreshAccessToken(oauth.refreshToken);
+  if (!refreshed) return null;
+
+  // Update stored credentials
+  creds.parsed.claudeAiOauth = {
+    ...oauth,
+    accessToken: refreshed.accessToken,
+    refreshToken: refreshed.refreshToken,
+    expiresAt: Date.now() + refreshed.expiresIn * 1000,
+  };
+  writeCredentials(creds.parsed);
+
+  return refreshed.accessToken;
+}
+
+export async function fetchUsageLimits(
+  token: string,
+): Promise<UsageLimits | null> {
+  try {
+    const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "claude-code/2.1.39",
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20",
+      },
+    });
+
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    return {
+      five_hour: data.five_hour || null,
+      seven_day: data.seven_day || null,
+      extra_usage: data.extra_usage || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function getUsageLimits(): Promise<UsageLimits> {
+  const empty: UsageLimits = {
+    five_hour: null,
+    seven_day: null,
+    extra_usage: null,
+  };
+  try {
+    if (cache && Date.now() - cache.timestamp < CACHE_DURATION_MS) {
+      return cache.data;
+    }
+
+    const token = await getValidAccessToken();
+    if (!token) return empty;
+
+    const limits = await fetchUsageLimits(token);
+    if (!limits) return empty;
+
+    cache = { data: limits, timestamp: Date.now() };
+    return limits;
+  } catch {
+    return empty;
+  }
+}

package/server/webhook-manager.ts

@@ -0,0 +1,228 @@
+import { createHmac } from "node:crypto";
+import * as webhookStore from "./webhook-store.js";
+import type { WebhookConfig, WebhookEvent, WebhookPayload } from "./webhook-types.js";
+
+export class WebhookManager {
+  // Cost thresholds to emit cost.threshold events (in USD)
+  private costThresholds = [0.50, 1.00, 2.00, 5.00, 10.00];
+  // Track which thresholds have been crossed per session to avoid re-emitting
+  private crossedThresholds = new Map<string, Set<number>>();
+
+  emit(event: WebhookEvent, sessionId: string, data: Record<string, unknown>): void {
+    // Load all webhooks, find matching ones, deliver asynchronously (fire-and-forget)
+    const webhooks = webhookStore.listWebhooks();
+    for (const webhook of webhooks) {
+      if (!webhook.enabled) continue;
+      if (!webhook.events.includes(event)) continue;
+      if (!this.matchesFilter(webhook, sessionId, data)) continue;
+
+      const payload: WebhookPayload = {
+        event,
+        timestamp: Date.now(),
+        sessionId,
+        data,
+      };
+
+      // Fire and forget — don't block the caller
+      this.deliver(webhook, payload).catch((err) => {
+        console.error(`[webhook-manager] Delivery failed for webhook ${webhook.id}:`, err);
+      });
+    }
+  }
+
+  /** Check cost thresholds and emit cost.threshold if crossed */
+  checkCostThreshold(sessionId: string, totalCostUsd: number): void {
+    if (!this.crossedThresholds.has(sessionId)) {
+      this.crossedThresholds.set(sessionId, new Set());
+    }
+    const crossed = this.crossedThresholds.get(sessionId)!;
+    for (const threshold of this.costThresholds) {
+      if (totalCostUsd >= threshold && !crossed.has(threshold)) {
+        crossed.add(threshold);
+        this.emit("cost.threshold", sessionId, {
+          threshold,
+          totalCostUsd,
+        });
+      }
+    }
+  }
+
+  /** Clean up threshold tracking when session ends */
+  clearSession(sessionId: string): void {
+    this.crossedThresholds.delete(sessionId);
+  }
+
+  private async deliver(webhook: WebhookConfig, payload: WebhookPayload, attempt = 1): Promise<void> {
+    const format = webhook.format || "generic";
+    let body: string;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "User-Agent": "Campfire-Webhook/1.0",
+      "X-Campfire-Event": payload.event,
+      "X-Campfire-Delivery": `${webhook.id}-${Date.now()}`,
+    };
+
+    if (format === "slack") {
+      body = JSON.stringify(
+        WebhookManager.formatSlackPayload(payload.event, payload.sessionId, payload.data),
+      );
+    } else if (format === "openclaw") {
+      body = JSON.stringify(
+        WebhookManager.formatOpenClawPayload(payload.event, payload.sessionId, payload.data),
+      );
+      // OpenClaw uses Bearer token auth — use the webhook secret as the token
+      if (webhook.secret) {
+        headers["Authorization"] = `Bearer ${webhook.secret}`;
+      }
+    } else {
+      body = JSON.stringify(payload);
+    }
+
+    // HMAC-SHA256 signing if secret is configured (not used for openclaw format which uses Bearer)
+    if (webhook.secret && format !== "openclaw") {
+      headers["X-Campfire-Signature"] = this.sign(body, webhook.secret);
+    }
+
+    try {
+      const res = await fetch(webhook.url, {
+        method: "POST",
+        headers,
+        body,
+        signal: AbortSignal.timeout(10_000),
+      });
+
+      const success = res.ok;
+      webhookStore.updateWebhook(webhook.id, {
+        totalDeliveries: webhook.totalDeliveries + 1,
+        failedDeliveries: success ? webhook.failedDeliveries : webhook.failedDeliveries + 1,
+        lastDeliveryAt: Date.now(),
+        lastDeliverySuccess: success,
+      });
+
+      if (!success && attempt < 3) {
+        // Retry with exponential backoff: 1s, 5s, 15s
+        const delays = [1000, 5000, 15000];
+        const delay = delays[attempt - 1] || 15000;
+        console.log(`[webhook-manager] Webhook ${webhook.id} returned ${res.status}, retrying in ${delay}ms (attempt ${attempt + 1}/3)`);
+        await new Promise((r) => setTimeout(r, delay));
+        await this.deliver(webhook, payload, attempt + 1);
+      }
+    } catch (err) {
+      webhookStore.updateWebhook(webhook.id, {
+        totalDeliveries: webhook.totalDeliveries + 1,
+        failedDeliveries: webhook.failedDeliveries + 1,
+        lastDeliveryAt: Date.now(),
+        lastDeliverySuccess: false,
+      });
+
+      if (attempt < 3) {
+        const delays = [1000, 5000, 15000];
+        const delay = delays[attempt - 1] || 15000;
+        console.log(`[webhook-manager] Webhook ${webhook.id} delivery error, retrying in ${delay}ms (attempt ${attempt + 1}/3):`, err);
+        await new Promise((r) => setTimeout(r, delay));
+        await this.deliver(webhook, payload, attempt + 1);
+      }
+    }
+  }
+
+  private sign(payload: string, secret: string): string {
+    return "sha256=" + createHmac("sha256", secret).update(payload).digest("hex");
+  }
+
+  private matchesFilter(
+    webhook: WebhookConfig,
+    sessionId: string,
+    data: Record<string, unknown>,
+  ): boolean {
+    if (!webhook.sessionFilter) return true;
+
+    if (webhook.sessionFilter.backendType && data.backendType) {
+      if (webhook.sessionFilter.backendType !== data.backendType) return false;
+    }
+    if (webhook.sessionFilter.cwd && data.cwd) {
+      if (!(data.cwd as string).startsWith(webhook.sessionFilter.cwd)) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Format a webhook payload as a Slack incoming webhook message.
+   * Can be used by webhook consumers to post to Slack.
+   */
+  static formatSlackPayload(
+    event: WebhookEvent,
+    sessionId: string,
+    data: Record<string, unknown>,
+  ): { text: string; blocks: Array<Record<string, unknown>> } {
+    const eventLabels: Record<WebhookEvent, string> = {
+      "session.created": "Session Started",
+      "session.completed": "Session Completed",
+      "session.failed": "Session Failed",
+      "permission.requested": "Permission Requested",
+      "permission.resolved": "Permission Resolved",
+      "turn.completed": "Turn Completed",
+      "cost.threshold": "Cost Threshold Reached",
+    };
+
+    const label = eventLabels[event] || event;
+    const cost = typeof data.totalCostUsd === "number" ? `$${data.totalCostUsd.toFixed(4)}` : "";
+    const model = (data.model as string) || "";
+
+    return {
+      text: `Campfire: ${label} — session ${sessionId.slice(0, 8)}`,
+      blocks: [
+        {
+          type: "section",
+          text: { type: "mrkdwn", text: `*${label}*` },
+        },
+        {
+          type: "section",
+          fields: [
+            { type: "mrkdwn", text: `*Session:* ${sessionId.slice(0, 8)}` },
+            ...(model ? [{ type: "mrkdwn", text: `*Model:* ${model}` }] : []),
+            ...(cost ? [{ type: "mrkdwn", text: `*Cost:* ${cost}` }] : []),
+          ],
+        },
+      ],
+    };
+  }
+
+  /**
+   * Format a webhook payload as an OpenClaw /hooks/agent request.
+   * This allows Campfire events to trigger OpenClaw agent runs.
+   */
+  static formatOpenClawPayload(
+    event: WebhookEvent,
+    sessionId: string,
+    data: Record<string, unknown>,
+  ): {
+    message: string;
+    name: string;
+    wakeMode: string;
+    deliver: boolean;
+  } {
+    const eventLabels: Record<WebhookEvent, string> = {
+      "session.created": "Session Started",
+      "session.completed": "Session Completed",
+      "session.failed": "Session Failed",
+      "permission.requested": "Permission Requested",
+      "permission.resolved": "Permission Resolved",
+      "turn.completed": "Turn Completed",
+      "cost.threshold": "Cost Threshold Reached",
+    };
+
+    const label = eventLabels[event] || event;
+    const cost = typeof data.totalCostUsd === "number" ? ` | Cost: $${data.totalCostUsd.toFixed(4)}` : "";
+    const model = data.model ? ` | Model: ${data.model}` : "";
+    const backend = data.backendType ? ` | Backend: ${data.backendType}` : "";
+    const turns = typeof data.numTurns === "number" ? ` | Turns: ${data.numTurns}` : "";
+
+    return {
+      message: `[Campfire] ${label} — session ${sessionId.slice(0, 8)}${backend}${model}${cost}${turns}`,
+      name: "Campfire",
+      wakeMode: "now",
+      deliver: true,
+    };
+  }
+}

package/server/webhook-store.ts

@@ -0,0 +1,168 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { WebhookConfig, WebhookCreateInput } from "./webhook-types.js";
+import { ALL_WEBHOOK_EVENTS } from "./webhook-types.js";
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const CAMPFIRE_DIR = join(homedir(), ".campfire");
+const WEBHOOKS_DIR = join(CAMPFIRE_DIR, "webhooks");
+
+function ensureDir(): void {
+  mkdirSync(WEBHOOKS_DIR, { recursive: true });
+}
+
+function filePath(id: string): string {
+  return join(WEBHOOKS_DIR, `${id}.json`);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+// ─── CRUD ───────────────────────────────────────────────────────────────────
+
+export function listWebhooks(): WebhookConfig[] {
+  ensureDir();
+  try {
+    const files = readdirSync(WEBHOOKS_DIR).filter((f) => f.endsWith(".json"));
+    const webhooks: WebhookConfig[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(WEBHOOKS_DIR, file), "utf-8");
+        webhooks.push(JSON.parse(raw));
+      } catch {
+        // Skip corrupt files
+      }
+    }
+    webhooks.sort((a, b) => a.name.localeCompare(b.name));
+    return webhooks;
+  } catch {
+    return [];
+  }
+}
+
+export function getWebhook(id: string): WebhookConfig | null {
+  ensureDir();
+  try {
+    const raw = readFileSync(filePath(id), "utf-8");
+    return JSON.parse(raw) as WebhookConfig;
+  } catch {
+    return null;
+  }
+}
+
+export function createWebhook(data: WebhookCreateInput): WebhookConfig {
+  if (!data.name || !data.name.trim()) throw new Error("Webhook name is required");
+  if (!data.url || !data.url.trim()) throw new Error("Webhook URL is required");
+  if (!data.events || data.events.length === 0) throw new Error("At least one event is required");
+
+  // Validate event names against allowed events
+  for (const event of data.events) {
+    if (!ALL_WEBHOOK_EVENTS.includes(event)) {
+      throw new Error(`Invalid event: "${event}"`);
+    }
+  }
+
+  const id = slugify(data.name.trim());
+  if (!id) throw new Error("Webhook name must contain alphanumeric characters");
+
+  ensureDir();
+  if (existsSync(filePath(id))) {
+    throw new Error(`A webhook with a similar name already exists ("${id}")`);
+  }
+
+  const now = Date.now();
+  const webhook: WebhookConfig = {
+    id,
+    name: data.name.trim(),
+    url: data.url.trim(),
+    events: data.events,
+    secret: data.secret,
+    enabled: data.enabled ?? true,
+    format: data.format,
+    sessionFilter: data.sessionFilter,
+    createdAt: now,
+    updatedAt: now,
+    totalDeliveries: 0,
+    failedDeliveries: 0,
+  };
+  writeFileSync(filePath(id), JSON.stringify(webhook, null, 2), "utf-8");
+  return webhook;
+}
+
+export function updateWebhook(
+  id: string,
+  updates: Partial<WebhookConfig>,
+): WebhookConfig | null {
+  ensureDir();
+  const existing = getWebhook(id);
+  if (!existing) return null;
+
+  const newName = updates.name?.trim() || existing.name;
+  const newId = slugify(newName);
+  if (!newId) throw new Error("Webhook name must contain alphanumeric characters");
+
+  // If name changed, check for slug collision with a different webhook
+  if (newId !== id && existsSync(filePath(newId))) {
+    throw new Error(`A webhook with a similar name already exists ("${newId}")`);
+  }
+
+  // Validate events if provided
+  if (updates.events) {
+    if (updates.events.length === 0) throw new Error("At least one event is required");
+    for (const event of updates.events) {
+      if (!ALL_WEBHOOK_EVENTS.includes(event)) {
+        throw new Error(`Invalid event: "${event}"`);
+      }
+    }
+  }
+
+  const webhook: WebhookConfig = {
+    ...existing,
+    ...updates,
+    id: newId,
+    name: newName,
+    updatedAt: Date.now(),
+    // Preserve immutable fields
+    createdAt: existing.createdAt,
+  };
+
+  // If id changed, delete old file
+  if (newId !== id) {
+    try {
+      unlinkSync(filePath(id));
+    } catch {
+      /* ok */
+    }
+  }
+
+  writeFileSync(filePath(newId), JSON.stringify(webhook, null, 2), "utf-8");
+  return webhook;
+}
+
+export function deleteWebhook(id: string): boolean {
+  ensureDir();
+  if (!existsSync(filePath(id))) return false;
+  try {
+    unlinkSync(filePath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/webhook-types.ts

@@ -0,0 +1,66 @@
+import type { BackendType } from "./session-types.js";
+
+export type WebhookEvent =
+  | "session.created"
+  | "session.completed"
+  | "session.failed"
+  | "permission.requested"
+  | "permission.resolved"
+  | "turn.completed"
+  | "cost.threshold";
+
+export const ALL_WEBHOOK_EVENTS: WebhookEvent[] = [
+  "session.created",
+  "session.completed",
+  "session.failed",
+  "permission.requested",
+  "permission.resolved",
+  "turn.completed",
+  "cost.threshold",
+];
+
+export interface WebhookConfig {
+  id: string;
+  name: string;
+  url: string;
+  events: WebhookEvent[];
+  secret?: string;
+  enabled: boolean;
+  /** Payload format: "generic" (default), "slack", or "openclaw" (POST to /hooks/agent). */
+  format?: WebhookFormat;
+  sessionFilter?: {
+    backendType?: BackendType;
+    cwd?: string;
+  };
+  createdAt: number;
+  updatedAt: number;
+  totalDeliveries: number;
+  failedDeliveries: number;
+  lastDeliveryAt?: number;
+  lastDeliverySuccess?: boolean;
+}
+
+export interface WebhookPayload {
+  event: WebhookEvent;
+  timestamp: number;
+  sessionId: string;
+  data: Record<string, unknown>;
+}
+
+/** Payload format for outbound webhook delivery. */
+export type WebhookFormat = "generic" | "slack" | "openclaw";
+
+export const ALL_WEBHOOK_FORMATS: WebhookFormat[] = ["generic", "slack", "openclaw"];
+
+export interface WebhookCreateInput {
+  name: string;
+  url: string;
+  events: WebhookEvent[];
+  secret?: string;
+  enabled?: boolean;
+  format?: WebhookFormat;
+  sessionFilter?: {
+    backendType?: BackendType;
+    cwd?: string;
+  };
+}