@trillboards/cli 0.1.0 → 0.1.3

package/dist/commands/ads/start.js

@@ -0,0 +1,175 @@
+import { Flags } from '@oclif/core';
+import { ApiClient } from '@trillboards/ads-sdk';
+import { hostname } from 'node:os';
+import { BaseCommand } from '../../base-command.js';
+import { buildImaPlayerUrl, fetchVirtualScreenAds, isPlayableTagUrl, newImpressionId, registerVirtualScreen, reportTextAdEvent, sendVirtualScreenHeartbeat, } from '../../ads-client.js';
+import { updateConfig } from '../../config.js';
+import { colorize, osc8 } from '../../format-helpers.js';
+import { refreshUserTokenIfNeeded } from '../../user-auth.js';
+/** Default seconds between simulated dead-time fills (overridable via --interval). */
+const DEFAULT_INTERVAL_SECONDS = 60;
+/** Sanctioned, vetted text/announcement ad copy shown in the TTY (the video bills via the link). */
+const SANCTIONED_AD_LINE = 'Sponsored — your idle agent earned you a paid impression. Tap to play the video ad:';
+export default class AdsStart extends BaseCommand {
+    static description = 'Register this machine as a virtual screen and rent its AI-coding-agent dead-time for money';
+    static examples = [
+        '<%= config.bin %> ads start',
+        '<%= config.bin %> ads start --once',
+        '<%= config.bin %> ads start --simulate --interval 30',
+    ];
+    static flags = {
+        name: Flags.string({
+            description: 'Display name for this virtual screen (defaults to "Claude Code on <hostname>")',
+        }),
+        once: Flags.boolean({
+            default: false,
+            description: 'Register, heartbeat once, serve a single ad, then exit (great for testing)',
+        }),
+        simulate: Flags.boolean({
+            default: false,
+            description: 'Treat each interval tick as a dead-time trigger (v0 stand-in for real detection)',
+        }),
+        interval: Flags.integer({
+            description: `Seconds between dead-time fills in --simulate mode (default ${DEFAULT_INTERVAL_SECONDS})`,
+        }),
+    };
+    shuttingDown = false;
+    async run() {
+        const { flags } = await this.parse(AdsStart);
+        this.setParsedFlags(flags);
+        const baseUrl = this.getBaseUrl();
+        // ── Auth (user JWT, refreshed if stale) ───────────────────
+        const token = await refreshUserTokenIfNeeded(baseUrl);
+        if (!token) {
+            this.error('Not logged in. Run: trillboards ads login', { exit: 1 });
+        }
+        // ── Stable machine id (generated UUID, persisted) ─────────
+        // Imported lazily-by-value so tests can stub config; the id is durable.
+        const { getStableMachineId } = await import('../../machine-id.js');
+        const machineId = getStableMachineId();
+        const screenName = flags.name || `Claude Code on ${hostname()}`;
+        // ── Register the virtual screen ───────────────────────────
+        this.log(colorize('Trillboards agent-ads', 'bold'));
+        this.log('');
+        this.log(`Machine:  ${machineId}`);
+        this.log(`Screen:   ${screenName}`);
+        this.log('Registering virtual screen...');
+        let reg;
+        try {
+            reg = await registerVirtualScreen(baseUrl, token, machineId, screenName);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.error(`Registration failed: ${msg}\n\nIf your session expired, run: trillboards ads login`, { exit: 1 });
+        }
+        updateConfig({ screen_id: reg.screenId, device_id: reg.deviceId });
+        this.log(colorize(`Registered (screen ${reg.screenId}${reg.isReRegistration ? ', re-used existing' : ', new'}).`, 'green'));
+        this.log('');
+        // Reuse the SDK's ApiClient for the text-ad impression. Its reportImpression
+        // targets /v1/partner/impression which records cleanly for a partner-less
+        // virtual screen. apiBase is repointed to this run's base URL.
+        const sdk = new ApiClient(`${baseUrl.replace(/\/$/, '')}/v1/partner`);
+        const intervalMs = Math.max((flags.interval ?? DEFAULT_INTERVAL_SECONDS) * 1000, 1000);
+        const cleanup = () => {
+            this.shuttingDown = true;
+            this.log('\nStopped. Your virtual screen will go idle.');
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        // ── --once: single cycle for testing ──────────────────────
+        if (flags.once) {
+            await this.heartbeat(baseUrl, reg.screenId);
+            await this.serveOneAd(baseUrl, sdk, reg.screenId, reg.deviceId);
+            return;
+        }
+        // ── Long loop: heartbeat each tick; on dead-time, serve an ad ──
+        this.log(colorize(`Watching for dead-time (simulate=${flags.simulate ? 'on' : 'off'}). Press Ctrl+C to stop.`, 'dim'));
+        this.log('');
+        while (!this.shuttingDown) {
+            await this.heartbeat(baseUrl, reg.screenId);
+            // v0 dead-time trigger: in --simulate, every interval tick is dead-time.
+            // Without --simulate we still heartbeat (keeping the screen live) but only
+            // serve when a real detector fires (PR2). This keeps the trigger pluggable.
+            if (flags.simulate) {
+                await this.serveOneAd(baseUrl, sdk, reg.screenId, reg.deviceId);
+            }
+            await AdsStart.sleep(intervalMs);
+        }
+    }
+    static sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+    async heartbeat(baseUrl, screenId) {
+        const ok = await sendVirtualScreenHeartbeat(baseUrl, screenId);
+        const stamp = colorize(new Date().toISOString(), 'dim');
+        if (ok) {
+            this.log(`${stamp}  ${colorize('heartbeat', 'green')}  screen ${screenId}`);
+        }
+        else {
+            this.log(`${stamp}  ${colorize('heartbeat failed', 'yellow')}  screen ${screenId} (will retry)`);
+        }
+    }
+    /**
+     * One dead-time fill: fetch the web VAST tag, print the sanctioned text ad with
+     * an OSC-8 link to the billable hosted player, and fire the text-ad impression.
+     */
+    async serveOneAd(baseUrl, sdk, screenId, deviceId) {
+        let ad;
+        try {
+            ad = await fetchVirtualScreenAds(baseUrl, screenId);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log(`${colorize(new Date().toISOString(), 'dim')}  ${colorize('ad fetch error', 'red')}  ${msg}`);
+            return;
+        }
+        if (!ad.vastTagUrl) {
+            this.log(`${colorize(new Date().toISOString(), 'dim')}  ${colorize('no fill', 'yellow')}  (no programmatic demand right now)`);
+            // Report the no-fill so the screen's request telemetry is complete.
+            await reportTextAdEvent(baseUrl, {
+                screenId,
+                deviceId,
+                event: 'no_fill',
+                adid: newImpressionId(),
+                variantName: ad.variantName,
+            });
+            return;
+        }
+        const impressionId = newImpressionId();
+        const playerUrl = buildImaPlayerUrl(baseUrl, screenId, ad.vastTagUrl, deviceId, ad.variantName);
+        this.log('');
+        this.log(colorize('  ' + SANCTIONED_AD_LINE, 'bold'));
+        this.log('  ' + osc8(playerUrl, colorize('▶ Play sponsored video', 'green')));
+        this.log('  ' + colorize(playerUrl, 'dim'));
+        if (!isPlayableTagUrl(ad.vastTagUrl)) {
+            this.log('  ' +
+                colorize('(note: this tag host is not on the player allowlist; the link may show no video)', 'yellow'));
+        }
+        this.log('');
+        // Fire the text-ad impression via the SDK (records for the virtual screen),
+        // and report the programmatic request event via the public OpenRTB endpoint.
+        const [impressionOk] = await Promise.all([
+            sdk.reportImpression({
+                adid: impressionId,
+                impid: impressionId,
+                did: deviceId,
+                aid: screenId,
+                duration: 0,
+                completed: false,
+            }),
+            reportTextAdEvent(baseUrl, {
+                screenId,
+                deviceId,
+                event: 'request',
+                adid: impressionId,
+                variantName: ad.variantName,
+            }),
+        ]);
+        this.log(`${colorize(new Date().toISOString(), 'dim')}  ${colorize('served', 'green')}  ${ad.variantName ?? 'programmatic'}  impression=${impressionOk ? 'ok' : 'queued'}`);
+        this.log(colorize('  Open the link above to play the ad and earn the video impression.', 'dim'));
+        this.log('');
+    }
+}

package/dist/commands/code.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../base-command.js';
+/**
+ * Wrap a coding agent and earn from its dead-time. Runs the agent byte-transparent
+ * under a PTY; while it's "thinking", plays a text/image/VIDEO ad on a side surface
+ * (a tmux split pane on a video-capable terminal, else a spawned player window).
+ */
+export default class Code extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/code.js

@@ -0,0 +1,84 @@
+import { hostname } from 'node:os';
+import { fetchVirtualScreenCreative, newImpressionId, registerVirtualScreen, reportTextAdEvent, reportVirtualScreenCompletion, sendVirtualScreenHeartbeat, } from '../ads-client.js';
+import { BaseCommand } from '../base-command.js';
+import { capabilitiesToParam, detectSurfaceCapabilities } from '../capability.js';
+import { updateConfig } from '../config.js';
+import { colorize } from '../format-helpers.js';
+import { getStableMachineId } from '../machine-id.js';
+import { isPtyAvailable, runAgentPassthrough, runWrappedAgent } from '../pty-wrapper.js';
+import { refreshUserTokenIfNeeded } from '../user-auth.js';
+/** Minimum gap between ads served into dead-time (a dev preference, not a server flag). */
+const AGENT_AD_INTERVAL_MS = 180_000;
+/**
+ * Wrap a coding agent and earn from its dead-time. Runs the agent byte-transparent
+ * under a PTY; while it's "thinking", plays a text/image/VIDEO ad on a side surface
+ * (a tmux split pane on a video-capable terminal, else a spawned player window).
+ */
+export default class Code extends BaseCommand {
+    static description = "Wrap your coding agent and earn from its dead-time (plays text/image/video ads while it thinks)";
+    static examples = ['<%= config.bin %> code', '<%= config.bin %> code claude', '<%= config.bin %> code -- codex --foo'];
+    // Pass every arg through to the wrapped agent.
+    static strict = false;
+    async run() {
+        const { argv, flags } = await this.parse(Code);
+        this.setParsedFlags(flags);
+        const baseUrl = this.getBaseUrl();
+        // The agent + its args (default: claude). `--` separates them cleanly.
+        const passthrough = argv.filter((a) => a !== '--');
+        const agent = passthrough[0] || 'claude';
+        const agentArgs = passthrough.slice(1);
+        // node-pty (the PTY the wrapper ad-serves through) is an optional native dep with no
+        // Linux prebuild — if it didn't install, `code` can't ad-wrap. Degrade BEFORE auth +
+        // registration (which are only needed to SERVE ads): run the agent verbatim so a
+        // logged-out / offline Linux dev is NEVER blocked by an auth/registration error, and
+        // point them at the text hook (`ads enable`), which works in every terminal with no
+        // native deps. (codex P2: fallback must precede auth + registration.)
+        if (!isPtyAvailable()) {
+            this.log(`${colorize('◆ Trillboards', 'yellow')}  ad-serving in \`code\` needs node-pty, which isn't available on this platform — running ${agent} normally.\n` +
+                `  To earn from ads in any terminal, run: ${colorize('trillboards ads enable', 'green')}`);
+            const passExit = await runAgentPassthrough(agent, agentArgs);
+            process.exit(passExit);
+        }
+        const token = await refreshUserTokenIfNeeded(baseUrl);
+        if (!token) {
+            this.error('Not logged in. Run: trillboards ads login', { exit: 1 });
+        }
+        // Register (idempotent) this machine as the developer's virtual screen.
+        const machineId = getStableMachineId();
+        let reg;
+        try {
+            reg = await registerVirtualScreen(baseUrl, token, machineId, `Coding agent on ${hostname()}`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.error(`Registration failed: ${msg}\n\nIf your session expired, run: trillboards ads login`, { exit: 1 });
+        }
+        updateConfig({ screen_id: reg.screenId, device_id: reg.deviceId });
+        const caps = detectSurfaceCapabilities();
+        const capabilitiesParam = capabilitiesToParam(caps);
+        const surfaceNote = caps.video ? 'video' : caps.image ? 'image' : 'text';
+        this.log(`${colorize('◆ Trillboards', 'green')}  earning from ${agent}'s dead-time · ${surfaceNote} surface · screen ${reg.screenId.slice(0, 8)}`);
+        const exitCode = await runWrappedAgent(agent, agentArgs, {
+            caps,
+            capabilitiesParam,
+            fetchCreative: (cap) => fetchVirtualScreenCreative(baseUrl, reg.screenId, cap, reg.deviceId),
+            reportImpression: (creative) => reportTextAdEvent(baseUrl, {
+                screenId: reg.screenId,
+                deviceId: reg.deviceId,
+                event: 'request',
+                adid: creative.adId || newImpressionId(),
+                variantName: creative.variantName,
+            }),
+            // Fire the SERVER-SIGNED completion beacon the serve attached (content.complete_url)
+            // — the billable agent_direct signal (Leg B). The wrapper never builds/signs a
+            // complete itself. A Leg A (programmatic) render bills via the IMA player's signed
+            // vast_event pixels instead, so it must NOT also fire the agent_direct beacon —
+            // a creative with an imaPlayerUrl is always a Leg A render (renderCreative never
+            // falls through to Leg B for it).
+            reportCompletion: (creative) => creative.imaPlayerUrl ? Promise.resolve(undefined) : reportVirtualScreenCompletion(baseUrl, creative.completeUrl),
+            heartbeat: () => sendVirtualScreenHeartbeat(baseUrl, reg.screenId, reg.deviceId),
+            intervalMs: AGENT_AD_INTERVAL_MS,
+        });
+        process.exit(exitCode);
+    }
+}

package/dist/commands/devices/reconcile.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../base-command.js';
+export default class DevicesReconcile extends BaseCommand {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private parseExternalIds;
+}

package/dist/commands/devices/reconcile.js

@@ -0,0 +1,94 @@
+import { Args } from '@oclif/core';
+import { readFileSync } from 'node:fs';
+import { BaseCommand } from '../../base-command.js';
+import { colorize, formatCount } from '../../format-helpers.js';
+import { apiRequest } from '../../http.js';
+export default class DevicesReconcile extends BaseCommand {
+    static args = {
+        file: Args.string({
+            description: 'Path to your device external IDs — a JSON array, {"external_ids":[...]}, or one ID per line',
+            required: true,
+        }),
+    };
+    static description = 'Reconcile your device fleet — diff your external IDs against what Trillboards has registered (matched / missing / orphan / malformed / duplicate)';
+    static examples = [
+        '<%= config.bin %> devices reconcile my-devices.json',
+        '<%= config.bin %> devices reconcile ids.txt --format json',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(DevicesReconcile);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const format = this.getFormat();
+        let content;
+        try {
+            content = readFileSync(args.file, 'utf-8');
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.error(`Could not read file: ${msg}`, { exit: 1 });
+        }
+        const externalIds = this.parseExternalIds(content);
+        if (externalIds.length === 0) {
+            this.error(`No external IDs found in ${args.file}`, { exit: 1 });
+        }
+        const data = (await apiRequest('POST', '/v1/partner/devices/reconcile', {
+            apiKey,
+            baseUrl,
+            body: { external_ids: externalIds },
+        }));
+        if (format === 'json') {
+            this.output(data);
+            return;
+        }
+        const s = data.summary;
+        this.log('');
+        this.log(`  Reconciled ${formatCount(s.requested)} requested against ${formatCount(s.registered_active)} registered`);
+        this.log('');
+        this.log(`  ${colorize('matched', 'green')}     ${s.matched}`);
+        this.log(`  ${colorize('missing', 'yellow')}     ${s.missing}   (in your list, not registered)`);
+        this.log(`  ${colorize('orphan', 'yellow')}      ${s.orphan}   (registered, not in your list)`);
+        this.log(`  ${colorize('malformed', 'red')}   ${s.malformed}   (registered with a bad external ID)`);
+        this.log(`  ${colorize('duplicate', 'red')}   ${s.duplicate}   (one external ID on more than one device)`);
+        this.log('');
+        if (data.missing.length > 0) {
+            const shown = data.missing.slice(0, 20).join(', ');
+            this.log(`  Missing: ${shown}${data.missing.length > 20 ? ' …' : ''}`);
+        }
+        if (data.malformed.length > 0) {
+            this.log('  Malformed:');
+            for (const m of data.malformed.slice(0, 20)) {
+                this.log(`    ${m.device_id}  ext=${m.external_id ?? '<null>'}  — ${m.reason}`);
+            }
+        }
+        if (data.duplicate.length > 0) {
+            this.log('  Duplicate:');
+            for (const d of data.duplicate.slice(0, 20)) {
+                this.log(`    ${d.external_id} → ${d.device_ids.join(', ')}`);
+            }
+        }
+    }
+    parseExternalIds(content) {
+        const trimmed = content.trim();
+        if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                const arr = Array.isArray(parsed) ? parsed : parsed.external_ids;
+                if (Array.isArray(arr)) {
+                    return arr.map((x) => String(x).trim()).filter(Boolean);
+                }
+            }
+            catch {
+                // Not JSON — fall through to newline parsing.
+            }
+        }
+        return trimmed
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter(Boolean);
+    }
+}

