debutly 0.0.0-stage → 0.2.0

package/src/cost/tiers.ts

@@ -0,0 +1,27 @@
+// Run sizes. Units are individuals or business crews; breadth evaluators judge pages on top.
+export const TIERS = {
+  quick: { units: 3, employees: 0 }, // CI / pre-deploy smoke: owners only
+  standard: { units: 10, employees: 2 },
+  deep: { units: 30, employees: 3 },
+} as const;
+export type Tier = keyof typeof TIERS;
+
+export interface RunSize {
+  tier: Tier;
+  units: number;
+  employees: number;
+}
+
+/** A tier's size, with explicitly given counts taking precedence. */
+export function resolveRunSize(o: { tier?: string; units?: number; employees?: number }): RunSize {
+  const tier = (o.tier ?? "quick") as Tier;
+  if (!(tier in TIERS)) throw new Error(`--tier must be quick, standard or deep (got "${o.tier}")`);
+  return { tier, units: o.units ?? TIERS[tier].units, employees: o.employees ?? TIERS[tier].employees };
+}
+
+/** Agents a run will use: individuals count once; a crew is its owner plus employees. */
+export const agentCount = (kind: "individual" | "business", size: RunSize) =>
+  kind === "individual" ? size.units : size.units * (1 + size.employees);
+
+/** Breadth evaluators per tier: Quick ~50, Standard 200–500, Deep 1,000–5,000. */
+export const EVALUATORS: Record<Tier, number> = { quick: 50, standard: 300, deep: 1500 };

package/src/costs.ts

@@ -0,0 +1,96 @@
+// Cost meter: what Debutly is spending, in one place.
+//
+//   npm run debutly:costs -- [--repo owner/name ...]
+//
+// Shows the OpenRouter key's spend (today, this week, this month, limit left) and, for each app
+// repo given, what its latest nightly agent run cost (read from the GitHub run log via `gh`).
+import "./util/legacy-env";
+import "./util/key-defaults";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parseArgs } from "node:util";
+import { isOpenRouter } from "./llm/openrouter";
+
+const run = promisify(execFile);
+
+export interface KeySpend {
+  today: number;
+  week: number;
+  month: number;
+  total: number;
+  limit: number | null;
+  remaining: number | null;
+  resets: string | null;
+}
+
+export async function fetchKeySpend(baseUrl: string, apiKey: string, fetchFn: typeof fetch = fetch): Promise<KeySpend> {
+  const res = await fetchFn(`${baseUrl.replace(/\/+$/, "")}/key`, { headers: { authorization: `Bearer ${apiKey}` } });
+  if (!res.ok) throw new Error(`OpenRouter key info: HTTP ${res.status}`);
+  const { data: d } = (await res.json()) as { data: Record<string, unknown> };
+  const n = (k: string) => (typeof d[k] === "number" ? (d[k] as number) : 0);
+  return {
+    today: n("usage_daily"),
+    week: n("usage_weekly"),
+    month: n("usage_monthly"),
+    total: n("usage"),
+    limit: typeof d.limit === "number" ? d.limit : null,
+    remaining: typeof d.limit_remaining === "number" ? d.limit_remaining : null,
+    resets: typeof d.limit_reset === "string" ? d.limit_reset : null,
+  };
+}
+
+/** The cost a Debutly run printed at the end ("Done: … cost $0.1234 …"), from a CI log. */
+export function costFromLog(log: string): number | null {
+  const matches = [...log.matchAll(/Done: [^\n]*?cost \$(\d+(?:\.\d+)?)/g)];
+  return matches.length ? Number(matches[matches.length - 1][1]) : null;
+}
+
+export interface NightlyCost {
+  repo: string;
+  when: string;
+  costUsd: number | null;
+  url: string;
+}
+
+async function latestNightly(repo: string): Promise<NightlyCost | null> {
+  const { stdout } = await run("gh", ["run", "list", "--repo", repo, "--workflow", "throwaway-env.yml", "--status", "success", "--limit", "5", "--json", "databaseId,createdAt,url,event"]);
+  const runs = JSON.parse(stdout) as { databaseId: number; createdAt: string; url: string; event: string }[];
+  for (const r of runs) {
+    const { stdout: log } = await run("gh", ["run", "view", String(r.databaseId), "--repo", repo, "--log"], { maxBuffer: 64 * 1024 * 1024 });
+    const costUsd = costFromLog(log);
+    if (costUsd !== null) return { repo, when: r.createdAt, costUsd, url: r.url };
+  }
+  return null;
+}
+
+const usd = (x: number) => `$${x.toFixed(2)}`;
+
+if (process.argv[1]?.endsWith("costs.ts")) {
+  const { values } = parseArgs({ options: { repo: { type: "string", multiple: true } } });
+  const { DEBUTLY_BASE_URL, DEBUTLY_API_KEY } = process.env;
+  if (DEBUTLY_BASE_URL && isOpenRouter(DEBUTLY_BASE_URL) && DEBUTLY_API_KEY) {
+    const s = await fetchKeySpend(DEBUTLY_BASE_URL, DEBUTLY_API_KEY);
+    console.log("OpenRouter key");
+    console.log(`  Today ${usd(s.today)} · this week ${usd(s.week)} · this month ${usd(s.month)} · all time ${usd(s.total)}`);
+    if (s.limit !== null) console.log(`  Limit ${usd(s.limit)}${s.resets ? ` (resets ${s.resets})` : ""} · left ${usd(s.remaining ?? 0)}`);
+  } else {
+    console.log("OpenRouter key: not configured (DEBUTLY_BASE_URL / DEBUTLY_API_KEY)");
+  }
+
+  const nightly: NightlyCost[] = [];
+  for (const repo of values.repo ?? []) {
+    try {
+      const n = await latestNightly(repo);
+      if (n) nightly.push(n);
+      else console.log(`  ${repo}: no costed agent run found yet`);
+    } catch (err) {
+      console.log(`  ${repo}: could not read runs (${err instanceof Error ? err.message.split("\n")[0] : err})`);
+    }
+  }
+  if (nightly.length) {
+    console.log("\nLatest agent run per app");
+    for (const n of nightly) console.log(`  ${n.repo.padEnd(40)} ${usd(n.costUsd ?? 0)}  (${n.when.slice(0, 10)})`);
+    const perNight = nightly.reduce((a, n) => a + (n.costUsd ?? 0), 0);
+    console.log(`  ${"Per night, all apps".padEnd(40)} ${usd(perNight)}  → about ${usd(perNight * 30)} a month`);
+  }
+}

