@telemetryos/cli 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @telemetryos/cli
 
+## 1.10.0
+
+### Minor Changes
+
+- Added MQTT, publish command, and other improvements
+  - Added MQTT support to the SDK
+  - Added a command `tos publish` that sends the project to be built on the platform (requires user token, so wont work right away)
+  - Added mock data for the currency service
+
+### Patch Changes
+
+- Updated dependencies
+  - @telemetryos/development-application-host-ui@1.10.0
+
 ## 1.9.0
 
 ### Minor Changes

package/dist/commands/auth.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
-import { loadConfig, saveConfig } from '../services/config.js';
+import { loadCliConfig, saveCliConfig } from '../services/cli-config.js';
 export const authCommand = new Command('auth')
     .description('Authenticate with TelemetryOS by saving your API token')
     .option('-t, --token <string>', 'API token (skip interactive prompt)')
@@ -26,8 +26,8 @@ function validateToken(input) {
 }
 async function handleAuthCommand(options) {
     let token = options.token;
-    const existingConfig = await loadConfig();
-    const existingToken = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.apiToken;
+    const existingCliConfig = await loadCliConfig();
+    const existingToken = existingCliConfig === null || existingCliConfig === void 0 ? void 0 : existingCliConfig.apiToken;
     if (existingToken && !options.force) {
         const { confirm } = await inquirer.prompt([
             {
@@ -62,6 +62,6 @@ async function handleAuthCommand(options) {
         ]);
         token = answers.token.trim();
     }
-    await saveConfig({ ...existingConfig, apiToken: token });
+    await saveCliConfig({ ...existingCliConfig, apiToken: token });
     console.log('API token saved successfully!');
 }

package/dist/commands/init.js

@@ -1,33 +1,98 @@
 import { Command } from 'commander';
-import { generateApplication } from '../services/generate-application.js';
+import { generateApplication, checkDirectoryConflicts, removeConflictingFiles, } from '../services/generate-application.js';
 import inquirer from 'inquirer';
 import path from 'path';
+import { resolveProjectPathAndName, validateProjectName } from '../utils/path-utils.js';
+import { ansi } from '../utils/ansi.js';
+async function promptConflictResolution() {
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'Target directory is not empty. Please choose how to proceed:',
+            choices: [
+                { name: 'Cancel operation', value: 'cancel' },
+                { name: 'Remove existing files and continue', value: 'remove' },
+                { name: 'Ignore files and continue', value: 'ignore' },
+            ],
+            default: 'cancel',
+        },
+    ]);
+    return action;
+}
 export const initCommand = new Command('init')
     .description('Initializes a new telemetryOS application')
+    .argument('[project-path]', 'Path to create the project (defaults to current directory)', '')
     .option('-d, --description <string>', 'The description of the application', '')
     .option('-a, --author <string>', 'The author of the application', '')
     .option('-v, --version <string>', 'The version of the application', '0.1.0')
     .option('-t, --template <string>', 'The template to use (vite-react-typescript)', '')
-    .argument('[project-name]', 'The name of the application', '')
     .action(handleInitCommand);
