OpenPond

Copy strategy · 4 times Sign in to star or watch

glucryptochore: bump opentool to v0.8.28

typescript

import { store } from "opentool/store";
import type { ToolProfile } from "opentool";
import { formatDigest, openpondRequest, readConfig } from "../src/daily-summary";

type ConnectedApp = {
  appId: string;
  deploymentId: string;
  toolName: string;
  displayName?: string;
  method?: "GET" | "POST";
  body?: unknown;
};

type ScheduleConfig = {
  cron: string;
  enabled: boolean;
  notifyEmail: boolean;
};

function resolveConnectedApps(): ConnectedApp[] {
  const raw = process.env.OPENPOND_DAILY_SNAPSHOT_CONFIG;
  if (!raw) return [];
  try {
    const parsed = JSON.parse(raw) as { subAgents?: unknown };
    const subAgents = Array.isArray(parsed?.subAgents) ? parsed.subAgents : [];
    return subAgents
      .map((agent) => {
        if (!agent || typeof agent !== "object") return null;
        const record = agent as Record<string, unknown>;
        const appId = typeof record.appId === "string" ? record.appId : "";
        const deploymentId =
          typeof record.deploymentId === "string" ? record.deploymentId : "";
        const toolName = typeof record.toolName === "string" ? record.toolName : "";
        if (!appId || !deploymentId || !toolName) return null;
        const connectedApp: ConnectedApp = {
          appId,
          deploymentId,
          toolName,
        };
        if (typeof record.displayName === "string" && record.displayName.trim().length > 0) {
          connectedApp.displayName = record.displayName;
        }
        if (record.method === "GET" || record.method === "POST") {
          connectedApp.method = record.method;
        }
        if ("body" in record) {
          connectedApp.body = record.body;
        }
        return connectedApp;
      })
      .filter((item): item is ConnectedApp => item !== null);
  } catch {
    return [];
  }
}

function resolveScheduleConfig(): ScheduleConfig {
  const fallback: ScheduleConfig = {
    cron: "0 8 * * *",
    enabled: false,
    notifyEmail: true,
  };
  const raw = process.env.OPENPOND_DAILY_SNAPSHOT_CONFIG;
  if (!raw) return fallback;
  try {
    const parsed = JSON.parse(raw) as {
      schedule?: { cron?: unknown; enabled?: unknown; notifyEmail?: unknown };
      channels?: { email?: unknown };
    };
    const cronRaw = parsed?.schedule?.cron;
    const cron =
      typeof cronRaw === "string" && cronRaw.trim().length > 0
        ? cronRaw.trim()
        : fallback.cron;
    const enabled = parsed?.schedule?.enabled === true;
    const notifyEmail =
      typeof parsed?.schedule?.notifyEmail === "boolean"
        ? parsed.schedule.notifyEmail
        : typeof parsed?.channels?.email === "boolean"
          ? parsed.channels.email
          : fallback.notifyEmail;
    return { cron, enabled, notifyEmail };
  } catch {
    return fallback;
  }
}

const scheduleConfig = resolveScheduleConfig();

export const profile: ToolProfile = {
  description: "Daily OpenPond summary (performance + add-on tools).",
  category: "orchestrator",
  schedule: {
    cron: scheduleConfig.cron,
    enabled: scheduleConfig.enabled,
    notifyEmail: scheduleConfig.notifyEmail,
  },
  connectedApps: resolveConnectedApps(),
};

type DailySummaryResponse = Awaited<ReturnType<typeof openpondRequest>>["data"];

function isMissing(response: Awaited<ReturnType<typeof openpondRequest>>) {
  const data = response.data;
  if (response.status === 404) return true;
  if (!data || typeof data !== "object") return false;
  return (data as Record<string, unknown>).error === "Not Found";
}

export async function GET(_req: Request) {
  const runAt = new Date().toISOString();
  const config = await readConfig();

  const performanceResponse = await openpondRequest("/apps/performance", {
    method: "GET",
  });
  const performance = isMissing(performanceResponse) ? null : performanceResponse.data;

  const subAgentResults: Array<{
    name: string;
    ok: boolean;
    data?: DailySummaryResponse;
    missing?: boolean;
  }> = [];
  if (config.subAgents?.length) {
    for (const agent of config.subAgents) {
      const response = await openpondRequest("/apps/tools/execute", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          appId: agent.appId,
          deploymentId: agent.deploymentId,
          toolName: agent.toolName,
          method: agent.method ?? "POST",
          body: agent.body ?? {},
        }),
      });
      subAgentResults.push({
        name: agent.displayName ?? agent.toolName,
        ok: response.ok,
        data: response.data,
        missing: isMissing(response),
      });
    }
  }

  const content = formatDigest({
    runAt,
    performance,
    subAgentResults,
  });

  await store({
    source: "daily-summary",
    ref: `daily-summary-${runAt}`,
    status: "info",
    action: "digest",
    metadata: {
      runAt,
      content,
      performance,
      subAgents: subAgentResults,
    },
  });

  return Response.json({
    ok: true,
    runAt,
    content,
    performance,
    subAgents: subAgentResults,
  });
}