package/src/crew/run-unit.ts

@@ -0,0 +1,62 @@
+import type { Inbox } from "../inbox/types";
+import type { Business, CustomerUnit, Persona, Session } from "../types";
+
+/** Runs one agent in its own browser context; `brief` joins its system prompt. */
+export type RunAgent = (persona: Persona, goal: string, brief: string | undefined) => Promise<Session>;
+
+export interface UnitDeps {
+  runAgent: RunAgent;
+  emailOf: (persona: Persona) => string;
+  inbox?: Inbox;
+}
+
+const article = (word: string) => (/^[aeiou]/i.test(word) ? "an" : "a");
+
+const companyBrief = (b: Business) =>
+  `You work at ${b.name}, ${article(b.archetype)} ${b.archetype} of about ${b.size} people. Its budget for tools like this is $${b.monthlyBudget} a month. Company goal: ${b.goal}.`;
+
+export function ownerGoal(goal: string, team: { name: string; role?: string; email: string }[]): string {
+  if (!team.length) return goal;
+  const who = team.map((t) => `${t.name} (${t.role ?? "Teammate"}) at ${t.email}`).join("; ");
+  return `${goal}\nOnce you are set up, invite your teammates by email so they can use it too: ${who}.`;
+}
+
+// A teammate who lands in an empty workspace of their own has not joined anything, even if the
+// invite page said "accepted"; that must not count as success.
+export const employeeGoal = (role: string, owner: string, company: string) =>
+  `${owner} has invited you to use this product at ${company}. Check your email for the invite, accept it and set up your account. Then check that you are in ${company}'s shared workspace: you should see what ${owner} set up there, such as the company details or the items they added. If you only see an empty workspace of your own, joining did not work: report that as a failure, not success. If you are in, do one task a ${role} would typically do here. Finish when you have done that or when you would give up.`;
+
+const tag = (s: Session, unitId: string, p: Persona): Session => ({ ...s, unitId, role: p.role, inclusion: p.inclusion, language: p.language });
+const notInvited = (unitId: string, p: Persona, why: string): Session =>
+  tag({ agentId: p.id, personaName: p.name, goal: "", steps: [], outcome: "not_invited", outcomeNote: why }, unitId, p);
+
+/**
+ * One customer unit. An individual runs once. A business crew runs its owner first (who is told
+ * whom to invite), then, in parallel and each in its own browser, only the employees whose invite
+ * actually reached their inbox, sharing the company brief and what the owner reported.
+ */
+export async function runUnit(unit: CustomerUnit, goal: string, deps: UnitDeps): Promise<Session[]> {
+  if (unit.kind === "individual") return [tag(await deps.runAgent(unit.person, goal, undefined), unit.id, unit.person)];
+
+  const { business, owner, employees } = unit;
+  const brief = companyBrief(business);
+  const team = employees.map((e) => ({ name: e.name, role: e.role, email: deps.emailOf(e) }));
+  const ownerSession = tag(
+    await deps.runAgent(owner, ownerGoal(goal, team), `${brief}\nYou run ${business.name} and decide which plan and how many seats to buy.`),
+    unit.id,
+    owner,
+  );
+  if (!employees.length) return [ownerSession];
+  const { inbox } = deps;
+  if (!inbox) return [ownerSession, ...employees.map((e) => notInvited(unit.id, e, "No test inbox, so teammates cannot receive invites."))];
+
+  const shared = `${brief}\n${owner.name} (the owner) reported: "${ownerSession.outcomeNote}"`;
+  const rest = await Promise.all(
+    employees.map(async (e) => {
+      const mail = await inbox.latest(deps.emailOf(e)).catch(() => []);
+      if (!mail.length) return notInvited(unit.id, e, `No invite email arrived after ${owner.name} finished.`);
+      return tag(await deps.runAgent(e, employeeGoal(e.role ?? "teammate", owner.name, business.name), shared), unit.id, e);
+    }),
+  );
+  return [ownerSession, ...rest];
+}