@telemetryos/cli 1.16.0 → 1.17.0

package/dist/services/generate-application.js

@@ -1,206 +0,0 @@
-import { spawn, execSync } from 'child_process';
-import fs from 'fs/promises';
-import path from 'path';
-import { ansi } from '../utils/ansi.js';
-const ignoredTemplateFiles = ['.DS_Store', 'thumbs.db', 'node_modules', '.git', 'dist'];
-const templatesDir = path.join(import.meta.dirname, '../../templates');
-const dotfileNames = ['_gitignore', '_claude'];
-// Files that can exist in a directory without being considered conflicts
-const safeExistingFiles = [
-    '.DS_Store',
-    '.git',
-    '.gitignore',
-    '.gitattributes',
-    '.idea',
-    '.vscode',
-    'Thumbs.db',
-    'LICENSE',
-    'README.md',
-];
-export async function generateApplication(options) {
-    const { name, description, author, version, template, projectPath, progressFn } = options;
-    await fs.mkdir(projectPath, { recursive: true });
-    // Initialize git repo early (before template dependencies that may have git hooks)
-    const gitInitialized = tryGitInit(projectPath);
-    if (gitInitialized) {
-        console.log('\nInitialized a git repository');
-    }
-    await copyDir(path.join(templatesDir, template), projectPath, {
-        name,
-        version,
-        description,
-        author,
-    }, progressFn);
-    // Install latest versions of @telemetryos/sdk and @telemetryos/cli
-    console.log('\nInstalling dependencies...');
-    await installPackages(projectPath);
-    // Create initial commit after all files are in place
-    if (gitInitialized) {
-        await tryGitCommit(projectPath);
-    }
-    printSuccessMessage(name, projectPath);
-}
-async function installPackages(projectPath) {
-    // Install SDK as a regular dependency
-    await new Promise((resolve, reject) => {
-        const sdkInstall = spawn('npm', ['install', '@telemetryos/sdk'], {
-            cwd: projectPath,
-            stdio: 'inherit',
-            shell: true,
-        });
-        sdkInstall.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`npm install @telemetryos/sdk failed with code ${code}`));
-            }
-        });
-        sdkInstall.on('error', (error) => {
-            reject(error);
-        });
-    });
-    // Install CLI as a dev dependency
-    await new Promise((resolve, reject) => {
-        const cliInstall = spawn('npm', ['install', '-D', '@telemetryos/cli'], {
-            cwd: projectPath,
-            stdio: 'inherit',
-            shell: true,
-        });
-        cliInstall.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`npm install -D @telemetryos/cli failed with code ${code}`));
-            }
-        });
-        cliInstall.on('error', (error) => {
-            reject(error);
-        });
-    });
-}
-function isInGitRepository(cwd) {
-    try {
-        execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function tryGitInit(projectPath) {
-    try {
-        execSync('git --version', { stdio: 'ignore' });
-        if (isInGitRepository(projectPath)) {
-            return false;
-        }
-        execSync('git init', { cwd: projectPath, stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function tryGitCommit(projectPath) {
-    try {
-        execSync('git add -A', { cwd: projectPath, stdio: 'ignore' });
-        execSync('git commit -m "Initialize project using TelemetryOS CLI"', {
-            cwd: projectPath,
-            stdio: 'ignore',
-        });
-        console.log('Created initial commit');
-        return true;
-    }
-    catch {
-        // Commit failed (e.g., git user not configured)
-        // Remove .git directory to avoid half-initialized state
-        console.log('Git commit not created');
-        console.log('Removing .git directory...');
-        try {
-            await fs.rm(path.join(projectPath, '.git'), { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-        return false;
-    }
-}
-export async function checkDirectoryConflicts(projectPath) {
-    try {
-        const entries = await fs.readdir(projectPath);
-        return entries.filter((file) => !safeExistingFiles.includes(file));
-    }
-    catch (error) {
-        // Directory doesn't exist, no conflicts
-        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-}
-export async function removeConflictingFiles(projectPath, conflicts) {
-    for (const file of conflicts) {
-        const filePath = path.join(projectPath, file);
-        try {
-            const stat = await fs.stat(filePath);
-            if (stat.isDirectory()) {
-                await fs.rm(filePath, { recursive: true, force: true });
-            }
-            else {
-                await fs.unlink(filePath);
-            }
-        }
-        catch (error) {
-            // Ignore errors for files that may have already been removed
-            console.error(`Warning: Could not remove ${file}: ${error instanceof Error ? error.message : error}`);
-        }
-    }
-}
-function printSuccessMessage(name, projectPath) {
-    // Calculate relative path from cwd for cleaner display
-    const relativePath = path.relative(process.cwd(), projectPath);
-    const displayPath = relativePath || '.';
-    console.log(`
-${ansi.green}Success!${ansi.reset} Created ${ansi.bold}${name}${ansi.reset} at ${ansi.cyan}${displayPath}${ansi.reset}
-
-Inside that directory, you can run:
-
-  ${ansi.cyan}npm run dev${ansi.reset}
-    Starts the development server
-
-  ${ansi.cyan}npm run build${ansi.reset}
-    Builds the app for production
-
-You may begin with:
-
-  ${ansi.cyan}cd ${displayPath}${ansi.reset}
-  ${ansi.cyan}npm run dev${ansi.reset}
-
-`);
-}
-async function copyDir(source, destination, replacements, progressFn) {
-    const dirListing = await fs.readdir(source);
-    for (const dirEntry of dirListing) {
-        if (ignoredTemplateFiles.includes(dirEntry))
-            continue;
-        const sourcePath = path.join(source, dirEntry);
-        const destinationPath = path.join(destination, dotfileNames.includes(dirEntry) ? `.${dirEntry.slice(1)}` : dirEntry);
-        const stats = await fs.stat(sourcePath);
-        if (stats.isDirectory()) {
-            await fs.mkdir(destinationPath, { recursive: true });
-            await copyDir(sourcePath, destinationPath, replacements, progressFn);
-        }
-        else if (stats.isFile()) {
-            await copyFile(sourcePath, destinationPath, replacements, progressFn);
-        }
-    }
-}
-async function copyFile(source, destination, replacements, progressFn) {
-    let contents = await fs.readFile(source, 'utf-8');
-    for (const [key, value] of Object.entries(replacements)) {
-        contents = contents.replace(new RegExp(`{{${key}}}`, 'g'), value);
-    }
-    await fs.writeFile(destination, contents, 'utf-8');
-    progressFn(destination);
-}

package/dist/services/project-config.d.ts

@@ -1,27 +0,0 @@
-import z from 'zod';
-export declare const projectConfigSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    version: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    logoPath: z.ZodOptional<z.ZodString>;
-    thumbnailPath: z.ZodOptional<z.ZodString>;
-    mountPoints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        path: z.ZodString;
-    }, z.z.core.$strip>, z.ZodString]>>>;
-    backgroundWorkers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        path: z.ZodString;
-    }, z.z.core.$strip>, z.ZodString]>>>;
-    serverWorkers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        path: z.ZodString;
-    }, z.z.core.$strip>, z.ZodString]>>>;
-    containers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        image: z.ZodString;
-    }, z.z.core.$strip>, z.ZodString]>>>;
-    useSpaRouting: z.ZodOptional<z.ZodBoolean>;
-    devServer: z.ZodOptional<z.ZodObject<{
-        runCommand: z.ZodOptional<z.ZodString>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>;
-}, z.z.core.$strip>;
-export type ProjectConfig = z.infer<typeof projectConfigSchema>;
-export declare function loadProjectConfig(projectPath: string): Promise<ProjectConfig>;

package/dist/services/project-config.js

@@ -1,54 +0,0 @@
-import { readFile } from 'fs/promises';
-import path from 'path';
-import z from 'zod';
-const mountPointSchema = z.object({
-    path: z.string(),
-});
-const backgroundWorkerSchema = z.object({
-    path: z.string(),
-});
-const serverWorkerSchema = z.object({
-    path: z.string(),
-});
-const containerSchema = z.object({
-    image: z.string(),
-});
-export const projectConfigSchema = z.object({
-    name: z.string().optional(),
-    version: z.string().optional(),
-    description: z.string().optional(),
-    logoPath: z.string().optional(),
-    thumbnailPath: z.string().optional(),
-    mountPoints: z.record(z.string(), z.union([mountPointSchema, z.string()])).optional(),
-    backgroundWorkers: z.record(z.string(), z.union([backgroundWorkerSchema, z.string()])).optional(),
-    serverWorkers: z.record(z.string(), z.union([serverWorkerSchema, z.string()])).optional(),
-    containers: z.record(z.string(), z.union([containerSchema, z.string()])).optional(),
-    useSpaRouting: z.boolean().optional(),
-    devServer: z
-        .object({
-        runCommand: z.string().optional(),
-        url: z.string(),
-    })
-        .optional(),
-});
-export async function loadProjectConfig(projectPath) {
-    const configPath = path.join(projectPath, 'telemetry.config.json');
-    try {
-        const content = await readFile(configPath, 'utf-8');
-        const parsed = JSON.parse(content);
-        return projectConfigSchema.parse(parsed);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`No telemetry.config.json found in ${projectPath}`);
-        }
-        if (error instanceof z.ZodError) {
-            const issues = error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`).join('\n');
-            throw new Error(`Invalid telemetry.config.json:\n${issues}`);
-        }
-        if (error instanceof SyntaxError) {
-            throw new Error(`Invalid JSON in telemetry.config.json: ${error.message}`);
-        }
-        throw error;
-    }
-}

package/dist/services/run-server.d.ts

@@ -1,5 +0,0 @@
-type Flags = {
-    port: number;
-};
-export declare function runServer(projectPath: string, flags: Flags): Promise<void>;
-export {};

package/dist/services/run-server.js

@@ -1,327 +0,0 @@
-import { spawn } from 'child_process';
-import { access, readFile } from 'fs/promises';
-import { fileURLToPath } from 'url';
-import http from 'http';
-import path from 'path';
-import { createInterface } from 'readline/promises';
-import serveHandler from 'serve-handler';
-import pkg from '../../package.json' with { type: 'json' };
-import { loadProjectConfig } from './project-config.js';
-import { ansi, ansiRegex } from '../utils/ansi.js';
-// import { handlePublishCommand } from '../commands/publish.js'
-const IMAGE_MIME_TYPES = {
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.png': 'image/png',
-    '.gif': 'image/gif',
-    '.svg': 'image/svg+xml',
-    '.webp': 'image/webp',
-};
-export async function runServer(projectPath, flags) {
-    printSplashScreen();
-    projectPath = path.resolve(process.cwd(), projectPath);
-    let projectConfig;
-    try {
-        projectConfig = await loadProjectConfig(projectPath);
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-    await serveDevelopmentApplicationHostUI(projectPath, flags.port, projectConfig);
-    await serveTelemetryApplication(projectPath, projectConfig);
-    // Print ready message after Vite is confirmed ready
-    printServerInfo(flags.port);
-}
-async function serveDevelopmentApplicationHostUI(projectPath, port, projectConfig) {
-    const hostUiPath = await import.meta.resolve('@telemetryos/development-application-host-ui/dist');
-    const serveConfig = { public: fileURLToPath(hostUiPath) };
-    const server = http.createServer();
-    server.on('request', async (req, res) => {
-        var _a, _b;
-        const url = new URL(req.url, `http://${req.headers.origin}`);
-        if (url.pathname === '/__tos-config__') {
-            res.setHeader('Content-Type', 'application/json');
-            res.end(JSON.stringify(projectConfig));
-            return;
-        }
-        if (url.pathname === '/__tos-logo__') {
-            await serveImageFile(res, projectPath, projectConfig.logoPath, 'logo');
-            return;
-        }
-        if (url.pathname === '/__tos-thumbnail__') {
-            await serveImageFile(res, projectPath, projectConfig.thumbnailPath, 'thumbnail');
-            return;
-        }
-        if (url.pathname === '/__dev_proxy__' && req.method === 'POST' && res) {
-            let body = '';
-            for await (const chunk of req) {
-                body += chunk;
-            }
-            try {
-                const { url, method, headers, body: requestBody } = JSON.parse(body);
-                const response = await fetch(url, {
-                    method,
-                    headers,
-                    body: requestBody !== null && requestBody !== void 0 ? requestBody : undefined,
-                });
-                const contentType = response.headers.get('content-type') || '';
-                const isJson = contentType.includes('application/json');
-                const isText = contentType.includes('text/') ||
-                    contentType.includes('application/javascript') ||
-                    contentType.includes('application/xml');
-                let responseBody;
-                let bodyType;
-                if (isJson) {
-                    const text = await response.text();
-                    responseBody = text ? JSON.parse(text) : null;
-                    bodyType = 'json';
-                }
-                else if (isText) {
-                    responseBody = await response.text();
-                    bodyType = 'text';
-                }
-                else {
-                    // Binary data - convert to base64 for JSON transport
-                    const arrayBuffer = await response.arrayBuffer();
-                    responseBody = Buffer.from(arrayBuffer).toString('base64');
-                    bodyType = 'binary';
-                }
-                const responseHeaders = {};
-                response.headers.forEach((value, key) => {
-                    responseHeaders[key] = value;
-                });
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    success: true,
-                    status: response.status,
-                    statusText: response.statusText,
-                    headers: responseHeaders,
-                    body: responseBody,
-                    bodyType,
-                    ok: response.ok,
-                    url: response.url,
-                }));
-            }
-            catch (error) {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    success: false,
-                    errorMessage: `Proxy fetch failed: ${String(error)}`,
-                    errorCause: error.cause ? String((_b = (_a = error.cause) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : error.cause) : undefined,
-                }));
-            }
-            return;
-        }
-        // TODO: Publish endpoint disabled until auth is working
-        // if (url.pathname === '/__publish__') {
-        //   if (req.method !== 'GET') {
-        //     res.statusCode = 405
-        //     res.end('Method not allowed')
-        //     return
-        //   }
-        //
-        //   // Set SSE headers
-        //   res.setHeader('Content-Type', 'text/event-stream')
-        //   res.setHeader('Cache-Control', 'no-cache')
-        //   res.setHeader('Connection', 'keep-alive')
-        //
-        //   const sendEvent = (event: string, data: any) => {
-        //     res.write(`event: ${event}\n`)
-        //     res.write(`data: ${JSON.stringify(data)}\n\n`)
-        //   }
-        //
-        //   try {
-        //     sendEvent('state', { state: 'starting' })
-        //
-        //     await handlePublishCommand(
-        //       projectPath,
-        //       {},
-        //       {
-        //         onLog: (line: string) => {
-        //           sendEvent('log', { message: line })
-        //         },
-        //         onStateChange: (state: string) => {
-        //           sendEvent('state', { state })
-        //         },
-        //         onComplete: (data: { success: boolean; buildIndex?: number; duration?: string }) => {
-        //           sendEvent('complete', data)
-        //           res.end()
-        //         },
-        //         onError: (error: Error) => {
-        //           const isAuthError =
-        //             error.message.includes('authenticate') ||
-        //             error.message.includes('Not authenticated')
-        //           sendEvent('error', {
-        //             error: error.message,
-        //             code: isAuthError ? 'AUTH_REQUIRED' : 'PUBLISH_FAILED',
-        //             message: isAuthError
-        //               ? "Run 'tos auth' in the terminal to authenticate"
-        //               : error.message,
-        //           })
-        //           res.end()
-        //         },
-        //       },
-        //     )
-        //   } catch (error) {
-        //     sendEvent('error', {
-        //       error: (error as Error).message,
-        //       code: 'UNEXPECTED_ERROR',
-        //       message: (error as Error).message,
-        //     })
-        //     res.end()
-        //   }
-        //   return
-        // }
-        serveHandler(req, res, serveConfig).catch((err) => {
-            console.error('Error handling request:', err);
-            res.statusCode = 500;
-            res.end('Internal Server Error');
-        });
-    });
-    server.listen(port);
-}
-async function serveImageFile(res, projectPath, filePath, label) {
-    if (!filePath) {
-        res.statusCode = 404;
-        res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-        res.end(`No ${label} configured`);
-        return;
-    }
-    const projectRoot = path.resolve(projectPath);
-    const validatePath = (fullPath) => fullPath.startsWith(projectRoot + path.sep) || fullPath === projectRoot;
-    // Try public/ first (Vite convention), then project root (backward compat)
-    const publicPath = path.resolve(projectPath, 'public', filePath);
-    const rootPath = path.resolve(projectPath, filePath);
-    let resolvedPath;
-    if (validatePath(publicPath)) {
-        try {
-            await access(publicPath);
-            resolvedPath = publicPath;
-        }
-        catch { }
-    }
-    if (!resolvedPath && validatePath(rootPath)) {
-        resolvedPath = rootPath;
-    }
-    if (!resolvedPath) {
-        res.statusCode = 403;
-        res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-        res.end('Forbidden: path escapes project root');
-        return;
-    }
-    try {
-        const imageData = await readFile(resolvedPath);
-        const ext = path.extname(filePath).toLowerCase();
-        const contentType = IMAGE_MIME_TYPES[ext] || 'application/octet-stream';
-        res.setHeader('Content-Type', contentType);
-        res.end(imageData);
-    }
-    catch (error) {
-        res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-        if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT') {
-            res.statusCode = 404;
-            res.end(`${label.charAt(0).toUpperCase() + label.slice(1)} file not found`);
-        }
-        else {
-            res.statusCode = 500;
-            res.end(`Error reading ${label}: ${(error === null || error === void 0 ? void 0 : error.message) || 'unknown error'}`);
-        }
-    }
-}
-async function serveTelemetryApplication(rootPath, projectConfig) {
-    return new Promise((resolve, reject) => {
-        var _a;
-        if (!((_a = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.devServer) === null || _a === void 0 ? void 0 : _a.runCommand)) {
-            console.log('No value in config at devServer.runCommand');
-            resolve();
-            return;
-        }
-        const runCommand = projectConfig.devServer.runCommand;
-        const binPath = path.join(rootPath, 'node_modules', '.bin');
-        const childProcess = spawn(runCommand, {
-            shell: true,
-            env: {
-                ...process.env,
-                FORCE_COLOR: '1',
-                PATH: `${binPath}${path.delimiter}${process.env.PATH}`,
-            },
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: rootPath,
-        });
-        const stdoutReadline = createInterface({
-            input: childProcess.stdout,
-            crlfDelay: Infinity,
-        });
-        const stderrReadline = createInterface({
-            input: childProcess.stderr,
-            crlfDelay: Infinity,
-        });
-        let cleaned = false;
-        const cleanup = () => {
-            if (cleaned)
-                return;
-            cleaned = true;
-            process.removeListener('exit', onParentExit);
-            clearTimeout(timeoutHandle);
-            childProcess.kill();
-            stdoutReadline.close();
-            stderrReadline.close();
-        };
-        const onParentExit = () => {
-            console.log('Shutting down development server...');
-            cleanup();
-        };
-        process.on('exit', onParentExit);
-        const timeoutHandle = setTimeout(() => {
-            cleanup();
-            reject(new Error('Vite dev server did not start within 30 seconds'));
-        }, 30000);
-        let viteReady = false;
-        stdoutReadline.on('line', (line) => {
-            console.log(`[application]: ${line}`);
-            // Detect Vite ready signal
-            if (!viteReady) {
-                const cleanLine = line.replace(ansiRegex, '');
-                if (cleanLine.includes('VITE') && cleanLine.includes('ready in')) {
-                    viteReady = true;
-                    clearTimeout(timeoutHandle);
-                    resolve();
-                }
-            }
-        });
-        stderrReadline.on('line', (line) => {
-            console.error(`[application]: ${line}`);
-        });
-        childProcess.on('error', (error) => {
-            if (!viteReady) {
-                cleanup();
-                reject(error);
-            }
-        });
-        childProcess.on('close', (code) => {
-            if (!viteReady) {
-                cleanup();
-                reject(new Error(`Dev server process exited with code ${code} before becoming ready`));
-            }
-        });
-    });
-}
-function printSplashScreen() {
-    console.log(`
-
-     ${ansi.white} █       █                  █          ${ansi.yellow}▄▀▀▀▄ ▄▀▀▀▄
-     ${ansi.white} █       █                  █          ${ansi.yellow}█   █ █
-     ${ansi.white}▀█▀ ▄▀▀▄ █ ▄▀▀▄ █▀▄▀▄ ▄▀▀▄ ▀█▀ █▄▀ █ █ ${ansi.yellow}█   █  ▀▀▀▄
-     ${ansi.white} █  █▀▀▀ █ █▀▀▀ █ █ █ █▀▀▀  █  █   █ █ ${ansi.yellow}█   █     █
-     ${ansi.white} ▀▄ ▀▄▄▀ █ ▀▄▄▀ █ █ █ ▀▄▄▀  ▀▄ █    █  ${ansi.yellow}▀▄▄▄▀ ▀▄▄▄▀
-     ${ansi.white}                                   ▄▀  ${ansi.reset}
-     v${pkg.version}`);
-}
-function printServerInfo(port) {
-    console.log(`
-╔═══════════════════════════════════════════════════════════╗
-║ ${ansi.bold}Development environment running at: ${ansi.cyan}http://localhost:${port}${ansi.reset} ║
-╚═══════════════════════════════════════════════════════════╝
-`);
-}

