Skip to content

A motion design studio on your own machine: Claude makes the video step by step, you approve every stage. Bring your own Claude Code or API key.

14.2 KB
Raw Blame
// The usage ledger (owner, 2026-11-02): Claude tokens + ElevenLabs credits, per day/project/stage/model, records, balance.
// Mock transcripts and mock fetch only: no real calls.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { mkdirSync, writeFileSync, appendFileSync, readFileSync, existsSync, utimesSync } from 'node:fs';
import { join } from 'node:path';
import { tempStudio } from './helpers.mjs';
import { createService } from '../src/service.mjs';
import { writeSecret, paths } from '../src/studio.mjs';
import { logVoiceUse } from '../src/voiceusage.mjs';
import { bookSpend, costHeader } from '../src/voice/spend.mjs';
import { usageGet, record, bookSession, recordClaudeJson, recordApiMessage, readRows, ledgerFile, backfillDone, _forget } from '../src/svc/ledger.mjs';

const P = '261101-ledger-test-0001';
const Q = '261101-ledger-test-0002';
const J = (o) => JSON.stringify(o) + '\n';
const sleep = (ms) => new Promise((ok) => setTimeout(ok, ms));

function studio(t) {
  _forget();
  const root = tempStudio(t);
  for (const id of [P, Q]) {
    mkdirSync(join(paths(root).state, id, 'sessions'), { recursive: true });
    writeFileSync(join(paths(root).state, id, 'project.json'), JSON.stringify({ id, created_at: '2026-11-01T08:00:00.000Z' }));
    mkdirSync(join(paths(root).projects, id), { recursive: true });
  }
  return root;
}

function transcript(root, id, run, { old = true } = {}) {
  const f = join(paths(root).state, id, 'sessions', `${run}.jsonl`);
  const asst = (mid, model, usage, extra = {}) => J({ type: 'assistant', message: { id: mid, model, usage, content: [{ type: 'text', text: 'x'.repeat(400) }] }, ...extra });
  writeFileSync(f,
    J({ type: 'system', subtype: 'init', model: 'claude-haiku-4-5', tools: ['Read'] })
    + asst('m1', 'claude-haiku-4-5', { input_tokens: 10, output_tokens: 1, cache_read_input_tokens: 100, cache_creation_input_tokens: 50 })
    + J({ type: 'result', usage: { output_tokens: 40 }, total_cost_usd: 0.01 })
    + J({ type: 'system', subtype: 'init', model: 'claude-opus-5-5', tools: ['Bash', 'Task', 'Edit'] })
    + asst('m2', 'claude-opus-5-5', { input_tokens: 5, output_tokens: 1, cache_read_input_tokens: 1000, cache_creation_input_tokens: 500 })
    + asst('m2', 'claude-opus-5-5', { input_tokens: 5, output_tokens: 1, cache_read_input_tokens: 1000, cache_creation_input_tokens: 500 }) // same message again: once
    + asst('m3', 'claude-opus-5-5', { input_tokens: 7, output_tokens: 1, cache_read_input_tokens: 2000, cache_creation_input_tokens: 0 })
    + J({ type: 'result', usage: { output_tokens: 200 }, total_cost_usd: 1 }));
  if (old) { const past = new Date(Date.now() - 3600_000); utimesSync(f, past, past); }
}

const seed = (root) => {
  transcript(root, P, '2026-11-01T09-00-00-000Z');
  const voice = join(paths(root).projects, P, 'sound', 'voice');
  mkdirSync(voice, { recursive: true });
  writeFileSync(join(voice, 'usage.jsonl'), [
    { t: '2026-11-01T09:05:00.000Z', engine: 'elevenlabs', model: 'eleven_multilingual_v2', line: 'l1', characters: 100 },
    { t: '2026-11-01T09:06:00.000Z', engine: 'elevenlabs', model: 'eleven_flash_v2_5', line: 'l2', characters: 100 },
    { t: '2026-11-01T09:07:00.000Z', engine: 'qwen', voice: 'x', lines: 3, seconds: 5 },
  ].map(J).join(''));
  mkdirSync(join(paths(root).projects, P, 'music'), { recursive: true });
  writeFileSync(join(paths(root).projects, P, 'music', 'calls.jsonl'), [
    { t: '2026-11-01T10:00:00.000Z', ok: true, seconds: 10, credits_estimate: 330 },
    { t: '2026-11-01T10:01:00.000Z', ok: true, cache: 'hit', credits_estimate: 0 },
    { t: '2026-11-01T10:02:00.000Z', ok: false, status: 402, seconds: 10 },
  ].map(J).join(''));
  mkdirSync(join(paths(root).projects, P, 'sound'), { recursive: true });
  writeFileSync(join(paths(root).projects, P, 'sound', 'calls.jsonl'), [
    { at: '2026-11-02T10:00:00.000Z', ok: true, seconds: 2, credits: 40 },
    { at: '2026-11-02T10:01:00.000Z', ok: true, cache: 'hit', credits: 0 },
  ].map(J).join(''));
};

