tokenmax-collector 0.2.1 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmax-collector",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Report local ccusage token usage to a tokenmax instance",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -40,12 +40,22 @@ async function runCollect(io: CliIo): Promise<number> {
     for (const warning of result.warnings) {
       io.stderr(warning);
     }
-    io.stdout(
-      result.kind === "reported"
-        ? `accepted ${result.accepted} days for ${result.machine}`
-        : "nothing to report",
-    );
-    return 0;
+    if (result.kind === "empty") {
+      io.stdout("nothing to report");
+      return 0;
+    }
+    let exitCode = 0;
+    for (const target of result.targets) {
+      if ("accepted" in target) {
+        io.stdout(
+          `accepted ${target.accepted} days for ${result.machine} at ${target.url}`,
+        );
+      } else {
+        io.stderr(`${target.url}: ${target.message}`);
+        exitCode = 1;
+      }
+    }
+    return exitCode;
   }
   if (result.kind === "missing-config") {
     io.stderr(

package/src/collect.ts

@@ -1,4 +1,5 @@
 import {
+  type AntigravityStep,
   antigravityConversationsDir,
   readAntigravitySteps,
 } from "./antigravity";
@@ -9,12 +10,19 @@ import {
   windowStart,
 } from "./ccusage";
 import { type CommandRunner, runCommand } from "./command";
-import { readConfig, runtimeTimezone } from "./config";
+import { type CollectorTarget, readConfig, runtimeTimezone } from "./config";
+import { type DevinStep, devinTranscriptsDir, readDevinSteps } from "./devin";
 import type { Fetcher } from "./http";
 import { type MachineIdentity, machineId } from "./machine";
-import { mapAntigravitySteps, mapCcusageDays } from "./mapping";
+import {
+  antigravityProvider,
+  devinProvider,
+  mapAntigravitySteps,
+  mapCcusageDays,
+  mapDevinSteps,
+} from "./mapping";
 import { type CollectorEnv, collectorPaths, processEnv } from "./paths";
-import { loadPrices } from "./pricing";
+import { loadPrices, type PriceTable } from "./pricing";
 import type { UsageDay, UsageReport } from "./usage";
 
 export interface CollectOptions {
@@ -26,8 +34,17 @@ export interface CollectOptions {
   timezone?: string;
 }
 
+export type TargetResult =
+  | { accepted: number; url: string }
+  | { message: string; url: string };
+
 export type CollectResult =
-  | { kind: "reported"; accepted: number; machine: string; warnings: string[] }
+  | {
+      kind: "reported";
+      machine: string;
+      targets: TargetResult[];
+      warnings: string[];
+    }
   | { kind: "empty"; warnings: string[] }
   | { kind: "missing-config"; configFile: string }
   | { kind: "failed"; message: string };
@@ -56,63 +73,100 @@ function acceptedCount(body: string): number | null {
   return typeof accepted === "number" ? accepted : null;
 }
 
-interface AntigravityRows {
+interface LocalRows {
   days: UsageDay[];
   warnings: string[];
 }
 
+interface LocalSource<Step extends { at: Date }> {
+  map: (steps: Step[], timezone: string, prices: PriceTable) => UsageDay[];
+  provider: string;
+  read: (home: string) => Promise<{ failures: string[]; steps: Step[] }>;
+}
+
+interface LocalWindow {
+  fetcher: Fetcher;
+  home: string;
+  pricesFile: string;
+  since: string;
+  timezone: string;
+  today: Date;
+}
+
+const antigravitySource: LocalSource<AntigravityStep> = {
+  map: mapAntigravitySteps,
+  provider: antigravityProvider,
+  read: (home) => readAntigravitySteps(antigravityConversationsDir(home)),
+};
+
+const devinSource: LocalSource<DevinStep> = {
+  map: mapDevinSteps,
+  provider: devinProvider,
+  read: (home) => readDevinSteps(devinTranscriptsDir(home)),
+};
+
 async function report(
   fetcher: Fetcher,
-  url: string,
-  key: string,
-  usage: UsageReport,
-  warnings: string[],
-): Promise<CollectResult> {
-  const response = await fetcher(reportUrl(url), {
-    body: JSON.stringify(usage),
-    headers: {
-      Authorization: `Bearer ${key}`,
-      "Content-Type": "application/json",
-    },
-    method: "POST",
-  });
-  const body = await response.text();
-  if (response.status !== 200) {
-    return {
-      kind: "failed",
-      message: `tokenmax responded ${response.status}: ${body}`,
-    };
-  }
-  const accepted = acceptedCount(body);
-  if (accepted === null) {
-    return {
-      kind: "failed",
-      message: `tokenmax responded an unexpected body: ${body}`,
-    };
+  target: CollectorTarget,
+  body: string,
+): Promise<TargetResult> {
+  const { url } = target;
+  try {
+    const response = await fetcher(reportUrl(url), {
+      body,
+      headers: {
+        Authorization: `Bearer ${target.key}`,
+        "Content-Type": "application/json",
+      },
+      method: "POST",
+    });
+    const answer = await response.text();
+    if (response.status !== 200) {
+      return {
+        message: `tokenmax responded ${response.status}: ${answer}`,
+        url,
+      };
+    }
+    const accepted = acceptedCount(answer);
+    if (accepted === null) {
+      return {
+        message: `tokenmax responded an unexpected body: ${answer}`,
+        url,
+      };
+    }
+    return { accepted, url };
+  } catch (error) {
+    return { message: messageOf(error), url };
   }
-  return { accepted, kind: "reported", machine: usage.machine, warnings };
 }
 
-async function antigravityDays(
-  home: string,
-  today: Date,
-  timezone: string,
-  fetcher: Fetcher,
-  pricesFile: string,
-): Promise<AntigravityRows> {
-  const since = windowStart(today, timezone);
-  const usage = await readAntigravitySteps(antigravityConversationsDir(home));
-  const warnings = usage.failures.map(
-    (failure) => `antigravity: skipped ${failure}`,
-  );
-  const steps = usage.steps.filter(
-    (step) => calendarDate(step.at, timezone) >= since,
-  );
-  if (steps.length === 0) {
-    return { days: [], warnings };
+async function localDays<Step extends { at: Date }>(
+  source: LocalSource<Step>,
+  window: LocalWindow,
+): Promise<LocalRows> {
+  try {
+    const usage = await source.read(window.home);
+    const warnings = usage.failures.map(
+      (failure) => `${source.provider}: skipped ${failure}`,
+    );
+    const steps = usage.steps.filter(
+      (step) => calendarDate(step.at, window.timezone) >= window.since,
+    );
+    if (steps.length === 0) {
+      return { days: [], warnings };
+    }
+    const prices = await loadPrices(
+      window.fetcher,
+      window.pricesFile,
+      window.today,
+    );
+    return { days: source.map(steps, window.timezone, prices), warnings };
+  } catch (error) {
+    return {
+      days: [],
+      warnings: [`${source.provider}: ${messageOf(error)}`],
+    };
   }
-  const prices = await loadPrices(fetcher, pricesFile, today);
-  return { days: mapAntigravitySteps(steps, timezone, prices), warnings };
 }
 
 export async function collect(options: CollectOptions): Promise<CollectResult> {
@@ -148,32 +202,27 @@ export async function collect(options: CollectOptions): Promise<CollectResult> {
     return { kind: "failed", message: messageOf(error) };
   }
 
-  let antigravity: AntigravityRows;
-  try {
-    antigravity = await antigravityDays(
-      env.home,
-      today,
-      timezone,
-      fetcher,
-      paths.pricesFile,
-    );
-  } catch (error) {
-    antigravity = { days: [], warnings: [`antigravity: ${messageOf(error)}`] };
-  }
-  days.push(...antigravity.days);
+  const window: LocalWindow = {
+    fetcher,
+    home: env.home,
+    pricesFile: paths.pricesFile,
+    since: windowStart(today, timezone),
+    timezone,
+    today,
+  };
+  const antigravity = await localDays(antigravitySource, window);
+  const devin = await localDays(devinSource, window);
+  days.push(...antigravity.days, ...devin.days);
+  const warnings = [...antigravity.warnings, ...devin.warnings];
   if (days.length === 0) {
-    return { kind: "empty", warnings: antigravity.warnings };
+    return { kind: "empty", warnings };
   }
 
-  try {
-    return await report(
-      fetcher,
-      config.config.url,
-      config.config.key,
-      { days, machine, timezone },
-      antigravity.warnings,
-    );
-  } catch (error) {
-    return { kind: "failed", message: messageOf(error) };
+  const usage: UsageReport = { days, machine, timezone };
+  const body = JSON.stringify(usage);
+  const targets: TargetResult[] = [];
+  for (const target of config.config.targets) {
+    targets.push(await report(fetcher, target, body));
   }
+  return { kind: "reported", machine, targets, warnings };
 }

package/src/config.ts

@@ -2,12 +2,25 @@ import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { z } from "zod";
 
-export const collectorConfig = z.object({
+export const collectorTarget = z.object({
   key: z.string().min(1),
-  timezone: z.string().min(1).optional(),
   url: z.url({ protocol: /^https?$/ }),
 });
 
+const timezone = z.string().min(1).optional();
+
+export const collectorConfig = z.object({
+  targets: z.array(collectorTarget).min(1),
+  timezone,
+});
+
+const singleTargetConfig = collectorTarget
+  .extend({ timezone })
+  .transform(({ key, url, ...rest }) => ({ targets: [{ key, url }], ...rest }));
+
+const storedConfig = z.union([collectorConfig, singleTargetConfig]);
+
+export type CollectorTarget = z.infer<typeof collectorTarget>;
 export type CollectorConfig = z.infer<typeof collectorConfig>;
 
 export function canonicalTimezone(value: string): string | null {
@@ -62,7 +75,7 @@ export async function readConfig(
     };
   }
 
-  const parsed = collectorConfig.safeParse(payload);
+  const parsed = storedConfig.safeParse(payload);
   if (!parsed.success) {
     return {
       kind: "invalid",

package/src/devin.ts

@@ -0,0 +1,94 @@
+import { readdir, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+
+export interface DevinStep {
+  at: Date;
+  cacheCreate: number;
+  cacheRead: number;
+  input: number;
+  model: string;
+  output: number;
+}
+
+export interface DevinUsage {
+  failures: string[];
+  steps: DevinStep[];
+}
+
+const unknownModel = "devin-unknown";
+
+const metrics = z.object({
+  cached_tokens: z.int().optional(),
+  completion_tokens: z.int(),
+  extra: z
+    .object({ cache_creation_input_tokens: z.int().optional() })
+    .optional(),
+  prompt_tokens: z.int(),
+});
+
+const step = z.object({
+  metrics: metrics.optional(),
+  model_name: z.string().optional(),
+  source: z.string(),
+  timestamp: z.iso.datetime({ offset: true }),
+});
+
+const transcript = z.object({ steps: z.array(step) });
+
+const issueText = (error: z.ZodError): string =>
+  error.issues
+    .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+    .join("; ");
+
+export function devinTranscriptsDir(home: string): string {
+  return resolve(home, ".local", "share", "devin", "cli", "transcripts");
+}
+
+function parseTranscript(source: string): DevinStep[] {
+  const parsed = transcript.safeParse(JSON.parse(source));
+  if (!parsed.success) {
+    throw new Error(issueText(parsed.error));
+  }
+  const steps: DevinStep[] = [];
+  for (const entry of parsed.data.steps) {
+    if (entry.source !== "agent" || entry.metrics === undefined) {
+      continue;
+    }
+    const cacheRead = entry.metrics.cached_tokens ?? 0;
+    const cacheCreate = entry.metrics.extra?.cache_creation_input_tokens ?? 0;
+    steps.push({
+      at: new Date(entry.timestamp),
+      cacheCreate,
+      cacheRead,
+      input: entry.metrics.prompt_tokens - cacheRead - cacheCreate,
+      model: entry.model_name ?? unknownModel,
+      output: entry.metrics.completion_tokens,
+    });
+  }
+  return steps;
+}
+
+export async function readDevinSteps(dir: string): Promise<DevinUsage> {
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return { failures: [], steps: [] };
+    }
+    throw error;
+  }
+  const steps: DevinStep[] = [];
+  const failures: string[] = [];
+  for (const file of files.filter((name) => name.endsWith(".json")).sort()) {
+    const path = resolve(dir, file);
+    try {
+      steps.push(...parseTranscript(await readFile(path, "utf8")));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${path}: ${message}`);
+    }
+  }
+  return { failures, steps };
+}

package/src/install.ts

@@ -3,8 +3,10 @@ import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   type CollectorConfig,
+  type CollectorTarget,
   canonicalTimezone,
   collectorConfig,
+  readConfig,
   runtimeTimezone,
   writeConfig,
 } from "./config";
@@ -67,6 +69,13 @@ function scheduleFiles(
   ];
 }
 
+async function configuredTargets(
+  configFile: string,
+): Promise<CollectorTarget[]> {
+  const existing = await readConfig(configFile);
+  return existing.kind === "ok" ? existing.config.targets : [];
+}
+
 export async function install(options: InstallOptions): Promise<InstallPlan> {
   const env = options.env ?? processEnv();
   const platform = resolvePlatform(options.platform ?? process.platform);
@@ -76,10 +85,12 @@ export async function install(options: InstallOptions): Promise<InstallPlan> {
   if (timezone === null) {
     throw new Error(`invalid timezone: ${requestedTimezone}`);
   }
+  const others = (await configuredTargets(paths.configFile)).filter(
+    (target) => target.url !== options.url,
+  );
   const config = collectorConfig.parse({
-    key: options.key,
+    targets: [...others, { key: options.key, url: options.url }],
     timezone,
-    url: options.url,
   });
   const cliPath = options.cliPath ?? resolveCliPath();
   if (
@@ -106,6 +117,9 @@ export async function install(options: InstallOptions): Promise<InstallPlan> {
   const log = options.log ?? console.log;
 
   log(`config: ${plan.configFile} (600, key redacted)`);
+  for (const target of plan.config.targets) {
+    log(`target: ${target.url}`);
+  }
   for (const file of plan.files) {
     log(`schedule: ${file.path}`);
   }

package/src/machine.ts

@@ -11,12 +11,13 @@ const disallowed = /[^A-Za-z0-9._-]/g;
 
 const platformUuidPattern = /"IOPlatformUUID"\s*=\s*"([^"]+)"/;
 
+/** The hostname changes with the network, and every spelling of it used to open
+ * a new machine on the server, so the platform identifier travels alone. */
 export function machineId(
   hostnameValue: string,
   platformUuid: string | null,
 ): string {
-  const raw =
-    platformUuid === null ? hostnameValue : `${hostnameValue}-${platformUuid}`;
+  const raw = platformUuid ?? hostnameValue;
   return raw.replace(disallowed, "-").slice(0, 64);
 }
 

package/src/mapping.ts

@@ -1,11 +1,18 @@
 import type { AntigravityStep } from "./antigravity";
 import { type CcusageDaily, calendarDate } from "./ccusage";
-import { costOf, type PriceTable } from "./pricing";
+import type { DevinStep } from "./devin";
+import { costOf, type ModelPrice, type PriceTable } from "./pricing";
 import type { UsageDay } from "./usage";
 
 export const antigravityProvider = "antigravity";
+export const devinProvider = "devin";
 
 const agentModelPrefix = /^\[[^\]]*\]\s*/;
+const effortSuffix = /-(low|medium|high|xhigh)$/;
+const gptMinorVersion = /^gpt-(\d+)-(\d+)-/;
+
+const litellmModel = (devinModel: string): string =>
+  devinModel.replace(effortSuffix, "").replace(gptMinorVersion, "gpt-$1.$2-");
 
 const rowKey = (day: UsageDay): string =>
   `${day.date}\u0000${day.provider}\u0000${day.model}`;
@@ -53,23 +60,33 @@ export function mapCcusageDays(output: CcusageDaily): UsageDay[] {
   return sortedRows(rows);
 }
 
-export function mapAntigravitySteps(
-  steps: AntigravityStep[],
+interface LocalStep {
+  at: Date;
+  cacheCreate?: number;
+  cacheRead: number;
+  input: number;
+  model: string;
+  output: number;
+}
+
+function mapLocalSteps(
+  steps: LocalStep[],
+  provider: string,
   timezone: string,
-  prices: PriceTable,
+  priceOf: (model: string) => ModelPrice | undefined,
 ): UsageDay[] {
   const rows = new Map<string, UsageDay>();
 
   for (const step of steps) {
     const row: UsageDay = {
-      cache_create: 0,
+      cache_create: step.cacheCreate ?? 0,
       cache_read: step.cacheRead,
       cost_usd: 0,
       date: calendarDate(step.at, timezone),
       input: step.input,
       model: step.model,
       output: step.output,
-      provider: antigravityProvider,
+      provider,
     };
     if (isEmptyRow(row)) {
       continue;
@@ -80,17 +97,19 @@ export function mapAntigravitySteps(
       rows.set(key, row);
       continue;
     }
+    existing.cache_create += row.cache_create;
     existing.cache_read += row.cache_read;
     existing.input += row.input;
     existing.output += row.output;
   }
 
   for (const row of rows.values()) {
-    const price = prices.get(row.model) ?? prices.get(`gemini/${row.model}`);
+    const price = priceOf(row.model);
     row.cost_usd =
       price === undefined
         ? 0
         : costOf(price, {
+            cacheCreate: row.cache_create,
             cacheRead: row.cache_read,
             input: row.input,
             output: row.output,
@@ -100,6 +119,32 @@ export function mapAntigravitySteps(
   return sortedRows(rows);
 }
 
+export function mapAntigravitySteps(
+  steps: AntigravityStep[],
+  timezone: string,
+  prices: PriceTable,
+): UsageDay[] {
+  return mapLocalSteps(
+    steps,
+    antigravityProvider,
+    timezone,
+    (model) => prices.get(model) ?? prices.get(`gemini/${model}`),
+  );
+}
+
+export function mapDevinSteps(
+  steps: DevinStep[],
+  timezone: string,
+  prices: PriceTable,
+): UsageDay[] {
+  return mapLocalSteps(
+    steps.map((step) => ({ ...step, model: litellmModel(step.model) })),
+    devinProvider,
+    timezone,
+    (model) => prices.get(model),
+  );
+}
+
 function sortedRows(rows: Map<string, UsageDay>): UsageDay[] {
   return [...rows.values()].sort(
     (a, b) =>

package/src/pricing.ts

@@ -4,6 +4,7 @@ import { z } from "zod";
 import type { Fetcher } from "./http";
 
 export interface ModelPrice {
+  cacheCreate: number;
   cacheRead: number;
   input: number;
   output: number;
@@ -12,6 +13,7 @@ export interface ModelPrice {
 export type PriceTable = Map<string, ModelPrice>;
 
 export interface PricedUsage {
+  cacheCreate?: number;
   cacheRead: number;
   input: number;
   output: number;
@@ -23,6 +25,7 @@ export const litellmPricesUrl =
 const maxAgeMs = 24 * 60 * 60 * 1000;
 
 const pricedEntry = z.object({
+  cache_creation_input_token_cost: z.number().optional(),
   cache_read_input_token_cost: z.number().optional(),
   input_cost_per_token: z.number(),
   output_cost_per_token: z.number(),
@@ -38,6 +41,7 @@ export function parseLitellmPrices(source: string): PriceTable {
     const priced = pricedEntry.safeParse(entry);
     if (priced.success) {
       table.set(model, {
+        cacheCreate: priced.data.cache_creation_input_token_cost ?? 0,
         cacheRead: priced.data.cache_read_input_token_cost ?? 0,
         input: priced.data.input_cost_per_token,
         output: priced.data.output_cost_per_token,
@@ -51,7 +55,8 @@ export function costOf(price: ModelPrice, usage: PricedUsage): number {
   return (
     usage.input * price.input +
     usage.output * price.output +
-    usage.cacheRead * price.cacheRead
+    usage.cacheRead * price.cacheRead +
+    (usage.cacheCreate ?? 0) * price.cacheCreate
   );
 }