package/dist/types/api.d.ts

@@ -1,44 +0,0 @@
-export type ApplicationKind = 'git' | 'github' | 'uploaded' | null;
-export type Application = {
-    id: string;
-    title: string;
-    description: string;
-    kind: ApplicationKind;
-    baseImage: string;
-    buildWorkingPath?: string;
-    buildScript?: string;
-    buildOutputPath?: string;
-    buildEnvironmentVariables?: Record<string, string>;
-    versions?: ApplicationVersion[];
-    createdAt?: string;
-    updatedAt?: string;
-};
-export type ApplicationVersion = {
-    name?: string;
-    version?: string;
-    applicationId: string;
-    buildId: string;
-    applicationSpecifier: string;
-    publishedAt: string;
-};
-export type ApplicationBuild = {
-    id: string;
-    applicationId: string;
-    index: number;
-    state: 'pending' | 'building' | 'success' | 'failure' | 'failed' | 'cancelled';
-    logs: string[];
-    scheduledAt?: string;
-    startedAt?: string;
-    finishedAt?: string;
-};
-export type CreateApplicationRequest = {
-    kind: 'uploaded';
-    title: string;
-    description?: string;
-    baseImage: string;
-    baseImageRegistryAuth: string;
-    buildWorkingPath: string;
-    buildScript: string;
-    buildOutputPath: string;
-    buildEnvironmentVariables?: Record<string, string>;
-};

package/dist/types/api.js

@@ -1 +0,0 @@
-export {};