-async function handleInitCommand(projectName, options) {
-    let name = projectName;
+async function handleInitCommand(projectPathArg, options) {
+    // Step 1: Resolve path and derive name
+    const cwd = process.cwd();
+    const inputPath = projectPathArg || '.';
+    const { resolvedPath, derivedName } = resolveProjectPathAndName(inputPath, cwd);
+    // Step 2: Validate the derived name BEFORE any destructive operations
+    const validation = validateProjectName(derivedName);
+    if (validation !== true) {
+        console.error(`\n${ansi.red}Error:${ansi.reset} Cannot initialize project - ${validation}`);
+        console.error(`\nDerived project name: ${ansi.yellow}${derivedName}${ansi.reset}`);
+        console.error(`From path: ${ansi.dim}${path.relative(cwd, resolvedPath)}${ansi.reset}`);
+        console.error(`\n${ansi.bold}Project names must:${ansi.reset}`);
+        console.error('  • Contain only lowercase letters, numbers, and hyphens');
+        console.error('  • Not start or end with a hyphen');
+        console.error('  • Not start with a dot (.) or underscore (_)');
+        console.error('  • Be between 1 and 214 characters');
+        console.error('  • Not be a reserved name (e.g., node_modules)');
+        console.error(`\n${ansi.yellow}Tip:${ansi.reset} Use a different directory name or specify a path`);
+        console.error(`Example: ${ansi.cyan}tos init my-app${ansi.reset}`);
+        process.exit(1);
+    }
+    // Step 3: Check for directory conflicts BEFORE prompting for details
+    const conflicts = await checkDirectoryConflicts(resolvedPath);
+    if (conflicts.length > 0) {
+        console.log(`\n${ansi.yellow}⚠${ansi.reset}  Target directory contains files that could conflict:\n`);
+        conflicts.slice(0, 10).forEach((file) => console.log(`  ${ansi.dim}${file}${ansi.reset}`));
+        if (conflicts.length > 10) {
+            console.log(`  ${ansi.dim}... and ${conflicts.length - 10} more${ansi.reset}`);
+        }
+        console.log();
+        const action = await promptConflictResolution();
+        if (action === 'cancel') {
+            console.log('Operation cancelled');
+            process.exit(0);
+        }
+        else if (action === 'remove') {
+            console.log('\nRemoving existing files...');
+            await removeConflictingFiles(resolvedPath, conflicts);
+            console.log(`${ansi.green}✓${ansi.reset} Existing files removed\n`);
+        }
+        else {
+            // action === 'ignore' - continue with merge
+            console.log('\nContinuing with existing files (will overwrite conflicts)...\n');
+        }
+    }
+    // Step 4: Setup variables from options
+    let name = derivedName;
     let description = options.description;
     let author = options.author;
     let version = options.version;
     let template = options.template;
+    // Step 5: Build prompt questions
     const questions = [];
-    if (!name)
-        questions.push({
-            type: 'input',
-            name: 'name',
-            message: 'What is the name of your application?',
-            validate: (input) => {
-                if (input.length > 0)
-                    return true;
-                return 'Application name cannot be empty';
-            },
-        });
+    // Always show the derived name with option to override
+    // This provides transparency and control
+    questions.push({
+        type: 'input',
+        name: 'name',
+        message: 'Project name:',
+        default: derivedName,
+        validate: (input) => {
+            const result = validateProjectName(input);
+            return result === true ? true : result;
+        },
+    });
     if (!description)
         questions.push({
             type: 'input',
@@ -61,40 +126,23 @@ async function handleInitCommand(projectName, options) {
             message: 'Which template would you like to use?',
             choices: [{ name: 'Vite + React + TypeScript', value: 'vite-react-typescript' }],
         });
-    if (questions.length !== 0) {
-        const answers = await inquirer.prompt(questions);
-        if (answers.name)
-            name = answers.name;
-        if (answers.version)
-            version = answers.version;
-        if (answers.description)
-            description = answers.description;
-        if (answers.author)
-            author = answers.author;
-        if (answers.template)
-            template = answers.template;
-    }
-    const projectPath = path.join(process.cwd(), name);
+    // Step 6: Prompt user
+    const answers = await inquirer.prompt(questions);
+    name = answers.name || name;
+    version = answers.version || version;
+    description = answers.description || description;
+    author = answers.author || author;
+    template = answers.template || template;
+    // Step 7: Generate application
     await generateApplication({
         name,
         description,
         author,
         version,
         template,
-        projectPath,
+        projectPath: resolvedPath,
         progressFn: (createdFilePath) => {
-            console.log(`.${path.sep}${path.relative(process.cwd(), createdFilePath)}`);
-        },
-        confirmOverwrite: async () => {
-            const { proceed } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'proceed',
-                    message: 'Do you want to continue and overwrite these files?',
-                    default: false,
-                },
-            ]);
-            return proceed;
+            console.log(`.${path.sep}${path.relative(cwd, createdFilePath)}`);
         },
     });
 }