test('backfill books transcripts, voice, music and sound logs once; no dollars anywhere', async (t) => {
  const root = studio(t);
  seed(root);
  const u = await usageGet(root, {}, { now: Date.parse('2026-11-02T12:00:00Z') });
  const c = u.totals.claude;
  // haiku quick call + opus session (m2 once, m3): fresh input 10+5+7, cache read 100+1000+2000, cache write 50+500
  assert.equal(c.input_tokens, 22);
  assert.equal(c.cache_read_tokens, 3100);
  assert.equal(c.cache_write_tokens, 550);
  assert.equal(c.output_tokens, 240); // the exact totals of the two results
  assert.equal(c.calls, 3);
  assert.equal(u.totals.elevenlabs.credits, 100 + 50 + 330 + 0 + 40); // flash half price; cache hits and the failed call are free
  const kinds = u.by_model.map((m) => `${m.provider}:${m.kind}:${m.model}`).sort();
  assert.ok(kinds.includes('claude:quick call:claude-haiku-4-5'));
  assert.ok(kinds.includes('claude:session:claude-opus-5-5'));
  assert.ok(kinds.includes('elevenlabs:music:music_v2_5'));
  assert.ok(kinds.includes('elevenlabs:sfx:null'));
  assert.equal(u.by_project[0].project, P);
  assert.equal(JSON.stringify(u).match(/cost|usd|characters|\$/i), null);
  assert.equal(readFileSync(ledgerFile(root), 'utf8').match(/cost|usd/i), null);
  // booking the same run again, or backfilling again, adds nothing
  const n = readRows(root).length;
  await bookSession(root, P, '2026-11-01T09-00-00-000Z', {});
  _forget();
  await backfillDone(root);
  assert.equal(readRows(root).length, n);
});

test('live rows: voice line, quick Claude calls, API call; records, streak, series, filters', async (t) => {
  const root = studio(t);
  seed(root);
  await backfillDone(root);
  const before = readRows(root).length;
  logVoiceUse(join(paths(root).projects, Q), { engine: 'elevenlabs', model: 'eleven_v4', line: 'a', characters: 70, credits: 70 });
  logVoiceUse(join(paths(root).projects, Q), { engine: 'qwen', voice: 'x', lines: 1, seconds: 2 }); // free: not booked
  recordClaudeJson(root, Q, { is_error: false, modelUsage: { 'claude-haiku-4-5': { inputTokens: 3, outputTokens: 4, cacheReadInputTokens: 5, cacheCreationInputTokens: 6 } } }, { role: 'options' });
  recordApiMessage(root, null, { model: 'claude-sonnet-5-5', usage: { input_tokens: 1, output_tokens: 2 } }, { role: 'name' });
  record(root, { provider: 'claude', project: P, kind: 'session', model: 'claude-opus-5-5', input_tokens: 1, output_tokens: 1, ok: false, at: '2026-10-01T00:00:00Z' });
  const rows = readRows(root).slice(before);
  assert.equal(rows.length, 4);
  assert.equal(rows[0].project, Q);
  assert.equal(rows[0].stage, 'voice');
  assert.equal(rows[1].role, 'options');
  assert.equal(rows[1].cache_write_tokens, 6);
  assert.equal(rows[2].project, null);
  assert.equal(rows[3].ok, false);

  const now = Date.parse('2026-11-02T12:00:00');
  const all = await usageGet(root, { project: P }, { now });
  assert.equal(all.series.length, 30);
  assert.equal(all.series.at(-1).date, '2026-11-02');
  assert.equal(all.series[0].date, '2026-10-04');
  assert.ok(all.records.longest_streak.days >= 1);
  assert.equal(all.records.biggest_call.elevenlabs.credits, 330);
  assert.ok(all.records.biggest_call.claude.cache_read_tokens >= 2000 || all.records.biggest_call.claude.input_tokens > 0);
  assert.equal(all.records.biggest_project.elevenlabs.project, P);
  assert.ok(all.records.biggest_day.elevenlabs.elevenlabs.credits > 0);
  const today = await usageGet(root, { range: 'today', project: P }, { now: Date.parse('2026-11-02T20:00:00') });
  assert.equal(today.totals.elevenlabs.credits, 40); // only the sound effect, made on the 2nd
  assert.equal(today.totals.claude.rows, 0);
  const week = await usageGet(root, { range: 'week' }, { now });
  assert.ok(week.totals.elevenlabs.credits > 0);
  await assert.rejects(usageGet(root, { range: 'year' }), /range must be/);
});