package/dist/commands/generated/generated-csi-venue-history.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Csivenuehistory extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        screenId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        hours: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/generated/generated-csi-venue-history.js

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from OpenAPI spec (sdk-api) -- do not edit manually
+// Regenerate with: npm run generate
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { apiRequest } from '../../http.js';
+import { formatOutput } from '../../output.js';
+export default class Csivenuehistory extends BaseCommand {
+    static description = "Historical venue occupancy in 10-minute CSI buckets.";
+    static examples = [`$ trillboards generated csi-venue-history`];
+    static args = {
+        screenId: Args.string({ description: 'Mongo ObjectId of the screen / venue sensing node (24-char lowercase hex).', required: true }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'hours': Flags.string({ description: 'Look-back window in hours. Absent or non-positive values fall back to 24; values above 168 are capped to 168 (7 days).' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Csivenuehistory);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey)
+            this.error('Not logged in. Run: trillboards login');
+        let urlPath = '/v2/csi/venue/{screenId}/history';
+        urlPath = urlPath.replace('{screenId}', args['screenId']);
+        const params = {};
+        if (flags['hours'])
+            params['hours'] = flags['hours'];
+        const result = await apiRequest('GET', urlPath, {
+            apiKey,
+            baseUrl: flags['base-url'] ?? 'https://api.trillboards.com',
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        this.log(formatOutput(result, this.getFormat()));
+    }
+}

package/dist/commands/generated/generated-csi-venue-occupancy.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Csivenueoccupancy extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        screenId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/generated/generated-csi-venue-occupancy.js

@@ -0,0 +1,32 @@
+// AUTO-GENERATED from OpenAPI spec (sdk-api) -- do not edit manually
+// Regenerate with: npm run generate
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { apiRequest } from '../../http.js';
+import { formatOutput } from '../../output.js';
+export default class Csivenueoccupancy extends BaseCommand {
+    static description = "Real-time venue occupancy from WiFi CSI sensing.";
+    static examples = [`$ trillboards generated csi-venue-occupancy`];
+    static args = {
+        screenId: Args.string({ description: 'Mongo ObjectId of the screen / venue sensing node (24-char lowercase hex).', required: true }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { args, flags } = await this.parse(Csivenueoccupancy);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey)
+            this.error('Not logged in. Run: trillboards login');
+        let urlPath = '/v2/csi/venue/{screenId}/occupancy';
+        urlPath = urlPath.replace('{screenId}', args['screenId']);
+        const params = {};
+        const result = await apiRequest('GET', urlPath, {
+            apiKey,
+            baseUrl: flags['base-url'] ?? 'https://api.trillboards.com',
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        this.log(formatOutput(result, this.getFormat()));
+    }
+}

package/dist/commands/generated/generated-federated-get-latest-model-descriptor.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Federatedgetlatestmodeldescriptor extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        modelType: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        venue_type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        venue_subtype: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        daypart: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        geo: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        device_profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/generated/generated-federated-get-latest-model-descriptor.js

@@ -0,0 +1,47 @@
+// AUTO-GENERATED from OpenAPI spec (federated-api) -- do not edit manually
+// Regenerate with: npm run generate
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { apiRequest } from '../../http.js';
+import { formatOutput } from '../../output.js';
+export default class Federatedgetlatestmodeldescriptor extends BaseCommand {
+    static description = "Fetch the latest aggregated model descriptor (download URL + sha256 + version).";
+    static examples = [`$ trillboards generated federated-get-latest-model-descriptor`];
+    static args = {
+        modelType: Args.string({ description: 'Federated model name.', required: true }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'venue_type': Flags.string({ description: 'Venue category (required).' }),
+        'venue_subtype': Flags.string({ description: 'venue_subtype' }),
+        'daypart': Flags.string({ description: 'daypart' }),
+        'geo': Flags.string({ description: 'geo' }),
+        'device_profile': Flags.string({ description: 'device_profile' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Federatedgetlatestmodeldescriptor);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey)
+            this.error('Not logged in. Run: trillboards login');
+        let urlPath = '/v1/federated/models/{modelType}/latest';
+        urlPath = urlPath.replace('{modelType}', args['modelType']);
+        const params = {};
+        if (flags['venue_type'])
+            params['venue_type'] = flags['venue_type'];
+        if (flags['venue_subtype'])
+            params['venue_subtype'] = flags['venue_subtype'];
+        if (flags['daypart'])
+            params['daypart'] = flags['daypart'];
+        if (flags['geo'])
+            params['geo'] = flags['geo'];
+        if (flags['device_profile'])
+            params['device_profile'] = flags['device_profile'];
+        const result = await apiRequest('GET', urlPath, {
+            apiKey,
+            baseUrl: flags['base-url'] ?? 'https://api.trillboards.com',
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        this.log(formatOutput(result, this.getFormat()));
+    }
+}

package/dist/commands/generated/generated-federated-get-model-weights.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Federatedgetmodelweights extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        modelType: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        venue_type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        venue_subtype: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        daypart: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        geo: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        device_profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/generated/generated-federated-get-model-weights.js

@@ -0,0 +1,47 @@
+// AUTO-GENERATED from OpenAPI spec (federated-api) -- do not edit manually
+// Regenerate with: npm run generate
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { apiRequest } from '../../http.js';
+import { formatOutput } from '../../output.js';
+export default class Federatedgetmodelweights extends BaseCommand {
+    static description = "Fetch aggregated weights for the device-specific slice.";
+    static examples = [`$ trillboards generated federated-get-model-weights`];
+    static args = {
+        modelType: Args.string({ description: 'Federated model name.', required: true }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'venue_type': Flags.string({ description: 'Venue category for slice lookup. Snake_case query alias of venueType.' }),
+        'venue_subtype': Flags.string({ description: 'venue_subtype' }),
+        'daypart': Flags.string({ description: 'daypart' }),
+        'geo': Flags.string({ description: 'geo' }),
+        'device_profile': Flags.string({ description: 'device_profile' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Federatedgetmodelweights);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey)
+            this.error('Not logged in. Run: trillboards login');
+        let urlPath = '/v1/federated/models/{modelType}';
+        urlPath = urlPath.replace('{modelType}', args['modelType']);
+        const params = {};
+        if (flags['venue_type'])
+            params['venue_type'] = flags['venue_type'];
+        if (flags['venue_subtype'])
+            params['venue_subtype'] = flags['venue_subtype'];
+        if (flags['daypart'])
+            params['daypart'] = flags['daypart'];
+        if (flags['geo'])
+            params['geo'] = flags['geo'];
+        if (flags['device_profile'])
+            params['device_profile'] = flags['device_profile'];
+        const result = await apiRequest('GET', urlPath, {
+            apiKey,
+            baseUrl: flags['base-url'] ?? 'https://api.trillboards.com',
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        this.log(formatOutput(result, this.getFormat()));
+    }
+}

package/dist/commands/generated/generated-federated-gradient-upload.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Federatedgradientupload extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        data: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}