package/dist/commands/publish.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const publishCommand: Command;

package/dist/commands/publish.js

@@ -0,0 +1,208 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import path from 'path';
+import { ApiClient } from '../services/api-client.js';
+import { loadProjectConfig } from '../services/project-config.js';
+import { createArchive } from '../services/archiver.js';
+import { pollBuild } from '../services/build-poller.js';
+import { ansi } from '../utils/ansi.js';
+// Default values for new application builds
+const APP_BUILD_DEFAULTS = {
+    baseImage: 'node:20',
+    buildScript: 'npm install\nnpm run build',
+    buildOutput: '/dist',
+    workingPath: '/',
+};
+export const publishCommand = new Command('publish')
+    .description('Publish an application to TelemetryOS')
+    .argument('[project-path]', 'Path to the project directory. Defaults to current working directory', process.cwd())
+    .option('-i, --interactive', 'Interactively prompt for all build configuration')
+    .option('--name <name>', 'Application name (overrides config)')
+    .option('--base-image <image>', 'Docker base image for build')
+    .option('--build-script <script>', 'Build script commands')
+    .option('--build-output <path>', 'Build output directory')
+    .option('--working-path <path>', 'Working directory in container')
+    .action(handlePublishCommand);
+function getSpecifiedBuildOptions(options) {
+    const specified = [];
+    if (options.baseImage !== undefined)
+        specified.push('--base-image');
+    if (options.buildScript !== undefined)
+        specified.push('--build-script');
+    if (options.buildOutput !== undefined)
+        specified.push('--build-output');
+    if (options.workingPath !== undefined)
+        specified.push('--working-path');
+    return specified;
+}
+async function handlePublishCommand(projectPath, options) {
+    var _a, _b, _c, _d;
+    projectPath = path.resolve(process.cwd(), projectPath);
+    try {
+        // Step 1: Load project config
+        console.log(`\n${ansi.cyan}Loading project configuration...${ansi.reset}`);
+        const config = await loadProjectConfig(projectPath);
+        // Step 2: Resolve build configuration
+        let buildConfig = {
+            name: options.name || config.name || '',
+            baseImage: options.baseImage,
+            buildScript: options.buildScript,
+            buildOutput: options.buildOutput,
+            workingPath: options.workingPath,
+        };
+        if (options.interactive) {
+            // Interactive mode: prompt for all fields
+            buildConfig = await promptBuildConfig(buildConfig);
+        }
+        else if (!buildConfig.name) {
+            // Non-interactive mode but no name: prompt just for name
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Application name:',
+                    validate: (input) => (input.trim() ? true : 'Application name is required'),
+                },
+            ]);
+            buildConfig.name = answers.name.trim();
+        }
+        if (!buildConfig.name) {
+            console.error(`${ansi.red}Error: Application name is required${ansi.reset}`);
+            process.exit(1);
+        }
+        console.log(`  Project: ${ansi.bold}${buildConfig.name}${ansi.reset}`);
+        if (config.version) {
+            console.log(`  Version: ${config.version}`);
+        }
+        // Step 3: Initialize API client
+        console.log(`\n${ansi.cyan}Authenticating...${ansi.reset}`);
+        const apiClient = await ApiClient.create();
+        console.log(`  ${ansi.green}Authenticated${ansi.reset}`);
+        // Step 4: Create archive
+        console.log(`\n${ansi.cyan}Archiving project...${ansi.reset}`);
+        const { buffer, filename } = await createArchive(projectPath, (msg) => {
+            console.log(`  ${ansi.dim}${msg}${ansi.reset}`);
+        });
+        // Step 5: Find or create application
+        console.log(`\n${ansi.cyan}Checking for existing application...${ansi.reset}`);
+        const appsRes = await apiClient.get('/application');
+        const apps = (await appsRes.json());
+        let app = apps.find((a) => a.title === buildConfig.name) || null;
+        if (app) {
+            console.log(`  Found existing application: ${ansi.dim}${app.id}${ansi.reset}`);
+            const specifiedOptions = getSpecifiedBuildOptions(options);
+            if (specifiedOptions.length > 0) {
+                console.log(`  ${ansi.yellow}Warning: ${specifiedOptions.join(', ')} ignored for existing application${ansi.reset}`);
+            }
+        }
+        else {
+            console.log(`  Creating new application...`);
+            const createRequest = {
+                kind: 'uploaded',
+                title: buildConfig.name,
+                baseImage: (_a = buildConfig.baseImage) !== null && _a !== void 0 ? _a : APP_BUILD_DEFAULTS.baseImage,
+                baseImageRegistryAuth: '',
+                buildWorkingPath: (_b = buildConfig.workingPath) !== null && _b !== void 0 ? _b : APP_BUILD_DEFAULTS.workingPath,
+                buildScript: (_c = buildConfig.buildScript) !== null && _c !== void 0 ? _c : APP_BUILD_DEFAULTS.buildScript,
+                buildOutputPath: (_d = buildConfig.buildOutput) !== null && _d !== void 0 ? _d : APP_BUILD_DEFAULTS.buildOutput,
+            };
+            const createRes = await apiClient.post('/application', { body: createRequest });
+            app = (await createRes.json());
+            console.log(`  ${ansi.green}Created application:${ansi.reset} ${ansi.dim}${app.id}${ansi.reset}`);
+        }
+        // Step 6: Upload archive
+        console.log(`\n${ansi.cyan}Uploading archive...${ansi.reset}`);
+        const formData = new FormData();
+        const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        const blob = new Blob([arrayBuffer], { type: 'application/gzip' });
+        formData.append('file', blob, filename);
+        await apiClient.post(`/application/${app.id}/archive`, { body: formData });
+        console.log(`  ${ansi.green}Upload complete${ansi.reset}`);
+        // Step 7: Poll for build status and stream logs
+        console.log(`\n${ansi.cyan}Building...${ansi.reset}`);
+        console.log(`${ansi.white}Build Logs${ansi.reset}`);
+        const build = await pollBuild(apiClient, app.id, {
+            onLog: (line) => {
+                console.log(`  ${ansi.dim}${line}${ansi.reset}`);
+            },
+            onStateChange: () => { },
+            onComplete: () => { },
+            onError: (error) => {
+                console.error(`${ansi.red}Polling error: ${error.message}${ansi.reset}`);
+            },
+        });
+        // Step 8: Report result
+        if (build.state === 'success') {
+            console.log(`\n${ansi.green}${ansi.bold}Build successful!${ansi.reset}`);
+            console.log(`\n  Application: ${buildConfig.name}`);
+            console.log(`  Build: #${build.index}`);
+            if (build.finishedAt && build.startedAt) {
+                const duration = calculateDuration(build.startedAt, build.finishedAt);
+                console.log(`  Duration: ${duration}`);
+            }
+            console.log('');
+        }
+        else {
+            console.log(`\n${ansi.red}${ansi.bold}Build failed${ansi.reset}`);
+            console.log(`\n  State: ${build.state}`);
+            console.log('');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`\n${ansi.red}Error: ${error.message}${ansi.reset}\n`);
+        process.exit(1);
+    }
+}
+async function promptBuildConfig(defaults) {
+    var _a, _b, _c, _d;
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Application name:',
+            default: defaults.name || undefined,
+            validate: (input) => (input.trim() ? true : 'Application name is required'),
+        },
+        {
+            type: 'input',
+            name: 'baseImage',
+            message: 'Base image:',
+            default: (_a = defaults.baseImage) !== null && _a !== void 0 ? _a : APP_BUILD_DEFAULTS.baseImage,
+        },
+        {
+            type: 'input',
+            name: 'buildScript',
+            message: 'Build script:',
+            default: (_b = defaults.buildScript) !== null && _b !== void 0 ? _b : APP_BUILD_DEFAULTS.buildScript,
+        },
+        {
+            type: 'input',
+            name: 'buildOutput',
+            message: 'Build output path:',
+            default: (_c = defaults.buildOutput) !== null && _c !== void 0 ? _c : APP_BUILD_DEFAULTS.buildOutput,
+        },
+        {
+            type: 'input',
+            name: 'workingPath',
+            message: 'Working path:',
+            default: (_d = defaults.workingPath) !== null && _d !== void 0 ? _d : APP_BUILD_DEFAULTS.workingPath,
+        },
+    ]);
+    return {
+        name: answers.name.trim(),
+        baseImage: answers.baseImage.trim(),
+        buildScript: answers.buildScript.trim(),
+        buildOutput: answers.buildOutput.trim(),
+        workingPath: answers.workingPath.trim(),
+    };
+}
+function calculateDuration(start, end) {
+    const ms = new Date(end).getTime() - new Date(start).getTime();
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import { authCommand } from './commands/auth.js';
 import { initCommand } from './commands/init.js';
+import { publishCommand } from './commands/publish.js';
 import { rootCommand } from './commands/root.js';
 import { serveCommand } from './commands/serve.js';
 rootCommand.addCommand(authCommand);
 rootCommand.addCommand(serveCommand);
 rootCommand.addCommand(initCommand);
+rootCommand.addCommand(publishCommand);
 rootCommand.parse(process.argv);

package/dist/plugins/math-tools.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '@opencode-ai/plugin';
+export declare const MathToolsPlugin: Plugin;

package/dist/plugins/math-tools.js

@@ -0,0 +1,18 @@
+import { tool } from '@opencode-ai/plugin';
+export const MathToolsPlugin = async (ctx) => {
+    return {
+        tool: {
+            multiply: tool({
+                description: 'Multiply two numbers',
+                args: {
+                    a: tool.schema.number().describe('First number'),
+                    b: tool.schema.number().describe('Second number'),
+                },
+                async execute(args, context) {
+                    const result = args.a * args.b;
+                    return result.toString();
+                },
+            }),
+        },
+    };
+};

package/dist/services/api-client.d.ts

@@ -0,0 +1,18 @@
+export type RequestOptions = {
+    body?: unknown;
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean>;
+};
+export declare class ApiClient {
+    private baseUrl;
+    private token;
+    constructor(baseUrl: string, token: string);
+    static create(): Promise<ApiClient>;
+    get(path: string, opts?: RequestOptions): Promise<Response>;
+    post(path: string, opts?: RequestOptions): Promise<Response>;
+    put(path: string, opts?: RequestOptions): Promise<Response>;
+    patch(path: string, opts?: RequestOptions): Promise<Response>;
+    delete(path: string, opts?: RequestOptions): Promise<Response>;
+    private request;
+    private buildUrl;
+}

package/dist/services/api-client.js

@@ -0,0 +1,70 @@
+import { loadCliConfig } from './cli-config.js';
+const DEFAULT_API_URL = 'https://api.telemetryos.com';
+export class ApiClient {
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    static async create() {
+        const config = await loadCliConfig();
+        if (!(config === null || config === void 0 ? void 0 : config.apiToken)) {
+            throw new Error('Not authenticated. Run `tos auth` first.');
+        }
+        const baseUrl = process.env.TOS_API_URL || config.apiUrl || DEFAULT_API_URL;
+        return new ApiClient(baseUrl, config.apiToken);
+    }
+    async get(path, opts) {
+        return this.request('GET', path, opts);
+    }
+    async post(path, opts) {
+        return this.request('POST', path, opts);
+    }
+    async put(path, opts) {
+        return this.request('PUT', path, opts);
+    }
+    async patch(path, opts) {
+        return this.request('PATCH', path, opts);
+    }
+    async delete(path, opts) {
+        return this.request('DELETE', path, opts);
+    }
+    async request(method, path, opts) {
+        const url = this.buildUrl(path, opts === null || opts === void 0 ? void 0 : opts.query);
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            ...opts === null || opts === void 0 ? void 0 : opts.headers,
+        };
+        // Don't set Content-Type for FormData - fetch sets it with boundary
+        if ((opts === null || opts === void 0 ? void 0 : opts.body) && !(opts.body instanceof FormData)) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: (opts === null || opts === void 0 ? void 0 : opts.body) instanceof FormData
+                ? opts.body
+                : (opts === null || opts === void 0 ? void 0 : opts.body)
+                    ? JSON.stringify(opts.body)
+                    : undefined,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => 'Unknown error');
+            if (response.status === 401) {
+                throw new Error('Authentication failed. Run `tos auth` to re-authenticate.');
+            }
+            throw new Error(`API Error ${response.status}: ${errorBody}`);
+        }
+        return response;
+    }
+    buildUrl(path, query) {
+        const url = new URL(path, this.baseUrl);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+}

