@remixmate/cli 0.9.72 → 0.9.74

package/dist/auth/device-flow.js

@@ -1,132 +1 @@
-/**
- * OAuth 2.0 Device Authorization Grant (RFC 8628) client for `remixmate login`.
- *
- * The device/code and device/token endpoints are PUBLIC (no auth), so this uses
- * plain fetch against the ab-api base URL rather than the authenticated mmPost.
- * On approval the backend returns the user's existing PrivToken (Route B).
- */
-import { spawn } from 'node:child_process';
-export class DeviceFlowError extends Error {
-}
-async function postJson(url, body, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        let resp;
-        try {
-            resp = await fetch(url, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-        }
-        catch (err) {
-            // A DNS/TCP/TLS failure or an abort rejects with a plain Error. Left
-            // unwrapped it escapes runDeviceFlow's DeviceFlowError handler and
-            // surfaces to the user as a raw stack trace.
-            const reason = err instanceof Error && err.name === 'AbortError'
-                ? `请求超时（${Math.round(timeoutMs / 1000)}s）`
-                : err.message;
-            throw new DeviceFlowError(`无法连接授权服务 ${url}: ${reason}`);
-        }
-        const text = await resp.text();
-        if (!resp.ok) {
-            throw new DeviceFlowError(`HTTP ${resp.status}: ${text.slice(0, 200)}`);
-        }
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            throw new DeviceFlowError(`授权服务返回了非 JSON 响应: ${text.slice(0, 200)}`);
-        }
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-/** Request a fresh device_code/user_code. 30s timeout, no retries here. */
-export async function requestDeviceCode(apiBaseUrl, clientLabel) {
-    const env = await postJson(`${apiBaseUrl}/auth/device/code`, { clientLabel }, 30_000);
-    if (env.code !== 0 || !env.data) {
-        throw new DeviceFlowError(env.msg || 'failed to obtain device code');
-    }
-    return env.data;
-}
-/**
- * Try to open `url` in the default browser. Returns false when no opener is
- * available (caller then prints the URL for manual entry).
- */
-export function openBrowser(url) {
-    const cmd = process.platform === 'darwin' ? 'open' :
-        process.platform === 'win32' ? 'cmd' :
-            'xdg-open';
-    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-    try {
-        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
-        child.on('error', () => { });
-        child.unref();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Poll device/token until a terminal outcome. Honors `interval` (+5s on
- * slow_down), retries transient network failures up to 3 consecutive times, and
- * bounds total time by the device code's `expiresIn`.
- *
- * When `opts.maxWaitMs` is supplied, polling also stops once that window
- * elapses (whichever comes first). A stop caused by `maxWaitMs` returns
- * `{ status: 'expired_token', timedOut: true }` so callers can tell a
- * short-wait timeout apart from a genuinely expired device code.
- *
- * Resolves with the final TokenResult (status 'approved' carries the token).
- */
-export async function pollForToken(apiBaseUrl, code, opts = {}) {
-    const expiryDeadline = Date.now() + code.expiresIn * 1000;
-    const waitDeadline = opts.maxWaitMs != null ? Date.now() + opts.maxWaitMs : Number.POSITIVE_INFINITY;
-    const deadline = Math.min(expiryDeadline, waitDeadline);
-    let intervalMs = Math.max(code.interval, 1) * 1000;
-    let consecutiveErrors = 0;
-    // Wait one interval before the first poll (approval can't have happened yet).
-    await sleep(intervalMs);
-    while (Date.now() < deadline) {
-        let env;
-        try {
-            env = await postJson(`${apiBaseUrl}/auth/device/token`, { deviceCode: code.deviceCode }, 15_000);
-            consecutiveErrors = 0;
-        }
-        catch (err) {
-            consecutiveErrors += 1;
-            if (consecutiveErrors >= 3) {
-                throw new DeviceFlowError(`polling failed: ${err.message}`);
-            }
-            await sleep(intervalMs);
-            continue;
-        }
-        if (env.code !== 0 || !env.data) {
-            throw new DeviceFlowError(env.msg || 'unexpected token response');
-        }
-        const result = env.data;
-        switch (result.status) {
-            case 'approved':
-            case 'access_denied':
-            case 'expired_token':
-            case 'invalid_grant':
-                return result;
-            case 'slow_down':
-                intervalMs += 5_000;
-                break;
-            case 'authorization_pending':
-            default:
-                break;
-        }
-        await sleep(intervalMs);
-    }
-    // Stopped on the wait window rather than the code's own expiry.
-    const timedOut = waitDeadline <= expiryDeadline;
-    return { status: 'expired_token', timedOut };
-}
+var f=Object.defineProperty;var s=(e,t)=>f(e,"name",{value:t,configurable:!0});import{spawn as x}from"node:child_process";class c extends Error{static{s(this,"DeviceFlowError")}}async function m(e,t,n){const o=new AbortController,l=setTimeout(()=>o.abort(),n);try{let i;try{i=await fetch(e,{method:"POST",headers:{"Content-Type":"application/json",Accept:"application/json"},body:JSON.stringify(t),signal:o.signal})}catch(a){const w=a instanceof Error&&a.name==="AbortError"?`请求超时（${Math.round(n/1e3)}s）`:a.message;throw new c(`无法连接授权服务 ${e}: ${w}`)}const r=await i.text();if(!i.ok)throw new c(`HTTP ${i.status}: ${r.slice(0,200)}`);try{return JSON.parse(r)}catch{throw new c(`授权服务返回了非 JSON 响应: ${r.slice(0,200)}`)}}finally{clearTimeout(l)}}s(m,"postJson");const p=s(e=>new Promise(t=>setTimeout(t,e)),"sleep");async function y(e,t){const n=await m(`${e}/auth/device/code`,{clientLabel:t},3e4);if(n.code!==0||!n.data)throw new c(n.msg||"failed to obtain device code");return n.data}s(y,"requestDeviceCode");function T(e){const t=process.platform==="darwin"?"open":process.platform==="win32"?"cmd":"xdg-open",n=process.platform==="win32"?["/c","start","",e]:[e];try{const o=x(t,n,{stdio:"ignore",detached:!0});return o.on("error",()=>{}),o.unref(),!0}catch{return!1}}s(T,"openBrowser");async function _(e,t,n={}){const o=Date.now()+t.expiresIn*1e3,l=n.maxWaitMs!=null?Date.now()+n.maxWaitMs:Number.POSITIVE_INFINITY,i=Math.min(o,l);let r=Math.max(t.interval,1)*1e3,a=0;for(await p(r);Date.now()<i;){let d;try{d=await m(`${e}/auth/device/token`,{deviceCode:t.deviceCode},15e3),a=0}catch(h){if(a+=1,a>=3)throw new c(`polling failed: ${h.message}`);await p(r);continue}if(d.code!==0||!d.data)throw new c(d.msg||"unexpected token response");const u=d.data;switch(u.status){case"approved":case"access_denied":case"expired_token":case"invalid_grant":return u;case"slow_down":r+=5e3;break;default:break}await p(r)}return{status:"expired_token",timedOut:l<=o}}s(_,"pollForToken");export{c as DeviceFlowError,T as openBrowser,_ as pollForToken,y as requestDeviceCode};

package/dist/auth/ensure.js

@@ -1,62 +1 @@
-/**
- * The single authorization entry point for every skill invocation.
- *
- * Before this module the CLI resolved PrivTokens in three unrelated places:
- * `resolveHttpContext` (4 TS handlers, with credential store + auto device
- * login), `registry_loader.py` (1 Python skill, with its own credential-file
- * reader), and plain `os.environ["PRIV_TOKEN"]` (the other 7 Python skills,
- * which therefore ignored `remixmate login` entirely). Auto browser auth only
- * ever covered the first group.
- *
- * Now `runner.ts` calls `ensureAuth()` once, before dispatch, for every skill —
- * so the credential store, the OS keychain and the device flow exist in exactly
- * one place (Node), and Python scripts only ever read an injected `PRIV_TOKEN`.
- */
-import { resolveApiBaseUrl } from '../http.js';
-import { EXIT, SkillError } from '../errors.js';
-import { resolvePrivToken, NOT_AUTHENTICATED_HINT } from './resolve.js';
-import { attemptAutoLogin } from './auto-login.js';
-export const AUTH_MODE_VALUES = ['required', 'optional', 'none'];
-/**
- * Resolve (and if necessary acquire) a PrivToken for one skill invocation.
- * Throws SkillError(exit 4) when `mode === 'required'` and no token could be
- * obtained; the message is the shared NOT_AUTHENTICATED_HINT.
- */
-export async function ensureAuth(opts) {
-    const apiBaseUrl = resolveApiBaseUrl(opts.apiBaseUrl);
-    if (opts.mode === 'none')
-        return { apiBaseUrl };
-    let resolved = await resolvePrivToken({ flag: opts.flagToken, apiBaseUrl });
-    // Browser authorization is only ever attempted for `required`. attemptAutoLogin
-    // self-gates on CI / headless / kill-switch, so the env-injected cloud path
-    // returns here untouched.
-    if (!resolved && opts.mode === 'required') {
-        resolved = await attemptAutoLogin(apiBaseUrl);
-    }
-    if (!resolved) {
-        if (opts.mode === 'optional')
-            return { apiBaseUrl };
-        throw new SkillError(NOT_AUTHENTICATED_HINT, EXIT.NOT_AUTHENTICATED);
-    }
-    return {
-        apiBaseUrl,
-        token: resolved.privToken,
-        source: resolved.source,
-        userLabel: resolved.userLabel,
-    };
-}
-/**
- * Environment overrides handed to a spawned Python skill.
- *
- * `MM_API_BASE_URL` is always set so the child resolves the same backend the
- * preflight authenticated against — otherwise a `--api-base-url` flag or a
- * credential bound to a staging backend would silently disagree with the URL
- * the Python side derives. `PRIV_TOKEN` is only set when non-empty, so an
- * `optional` skill without a credential keeps inheriting whatever the host set.
- */
-export function authChildEnv(pre) {
-    const env = { MM_API_BASE_URL: pre.apiBaseUrl };
-    if (pre.token)
-        env.PRIV_TOKEN = pre.token;
-    return env;
-}
+var t=Object.defineProperty;var n=(e,r)=>t(e,"name",{value:r,configurable:!0});import{resolveApiBaseUrl as i}from"../http.js";import{EXIT as a,SkillError as l}from"../errors.js";import{resolvePrivToken as u,NOT_AUTHENTICATED_HINT as T}from"./resolve.js";import{attemptAutoLogin as f}from"./auto-login.js";const U=["required","optional","none"];async function _(e){const r=i(e.apiBaseUrl);if(e.mode==="none")return{apiBaseUrl:r};let o=await u({flag:e.flagToken,apiBaseUrl:r});if(!o&&e.mode==="required"&&(o=await f(r)),!o){if(e.mode==="optional")return{apiBaseUrl:r};throw new l(T,a.NOT_AUTHENTICATED)}return{apiBaseUrl:r,token:o.privToken,source:o.source,userLabel:o.userLabel}}n(_,"ensureAuth");function c(e){const r={MM_API_BASE_URL:e.apiBaseUrl};return e.token&&(r.PRIV_TOKEN=e.token),r}n(c,"authChildEnv");export{U as AUTH_MODE_VALUES,c as authChildEnv,_ as ensureAuth};

package/dist/auth/environment.js

@@ -1,69 +1 @@
-/**
- * Pure environment predicates that gate the auto device-login feature.
- *
- * Everything here is synchronous, side-effect free, never touches the network
- * and never reads a PrivToken. The conservative bias is: when in doubt, treat
- * the environment as headless so we fail fast rather than pop a useless browser.
- *
- * See .kiro/specs/cli-auto-device-login/design.md (Requirement 1.4–1.7).
- */
-/** Total kill switch: hosts can force-disable auto auth and fall back to fail-fast. */
-export function autoAuthDisabled() {
-    return (process.env.REMIXMATE_NO_BROWSER_AUTH ?? '').trim() === '1';
-}
-/** Heuristic detection of common CI environments (no desktop → headless). */
-function isCI() {
-    const e = process.env;
-    return !!(e.CI ||
-        e.CONTINUOUS_INTEGRATION ||
-        e.GITHUB_ACTIONS ||
-        e.GITLAB_CI ||
-        e.BUILDKITE ||
-        e.CIRCLECI ||
-        e.TRAVIS ||
-        e.JENKINS_URL);
-}
-/**
- * Whether the process is likely running without a desktop session capable of
- * opening a browser.
- *
- *   - CI environments are always treated as headless.
- *   - On Linux a browser needs an X11 / Wayland display; absence → headless.
- *   - macOS / Windows are assumed to have a GUI session available.
- */
-export function isHeadless() {
-    if (isCI())
-        return true;
-    if (process.platform === 'linux') {
-        return !((process.env.DISPLAY ?? '').trim() || (process.env.WAYLAND_DISPLAY ?? '').trim());
-    }
-    return false;
-}
-/**
- * Master gate for auto authorization. Only true when auto auth is not disabled
- * AND the environment can plausibly open a browser for the user.
- */
-export function canAutoAuth() {
-    return !autoAuthDisabled() && !isHeadless();
-}
-/**
- * Whether the CLI is being driven by an agent host (Claude Code / Codex /
- * ab-agent) rather than typed by a human at a terminal.
- *
- * Used to decide (a) whether to emit the machine-readable AUTH_REQUIRED block
- * alongside the human text, and (b) whether an interactive `login` may block
- * for the device code's full lifetime — an agent's tool call is time-bounded,
- * so it must get a bounded, resumable wait instead.
- *
- * Detection is deliberately loose: a piped stdout is the reliable signal, the
- * env markers just make the intent explicit for hosts that allocate a pty.
- */
-export function isAgentHost() {
-    const e = process.env;
-    if ((e.CLAUDECODE ?? '').trim() || (e.CLAUDE_CODE ?? '').trim() || (e.CODEX_SANDBOX ?? '').trim()) {
-        return true;
-    }
-    if ((e.AGENT_NAME ?? '').trim())
-        return true;
-    return !process.stdout.isTTY;
-}
+var n=Object.defineProperty;var t=(r,e)=>n(r,"name",{value:e,configurable:!0});function s(){return(process.env.REMIXMATE_NO_BROWSER_AUTH??"").trim()==="1"}t(s,"autoAuthDisabled");function o(){const r=process.env;return!!(r.CI||r.CONTINUOUS_INTEGRATION||r.GITHUB_ACTIONS||r.GITLAB_CI||r.BUILDKITE||r.CIRCLECI||r.TRAVIS||r.JENKINS_URL)}t(o,"isCI");function u(){return o()?!0:process.platform==="linux"?!((process.env.DISPLAY??"").trim()||(process.env.WAYLAND_DISPLAY??"").trim()):!1}t(u,"isHeadless");function A(){return!s()&&!u()}t(A,"canAutoAuth");function I(){const r=process.env;return(r.CLAUDECODE??"").trim()||(r.CLAUDE_CODE??"").trim()||(r.CODEX_SANDBOX??"").trim()||(r.AGENT_NAME??"").trim()?!0:!process.stdout.isTTY}t(I,"isAgentHost");export{s as autoAuthDisabled,A as canAutoAuth,I as isAgentHost,u as isHeadless};

package/dist/auth/pending-store.js

@@ -1,45 +1 @@
-/**
- * Pending device-authorization state, at ~/.config/remixmate/pending.json.
- *
- * Exists so authorization can outlive a single process. `login --start` requests
- * a device code, persists it and returns immediately; `login --wait` picks it up
- * and polls with a bounded window, as many times as needed. That split is what
- * makes authorization workable from an agent host, whose tool calls are
- * time-bounded and cannot sit on a 10-minute blocking poll.
- *
- * The device_code IS a short-lived bearer secret (it can be exchanged for the
- * PrivToken until it expires or is used), so the file is written 0600 like the
- * credential store, and is deleted as soon as it is redeemed or found expired.
- */
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { promises as fs } from 'node:fs';
-const PENDING_DIR = join(homedir(), '.config', 'remixmate');
-export const PENDING_FILE = join(PENDING_DIR, 'pending.json');
-export async function setPending(pending) {
-    await fs.mkdir(PENDING_DIR, { recursive: true, mode: 0o700 });
-    await fs.writeFile(PENDING_FILE, JSON.stringify(pending, null, 2), { mode: 0o600 });
-    await fs.chmod(PENDING_FILE, 0o600);
-}
-/**
- * Read the pending authorization for `apiBaseUrl`. Returns null when absent,
- * unreadable, bound to a different backend, or already expired — callers then
- * tell the user to run `login --start` again.
- */
-export async function getPending(apiBaseUrl) {
-    let parsed;
-    try {
-        parsed = JSON.parse(await fs.readFile(PENDING_FILE, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-    if (!parsed?.deviceCode || parsed.apiBaseUrl !== apiBaseUrl)
-        return null;
-    if (!(parsed.expiresAt > Date.now()))
-        return null;
-    return parsed;
-}
-export async function clearPending() {
-    await fs.rm(PENDING_FILE, { force: true });
-}
+var s=Object.defineProperty;var i=(r,e)=>s(r,"name",{value:e,configurable:!0});import{homedir as c}from"node:os";import{join as o}from"node:path";import{promises as t}from"node:fs";const a=o(c(),".config","remixmate"),n=o(a,"pending.json");async function l(r){await t.mkdir(a,{recursive:!0,mode:448}),await t.writeFile(n,JSON.stringify(r,null,2),{mode:384}),await t.chmod(n,384)}i(l,"setPending");async function p(r){let e;try{e=JSON.parse(await t.readFile(n,"utf8"))}catch{return null}return!e?.deviceCode||e.apiBaseUrl!==r||!(e.expiresAt>Date.now())?null:e}i(p,"getPending");async function g(){await t.rm(n,{force:!0})}i(g,"clearPending");export{n as PENDING_FILE,g as clearPending,p as getPending,l as setPending};

package/dist/auth/resolve.js

@@ -1,44 +1 @@
-/**
- * Single source of truth for PrivToken resolution precedence, shared by the
- * CLI commands and the HTTP layer (src/http.ts wires this in — Wave 2 task 4.3).
- *
- * Precedence (high → low), per requirements 7.1–7.4:
- *   1. explicit --token flag (caller override)
- *   2. PRIV_TOKEN environment variable  (CI / agent-embedded hosts)
- *   3. Credential_Store entry for the active API base URL (written by `login`)
- *
- * A value that is empty after trimming whitespace is treated as ABSENT, so an
- * exported-but-empty `PRIV_TOKEN=""` falls through to the credential store
- * rather than masking it.
- */
-import { getCredential } from './credential-store.js';
-/** Trim and return undefined when empty, so empty == absent everywhere. */
-function clean(value) {
-    if (value == null)
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-/**
- * Resolve the PrivToken following the documented precedence. Returns null when
- * no source yields a token (callers render the not-authenticated message).
- */
-export async function resolvePrivToken(opts) {
-    const flag = clean(opts.flag);
-    if (flag)
-        return { privToken: flag, source: 'flag' };
-    const env = clean(process.env.PRIV_TOKEN);
-    if (env)
-        return { privToken: env, source: 'env' };
-    const stored = await getCredential(opts.apiBaseUrl);
-    if (stored && clean(stored.privToken)) {
-        return {
-            privToken: stored.privToken,
-            source: 'credential-store',
-            userLabel: stored.userLabel,
-        };
-    }
-    return null;
-}
-/** Human-readable hint shown when resolution fails (no token echoed). */
-export const NOT_AUTHENTICATED_HINT = '❌ not authenticated — run `remixmate login`, set PRIV_TOKEN, or pass --token';
+var s=Object.defineProperty;var t=(e,n)=>s(e,"name",{value:n,configurable:!0});import{getCredential as u}from"./credential-store.js";function o(e){if(e==null)return;const n=e.trim();return n.length>0?n:void 0}t(o,"clean");async function l(e){const n=o(e.flag);if(n)return{privToken:n,source:"flag"};const i=o(process.env.PRIV_TOKEN);if(i)return{privToken:i,source:"env"};const r=await u(e.apiBaseUrl);return r&&o(r.privToken)?{privToken:r.privToken,source:"credential-store",userLabel:r.userLabel}:null}t(l,"resolvePrivToken");const T="❌ not authenticated — run `remixmate login`, set PRIV_TOKEN, or pass --token";export{T as NOT_AUTHENTICATED_HINT,l as resolvePrivToken};

package/dist/billing.js

@@ -1,76 +1,3 @@
-/**
- * Billing capture — makes credit consumption visible to whoever ran the skill.
- *
- * Credits are deducted server-side and used to be invisible here: a run printed
- * its image/video URL and nothing else, so the first time a user noticed the
- * credit system at all was the `insufficient_credits` error after the balance
- * had already run out. ab-api now attaches a `billing` object to the envelope of
- * every response that charged something (see core.Success / credits_billing.go);
- * this module accumulates those across all the calls a single skill run makes —
- * a gen-image run polls, a gen-video run polls, and each may charge once — and
- * renders one footer at the end.
- *
- * Two outputs, two audiences, both on stdout:
- *   - a human-readable footer, which is what the agent relays to the user.
- *   - one `__progress__` line (phase `billing`) — the existing machine protocol,
- *     already parsed by ab-agent's executor and skipped by the line-scanning
- *     parsers in render_video.py, so a nested pipeline caller can aggregate a
- *     whole run's spend without a new stdout contract.
- *
- * Both go to stdout rather than stderr (where the auth footer lives) because
- * ab-agent hands the LLM `result.stdout || result.stderr` (mcp-tools.ts) — a
- * stderr-only footer would be invisible in the hosted agent, visible only when
- * a local host like codex shows both streams. Adding stdout lines is safe:
- * emitProgress already writes NDJSON there, so no consumer can be treating
- * stdout as a single JSON document.
- */
-import { emitProgress } from './progress.js';
-let creditsCharged = 0;
-let latestBalance = null;
-const chargedItems = [];
-/** Accumulate one response's billing object; no-ops on responses that charged nothing. */
-export function recordBilling(billing) {
-    if (!billing || typeof billing.credits !== 'number' || billing.credits <= 0)
-        return;
-    creditsCharged += billing.credits;
-    if (typeof billing.balance === 'number')
-        latestBalance = billing.balance;
-    for (const item of billing.items ?? []) {
-        if (item && typeof item.credits === 'number' && item.credits > 0)
-            chargedItems.push(item);
-    }
-}
-/** Everything charged so far in this process, or null when nothing was. */
-export function billingSummary() {
-    if (creditsCharged <= 0)
-        return null;
-    return { credits: creditsCharged, balance: latestBalance ?? 0, items: [...chargedItems] };
-}
-/**
- * Emit the footer for what this process charged. Safe to call on the error path
- * too: a run can fail after a successful (already billed) generation step, and
- * that spend still needs to be reported.
- *
- * Idempotent — only the first call prints, so a handler and the dispatcher can
- * both reach for it without doubling the number the user sees.
- */
-let emitted = false;
-export function emitBillingFooter() {
-    if (emitted)
-        return;
-    const summary = billingSummary();
-    if (!summary)
-        return;
-    emitted = true;
-    emitProgress({ phase: 'billing', credits: summary.credits, balance: summary.balance, items: summary.items });
-    const balance = summary.balance.toLocaleString('en-US');
-    const credits = summary.credits.toLocaleString('en-US');
-    process.stdout.write(`\n💳 Charged ${credits} credits · balance ${balance}\n`);
-}
-/** Test seam — resets the accumulator between runs in-process. */
-export function resetBilling() {
-    creditsCharged = 0;
-    latestBalance = null;
-    chargedItems.length = 0;
-    emitted = false;
-}
+var a=Object.defineProperty;var r=(e,t)=>a(e,"name",{value:t,configurable:!0});import{emitProgress as l}from"./progress.js";let n=0,c=null;const s=[];function m(e){if(!(!e||typeof e.credits!="number"||e.credits<=0)){n+=e.credits,typeof e.balance=="number"&&(c=e.balance);for(const t of e.items??[])t&&typeof t.credits=="number"&&t.credits>0&&s.push(t)}}r(m,"recordBilling");function u(){return n<=0?null:{credits:n,balance:c??0,items:[...s]}}r(u,"billingSummary");let i=!1;function p(){if(i)return;const e=u();if(!e)return;i=!0,l({phase:"billing",credits:e.credits,balance:e.balance,items:e.items});const t=e.balance.toLocaleString("en-US"),o=e.credits.toLocaleString("en-US");process.stdout.write(`
+💳 Charged ${o} credits · balance ${t}
+`)}r(p,"emitBillingFooter");function b(){n=0,c=null,s.length=0,i=!1}r(b,"resetBilling");export{u as billingSummary,p as emitBillingFooter,m as recordBilling,b as resetBilling};

package/dist/capabilities.js

@@ -1,75 +1 @@
-/**
- * Model capabilities client.
- *
- * The model roster — internal model ids, friendly aliases, defaults, and each
- * model's parameter constraints (aspect ratios / resolutions / durations /
- * reference-image caps / Seedream size presets) — is owned by ab-api and served
- * from POST /model/capabilities (public, no auth). The CLI fetches it at runtime
- * instead of hardcoding it, so this npm package never ships the internal model
- * matrix or provider details, and validation can't drift from the backend.
- *
- * Fetched once per process and memoized; the catalog is static server-side.
- */
-import { resolveApiBaseUrl, SkillError } from './http.js';
-let cached = null;
-/** Fetch (and memoize) the model capabilities catalog from ab-api. */
-export async function getCapabilities(apiBaseUrl) {
-    if (cached)
-        return cached;
-    const base = resolveApiBaseUrl(apiBaseUrl);
-    const url = `${base}/model/capabilities`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 15_000);
-    let resp;
-    try {
-        resp = await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: '{}',
-            signal: controller.signal,
-        });
-    }
-    catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') {
-            throw new SkillError(`❌ request timed out fetching model capabilities: ${url}`);
-        }
-        throw new SkillError(`❌ network error fetching model capabilities: ${err.message}`);
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-    const text = await resp.text();
-    if (!resp.ok) {
-        throw new SkillError(`❌ failed to fetch model capabilities (HTTP ${resp.status}): ${text}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        throw new SkillError(`❌ model capabilities response is not JSON: ${text.slice(0, 200)}`);
-    }
-    if (parsed.code !== 0 || !parsed.data) {
-        throw new SkillError(`❌ model capabilities request failed: ${parsed.msg ?? 'unknown error'} (code=${parsed.code})`);
-    }
-    cached = parsed.data;
-    return cached;
-}
-/**
- * Resolve a user-supplied model (friendly alias or full id) against a model
- * list. Returns the matched descriptor, or null when nothing matches.
- */
-export function matchModel(list, input) {
-    const key = input.trim().toLowerCase();
-    for (const m of list) {
-        if (m.id.toLowerCase() === key)
-            return m;
-        if ((m.aliases ?? []).some((a) => a.toLowerCase() === key))
-            return m;
-    }
-    return null;
-}
-/** The descriptor flagged `default` in a list, falling back to the first entry. */
-export function defaultModel(list) {
-    return list.find((m) => m.default) ?? list[0];
-}
+var u=Object.defineProperty;var s=(e,o)=>u(e,"name",{value:o,configurable:!0});import{resolveApiBaseUrl as m,SkillError as a}from"./http.js";let l=null;async function h(e){if(l)return l;const i=`${m(e)}/model/capabilities`,t=new AbortController,c=setTimeout(()=>t.abort(),15e3);let n;try{n=await fetch(i,{method:"POST",headers:{"Content-Type":"application/json"},body:"{}",signal:t.signal})}catch(f){throw f instanceof Error&&f.name==="AbortError"?new a(`❌ request timed out fetching model capabilities: ${i}`):new a(`❌ network error fetching model capabilities: ${f.message}`)}finally{clearTimeout(c)}const d=await n.text();if(!n.ok)throw new a(`❌ failed to fetch model capabilities (HTTP ${n.status}): ${d}`);let r;try{r=JSON.parse(d)}catch{throw new a(`❌ model capabilities response is not JSON: ${d.slice(0,200)}`)}if(r.code!==0||!r.data)throw new a(`❌ model capabilities request failed: ${r.msg??"unknown error"} (code=${r.code})`);return l=r.data,l}s(h,"getCapabilities");function b(e,o){const i=o.trim().toLowerCase();for(const t of e)if(t.id.toLowerCase()===i||(t.aliases??[]).some(c=>c.toLowerCase()===i))return t;return null}s(b,"matchModel");function $(e){return e.find(o=>o.default)??e[0]}s($,"defaultModel");export{$ as defaultModel,h as getCapabilities,b as matchModel};