@telemetryos/cli 1.9.0 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @telemetryos/cli
 
+## 1.11.0
+
+### Minor Changes
+
+- Added media select component, improved tos init tos publish and tos auth commands, add new store hook
+
+### Patch Changes
+
+- Updated dependencies
+  - @telemetryos/development-application-host-ui@1.11.0
+
+## 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 { apiTokenSchema, 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)')
@@ -12,22 +12,15 @@ function maskToken(token) {
     return `${token.slice(0, 4)}...${token.slice(-4)}`;
 }
 function validateToken(input) {
-    if (!input || input.trim().length === 0) {
-        return 'Token cannot be empty';
-    }
-    const trimmed = input.trim();
-    if (!/^[a-f0-9-]+$/i.test(trimmed)) {
-        return 'Token must be a valid string';
-    }
-    if (trimmed.length < 24) {
-        return 'Token must be at least 24 characters';
-    }
-    return true;
+    const result = apiTokenSchema.safeParse(input.trim());
+    if (result.success)
+        return true;
+    return result.error.issues[0].message;
 }
 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.apiToken;
     if (existingToken && !options.force) {
         const { confirm } = await inquirer.prompt([
             {
@@ -62,6 +55,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,100 +1,163 @@
 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', '')
+    .option('-y, --yes', 'Skip all prompts and use defaults', false)
     .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;
-    const questions = [];
-    if (!name)
+    // Step 5: Build prompt questions (skipped with --yes)
+    if (options.yes) {
+        if (!name) {
+            console.error('Project name is required when using --yes');
+            process.exit(1);
+        }
+        if (!description)
+            description = 'A telemetryOS application';
+        if (!template)
+            template = 'vite-react-typescript';
+        if (!version)
+            version = '0.1.0';
+    }
+    else {
+        const questions = [];
+        // Always show the derived name with option to override
+        // This provides transparency and control
         questions.push({
             type: 'input',
             name: 'name',
-            message: 'What is the name of your application?',
+            message: 'Project name:',
+            default: derivedName,
             validate: (input) => {
-                if (input.length > 0)
-                    return true;
-                return 'Application name cannot be empty';
+                const result = validateProjectName(input);
+                return result === true ? true : result;
             },
         });
-    if (!description)
-        questions.push({
-            type: 'input',
-            name: 'description',
-            message: 'What is the description of your application?',
-            default: 'A telemetryOS application',
-        });
-    if (!author)
-        questions.push({
-            type: 'input',
-            name: 'author',
-            message: 'Who is the author of your application?',
-            default: '',
-        });
-    if (!version)
-        questions.push({
-            type: 'input',
-            name: 'version',
-            message: 'What is the version of your application?',
-            default: '0.1.0',
-            validate: (input) => {
-                if (/^\d+\.\d+\.\d+(-.+)?$/.test(input))
-                    return true;
-                return 'Version must be in semver format (e.g. 1.0.0)';
-            },
-        });
-    if (!template)
-        questions.push({
-            type: 'list',
-            name: 'template',
-            message: 'Which template would you like to use?',
-            choices: [{ name: 'Vite + React + TypeScript', value: 'vite-react-typescript' }],
-        });
-    if (questions.length !== 0) {
+        if (!description)
+            questions.push({
+                type: 'input',
+                name: 'description',
+                message: 'What is the description of your application?',
+                default: 'A telemetryOS application',
+            });
+        if (!author)
+            questions.push({
+                type: 'input',
+                name: 'author',
+                message: 'Who is the author of your application?',
+                default: '',
+            });
+        if (!version)
+            questions.push({
+                type: 'input',
+                name: 'version',
+                message: 'What is the version of your application?',
+                default: '0.1.0',
+                validate: (input) => {
+                    if (/^\d+\.\d+\.\d+(-.+)?$/.test(input))
+                        return true;
+                    return 'Version must be in semver format (e.g. 1.0.0)';
+                },
+            });
+        if (!template)
+            questions.push({
+                type: 'list',
+                name: 'template',
+                message: 'Which template would you like to use?',
+                choices: [{ name: 'Vite + React + TypeScript', value: 'vite-react-typescript' }],
+            });
+        // Step 6: Prompt user
         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;
+        name = answers.name || name;
+        version = answers.version || version;
+        description = answers.description || description;
+        author = answers.author || author;
+        template = answers.template || template;
     }
-    const projectPath = path.join(process.cwd(), name);
+    // 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,22 @@
+import { Command } from 'commander';
+export declare const publishCommand: Command;
+type PublishOptions = {
+    interactive?: boolean;
+    name?: string;
+    baseImage?: string;
+    buildScript?: string;
+    buildOutput?: string;
+    workingPath?: string;
+};
+type PublishCallbacks = {
+    onLog?: (line: string) => void;
+    onStateChange?: (state: string) => void;
+    onComplete?: (data: {
+        success: boolean;
+        buildIndex?: number;
+        duration?: string;
+    }) => void;
+    onError?: (error: Error) => void;
+};
+declare function handlePublishCommand(projectPath: string, options: PublishOptions, callbacks?: PublishCallbacks): Promise<void>;
+export { handlePublishCommand, type PublishCallbacks, type PublishOptions };

package/dist/commands/publish.js

@@ -0,0 +1,238 @@
+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, callbacks) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    projectPath = path.resolve(process.cwd(), projectPath);
+    const logMessage = (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onLog) || ((msg) => console.log(msg));
+    try {
+        // Step 1: Load project config
+        (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _a === void 0 ? void 0 : _a.call(callbacks, 'loading');
+        logMessage(`\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) {
+            const error = new Error('Application name is required');
+            logMessage(`${ansi.red}Error: Application name is required${ansi.reset}`);
+            (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _b === void 0 ? void 0 : _b.call(callbacks, error);
+            if (!callbacks)
+                process.exit(1);
+            return;
+        }
+        logMessage(`  Project: ${ansi.bold}${buildConfig.name}${ansi.reset}`);
+        if (config.version) {
+            logMessage(`  Version: ${config.version}`);
+        }
+        // Step 3: Initialize API client
+        (_c = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _c === void 0 ? void 0 : _c.call(callbacks, 'authenticating');
+        logMessage(`\n${ansi.cyan}Authenticating...${ansi.reset}`);
+        const apiClient = await ApiClient.create();
+        logMessage(`  ${ansi.green}Authenticated${ansi.reset}`);
+        // Step 4: Create archive
+        (_d = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _d === void 0 ? void 0 : _d.call(callbacks, 'archiving');
+        logMessage(`\n${ansi.cyan}Archiving project...${ansi.reset}`);
+        const { buffer, filename } = await createArchive(projectPath, (msg) => {
+            logMessage(`  ${ansi.dim}${msg}${ansi.reset}`);
+        });
+        // Step 5: Find or create application
+        logMessage(`\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) {
+            logMessage(`  Found existing application: ${ansi.dim}${app.id}${ansi.reset}`);
+            const specifiedOptions = getSpecifiedBuildOptions(options);
+            if (specifiedOptions.length > 0) {
+                logMessage(`  ${ansi.yellow}Warning: ${specifiedOptions.join(', ')} ignored for existing application${ansi.reset}`);
+            }
+        }
+        else {
+            logMessage(`  Creating new application...`);
+            const createRequest = {
+                kind: 'uploaded',
+                title: buildConfig.name,
+                baseImage: (_e = buildConfig.baseImage) !== null && _e !== void 0 ? _e : APP_BUILD_DEFAULTS.baseImage,
+                baseImageRegistryAuth: '',
+                buildWorkingPath: (_f = buildConfig.workingPath) !== null && _f !== void 0 ? _f : APP_BUILD_DEFAULTS.workingPath,
+                buildScript: (_g = buildConfig.buildScript) !== null && _g !== void 0 ? _g : APP_BUILD_DEFAULTS.buildScript,
+                buildOutputPath: (_h = buildConfig.buildOutput) !== null && _h !== void 0 ? _h : APP_BUILD_DEFAULTS.buildOutput,
+            };
+            const createRes = await apiClient.post('/application', { body: createRequest });
+            app = (await createRes.json());
+            logMessage(`  ${ansi.green}Created application:${ansi.reset} ${ansi.dim}${app.id}${ansi.reset}`);
+        }
+        // Step 6: Upload archive
+        (_j = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _j === void 0 ? void 0 : _j.call(callbacks, 'uploading');
+        logMessage(`\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 });
+        logMessage(`  ${ansi.green}Upload complete${ansi.reset}`);
+        // Step 7: Poll for build status and stream logs
+        (_k = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _k === void 0 ? void 0 : _k.call(callbacks, 'building');
+        logMessage(`\n${ansi.cyan}Building...${ansi.reset}`);
+        logMessage(`${ansi.white}Build Logs${ansi.reset}`);
+        const build = await pollBuild(apiClient, app.id, {
+            onLog: (line) => {
+                logMessage(`  ${ansi.dim}${line}${ansi.reset}`);
+            },
+            onStateChange: () => { },
+            onComplete: () => { },
+            onError: (error) => {
+                var _a;
+                logMessage(`${ansi.red}Polling error: ${error.message}${ansi.reset}`);
+                (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _a === void 0 ? void 0 : _a.call(callbacks, error);
+            },
+        });
+        // Step 8: Report result
+        if (build.state === 'success') {
+            (_l = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _l === void 0 ? void 0 : _l.call(callbacks, 'success');
+            logMessage(`\n${ansi.green}${ansi.bold}Build successful!${ansi.reset}`);
+            logMessage(`\n  Application: ${buildConfig.name}`);
+            logMessage(`  Build: #${build.index}`);
+            let duration = '';
+            if (build.finishedAt && build.startedAt) {
+                duration = calculateDuration(build.startedAt, build.finishedAt);
+                logMessage(`  Duration: ${duration}`);
+            }
+            logMessage('');
+            (_m = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onComplete) === null || _m === void 0 ? void 0 : _m.call(callbacks, {
+                success: true,
+                buildIndex: build.index,
+                duration,
+            });
+        }
+        else {
+            (_o = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStateChange) === null || _o === void 0 ? void 0 : _o.call(callbacks, 'failure');
+            logMessage(`\n${ansi.red}${ansi.bold}Build failed${ansi.reset}`);
+            logMessage(`\n  State: ${build.state}`);
+            logMessage('');
+            const error = new Error(`Build failed with state: ${build.state}`);
+            (_p = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _p === void 0 ? void 0 : _p.call(callbacks, error);
+            if (!callbacks) {
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        const err = error;
+        logMessage(`\n${ansi.red}Error: ${err.message}${ansi.reset}\n`);
+        (_q = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _q === void 0 ? void 0 : _q.call(callbacks, err);
+        if (!callbacks) {
+            process.exit(1);
+        }
+    }
+}
+// Export for use by server
+export { handlePublishCommand };
+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;
+}