package/dist/services/archiver.d.ts

@@ -0,0 +1,4 @@
+export declare function createArchive(projectPath: string, onProgress?: (message: string) => void): Promise<{
+    buffer: Buffer;
+    filename: string;
+}>;

package/dist/services/archiver.js

@@ -0,0 +1,65 @@
+import { readFile, stat, unlink } from 'fs/promises';
+import path from 'path';
+import { tmpdir } from 'os';
+import * as tar from 'tar';
+import ignoreModule from 'ignore';
+const ignore = ignoreModule.default || ignoreModule;
+const DEFAULT_IGNORES = [
+    'node_modules',
+    '.git',
+    'dist',
+    '.DS_Store',
+    '*.log',
+    '.env',
+    '.env.*',
+    '.turbo',
+    'coverage',
+];
+export async function createArchive(projectPath, onProgress) {
+    const projectName = path.basename(projectPath);
+    const filename = `${projectName}-${Date.now()}.tar.gz`;
+    const tempPath = path.join(tmpdir(), filename);
+    // Build ignore filter
+    const ig = ignore();
+    // Load .gitignore patterns if present, otherwise use defaults
+    try {
+        const gitignoreContent = await readFile(path.join(projectPath, '.gitignore'), 'utf-8');
+        ig.add(gitignoreContent);
+        ig.add('.git'); // .git is always ignored by git itself
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('Using .gitignore patterns');
+    }
+    catch {
+        ig.add(DEFAULT_IGNORES);
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('No .gitignore found, using default exclusions');
+    }
+    // Create tar.gz archive
+    onProgress === null || onProgress === void 0 ? void 0 : onProgress('Creating archive...');
+    await tar.create({
+        gzip: true,
+        file: tempPath,
+        cwd: projectPath,
+        filter: (filePath) => {
+            // Always include root
+            if (filePath === '.')
+                return true;
+            // Normalize path for ignore matching
+            const relativePath = filePath.startsWith('./') ? filePath.slice(2) : filePath;
+            const ignored = ig.ignores(relativePath);
+            if (!ignored)
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress(`  ${relativePath}`);
+            return !ignored;
+        },
+    }, ['.']);
+    const buffer = await readFile(tempPath);
+    const stats = await stat(tempPath);
+    onProgress === null || onProgress === void 0 ? void 0 : onProgress(`Archive created: ${formatBytes(stats.size)}`);
+    await unlink(tempPath).catch(() => { });
+    return { buffer, filename };
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/services/build-poller.d.ts

@@ -0,0 +1,10 @@
+import type { ApiClient } from './api-client.js';
+import type { ApplicationBuild } from '../types/applications.js';
+type BuildPollerCallbacks = {
+    onLog: (line: string) => void;
+    onStateChange: (state: string) => void;
+    onComplete: (build: ApplicationBuild) => void;
+    onError: (error: Error) => void;
+};
+export declare function pollBuild(apiClient: ApiClient, applicationId: string, callbacks: BuildPollerCallbacks): Promise<ApplicationBuild>;
+export {};