test('streak: consecutive days, current streak counts through yesterday', async (t) => {
  const root = studio(t);
  for (const d of ['2026-10-28', '2026-10-29', '2026-10-30', '2026-11-01']) record(root, { provider: 'elevenlabs', kind: 'sfx', credits: 1, at: `${d}T12:00:00` });
  const u = await usageGet(root, {}, { now: Date.parse('2026-11-02T12:00:00') });
  assert.deepEqual(u.records.longest_streak, { days: 3, from: '2026-10-28', to: '2026-10-30', current: 1 });
});

test('ElevenLabs balance: from the subscription endpoint, cached 10 minutes, null with a reason otherwise', async (t) => {
  const root = studio(t);
  const now = Date.parse('2026-11-02T12:00:00Z');
  const none = await usageGet(root, {}, { now, fetch: async () => { throw new Error('no network call expected'); } });
  assert.equal(none.elevenlabs_balance, null);
  assert.match(none.elevenlabs_balance_why, /no ElevenLabs API key/);
  writeSecret(root, 'elevenlabs_api_key', 'k');
  let calls = 0;
  let fail = false;
  const fetch = async (url, init) => {
    calls++;
    assert.equal(String(url), 'https://api.elevenlabs.io/v1/user/subscription');
    assert.equal(init.headers['xi-api-key'], 'k');
    if (fail) return { ok: false, status: 500 };
    return { ok: true, json: async () => ({ tier: 'creator', character_count: 1200, character_limit: 100000, next_character_count_reset_unix: 1796000000 }) };
  };
  const a = await usageGet(root, {}, { now, fetch });
  assert.equal(a.elevenlabs_balance.remaining, 98800);
  assert.equal(a.elevenlabs_balance.limit, 100000);
  assert.equal(a.elevenlabs_balance.resets_at, new Date(1796000000 * 1000).toISOString());
  await usageGet(root, {}, { now: now + 5 * 60_000, fetch });
  assert.equal(calls, 1);
  fail = true;
  const stale = await usageGet(root, {}, { now: now + 11 * 60_000, fetch });
  assert.equal(calls, 2);
  assert.equal(stale.elevenlabs_balance.stale, true);
  assert.equal(stale.elevenlabs_balance.remaining, 98800);
  assert.match(stale.elevenlabs_balance_why, /could not refresh/);
});

test('service: usage.get handler and one debounced usage.changed per burst', async (t) => {
  const root = studio(t);
  seed(root);
  const out = [];
  const svc = createService({ root, send: (m) => out.push(m), runner: false, tickMs: 0, fetch: async () => { throw new Error('offline'); } });
  t.after(() => svc.close());
  await svc.handle({ id: 1, type: 'usage.get', params: { range: 'all' } });
  const r = out.find((m) => m.id === 1);
  assert.equal(r.ok, true);
  assert.ok(r.result.totals.claude.total_tokens > 0);
  await svc.handle({ id: 2, type: 'usage.get', params: { range: 'nope' } });
  assert.equal(out.find((m) => m.id === 2).error.code, 'bad_request');
  record(root, { provider: 'elevenlabs', kind: 'sfx', credits: 1, project: P });
  record(root, { provider: 'elevenlabs', kind: 'sfx', credits: 2, project: P });
  record(root, { provider: 'elevenlabs', kind: 'music', credits: 3, project: Q });
  assert.equal(out.filter((m) => m.event === 'usage.changed').length, 0);
  await sleep(1300);
  const ev = out.filter((m) => m.event === 'usage.changed');
  assert.equal(ev.length, 1);
  assert.equal(ev[0].data.project, Q);
  assert.ok(existsSync(ledgerFile(root)));
});

test('session booking is incremental and never double counts; a crash keeps what was booked', async (t) => {
  const root = studio(t);
  const run = '2026-11-02T09-00-00-000Z';
  const f = join(paths(root).state, P, 'sessions', `${run}.jsonl`);
  const asst = (mid, usage) => J({ type: 'assistant', message: { id: mid, model: 'claude-opus-5-5', usage, content: [{ type: 'text', text: 'x'.repeat(40) }] } });
  writeFileSync(f, J({ type: 'system', subtype: 'init', model: 'claude-opus-5-5', tools: ['Bash'] }) + asst('a', { input_tokens: 10, cache_read_input_tokens: 100, output_tokens: 1 }));
  await backfillDone(root);
  const sum = () => readRows(root).filter((r) => r.provider === 'claude').reduce((a, r) => a + r.input_tokens + r.cache_read_tokens, 0);
  assert.equal((await bookSession(root, P, run, { stage: 'script' })).length, 1);
  assert.equal(sum(), 110);
  assert.equal((await bookSession(root, P, run)).length, 0); // nothing new
  appendFileSync(f, asst('b', { input_tokens: 5, cache_read_input_tokens: 200, output_tokens: 1 }));
  assert.equal((await bookSession(root, P, run)).length, 1); // the new call only: a crash here lost nothing before it
  assert.equal(sum(), 315);
  appendFileSync(f, J({ type: 'result', usage: { output_tokens: 90 } }));
  await bookSession(root, P, run);
  assert.equal(sum(), 315); // the end books only what is left (the output total), never the input twice
  const u = await usageGet(root, {});
  assert.equal(u.totals.claude.input_tokens, 15);
  assert.equal(u.totals.claude.calls, 2);
  assert.ok(u.totals.claude.output_tokens >= 2);
});

test('session-side scripts append ledger rows; the service notices them; real header beats the estimate', async (t) => {
  const root = studio(t);
  seed(root);
  const out = [];
  const svc = createService({ root, send: (m) => out.push(m), runner: false, tickMs: 0, usagePollMs: 100 });
  t.after(() => svc.close());
  await svc.handle({ id: 1, type: 'usage.get', params: {} });
  const base = out.find((m) => m.id === 1).result.totals.elevenlabs.credits;
  const work = join(paths(root).projects, P);
  const env = { MFX_LEDGER: ledgerFile(root), MFX_PROJECT: P };
  assert.equal(bookSpend({ kind: 'tts', model: 'eleven_v4', credits: costHeader({ headers: new Headers({ 'character-cost': '42' }) }), cwd: work, env }), true);
  assert.equal(bookSpend({ kind: 'scribe check', model: 'scribe_v2', credits: null, seconds: 6, cwd: work, env: {} }), true); // project and ledger from the folder
  assert.equal(bookSpend({ kind: 'sfx', credits: 20, estimated: true, cwd: '/tmp', env: {} }), false); // not in a studio: nothing written
  await sleep(1500);
  assert.equal(out.filter((m) => m.event === 'usage.changed').length, 1);
  const u = await usageGet(root, {});
  assert.equal(u.totals.elevenlabs.credits, base + 42);
  const rows = readRows(root).filter((r) => r.id?.startsWith('el:'));
  assert.equal(rows.length, 2);
  assert.equal(rows[0].estimated, undefined);
  assert.equal(rows[0].stage, 'voice');
  assert.equal(rows[1].credits_unknown, true);
  assert.equal(rows[1].project, P);
  // in-process rows after a foreign append still count (the cache reloads)
  record(root, { provider: 'elevenlabs', kind: 'sfx', credits: 1, project: P });
  assert.equal(readFileSync(ledgerFile(root), 'utf8').trim().split('\n').length, readRows(root).length);
});