@telemetryos/cli 1.17.0 → 1.17.1

package/dist/services/run-server.js

@@ -0,0 +1,327 @@
+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/applications.d.ts

@@ -0,0 +1,44 @@
+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/applications.js

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

package/dist/utils/ansi.d.ts

@@ -0,0 +1,11 @@
+export declare const ansi: {
+    readonly white: "\u001B[37m";
+    readonly yellow: "\u001B[33m";
+    readonly green: "\u001B[32m";
+    readonly cyan: "\u001B[36m";
+    readonly red: "\u001B[31m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly reset: "\u001B[0m";
+};
+export declare const ansiRegex: RegExp;

package/dist/utils/ansi.js

@@ -0,0 +1,11 @@
+export const ansi = {
+    white: '\u001b[37m',
+    yellow: '\u001b[33m',
+    green: '\u001b[32m',
+    cyan: '\u001b[36m',
+    red: '\u001b[31m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    reset: '\u001b[0m',
+};
+export const ansiRegex = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g');

package/dist/utils/path-utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Converts a string to kebab-case
+ *
+ * @param str - The string to convert
+ * @returns The kebab-cased string
+ *
+ * @example
+ * toKebabCase('MyApp') // 'my-app'
+ * toKebabCase('my_app') // 'my-app'
+ * toKebabCase('My App!') // 'my-app'
+ * toKebabCase('my--app') // 'my-app'
+ */
+export declare function toKebabCase(str: string): string;
+/**
+ * Derives a project name from a given path
+ *
+ * @param projectPath - The path to derive the name from
+ * @param currentWorkingDirectory - The current working directory (defaults to process.cwd())
+ * @returns The derived project name in kebab-case
+ *
+ * @example
+ * deriveProjectName('my-project') // 'my-project'
+ * deriveProjectName('apps/MyApp') // 'my-app'
+ * deriveProjectName('./', '/Users/test/MyProject') // 'my-project'
+ * deriveProjectName('../parent') // 'parent'
+ * deriveProjectName('/absolute/path/to/app') // 'app'
+ */
+export declare function deriveProjectName(projectPath: string, currentWorkingDirectory?: string): string;
+/**
+ * Resolves a project path and derives the name
+ *
+ * @param projectPath - The path to resolve
+ * @param currentWorkingDirectory - The current working directory (defaults to process.cwd())
+ * @returns An object containing the resolved path and derived name
+ *
+ * @example
+ * resolveProjectPathAndName('apps/MyApp')
+ * // { resolvedPath: '/Users/user/cwd/apps/MyApp', derivedName: 'my-app' }
+ */
+export declare function resolveProjectPathAndName(projectPath: string, currentWorkingDirectory?: string): {
+    resolvedPath: string;
+    derivedName: string;
+};
+/**
+ * Validates a project name according to npm package name requirements
+ *
+ * @param name - The project name to validate
+ * @returns true if valid, or an error message string if invalid
+ *
+ * @example
+ * validateProjectName('my-app') // true
+ * validateProjectName('') // 'Project name cannot be empty'
+ * validateProjectName('MyApp') // 'Project name must contain only lowercase letters, numbers, and hyphens'
+ */
+export declare function validateProjectName(name: string): true | string;

package/dist/utils/path-utils.js

@@ -0,0 +1,99 @@
+/**
+ * Utility functions for path handling and project name derivation
+ */
+import path from 'node:path';
+/**
+ * Converts a string to kebab-case
+ *
+ * @param str - The string to convert
+ * @returns The kebab-cased string
+ *
+ * @example
+ * toKebabCase('MyApp') // 'my-app'
+ * toKebabCase('my_app') // 'my-app'
+ * toKebabCase('My App!') // 'my-app'
+ * toKebabCase('my--app') // 'my-app'
+ */
+export function toKebabCase(str) {
+    return (str
+        .trim()
+        // Remove special characters except spaces, underscores, and hyphens
+        .replace(/[^a-zA-Z0-9\s_-]/g, '')
+        // Replace spaces and underscores with hyphens
+        .replace(/[\s_]+/g, '-')
+        // Insert hyphen before uppercase letters preceded by lowercase
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        // Convert to lowercase
+        .toLowerCase()
+        // Replace multiple consecutive hyphens with single hyphen
+        .replace(/-+/g, '-')
+        // Remove leading/trailing hyphens
+        .replace(/^-+|-+$/g, ''));
+}
+/**
+ * Derives a project name from a given path
+ *
+ * @param projectPath - The path to derive the name from
+ * @param currentWorkingDirectory - The current working directory (defaults to process.cwd())
+ * @returns The derived project name in kebab-case
+ *
+ * @example
+ * deriveProjectName('my-project') // 'my-project'
+ * deriveProjectName('apps/MyApp') // 'my-app'
+ * deriveProjectName('./', '/Users/test/MyProject') // 'my-project'
+ * deriveProjectName('../parent') // 'parent'
+ * deriveProjectName('/absolute/path/to/app') // 'app'
+ */
+export function deriveProjectName(projectPath, currentWorkingDirectory = process.cwd()) {
+    // Resolve the path to handle relative paths
+    const resolvedPath = path.resolve(currentWorkingDirectory, projectPath);
+    // Get the last segment of the path
+    const basename = path.basename(resolvedPath);
+    // Convert to kebab-case
+    return toKebabCase(basename);
+}
+/**
+ * Resolves a project path and derives the name
+ *
+ * @param projectPath - The path to resolve
+ * @param currentWorkingDirectory - The current working directory (defaults to process.cwd())
+ * @returns An object containing the resolved path and derived name
+ *
+ * @example
+ * resolveProjectPathAndName('apps/MyApp')
+ * // { resolvedPath: '/Users/user/cwd/apps/MyApp', derivedName: 'my-app' }
+ */
+export function resolveProjectPathAndName(projectPath, currentWorkingDirectory = process.cwd()) {
+    const resolvedPath = path.resolve(currentWorkingDirectory, projectPath);
+    const derivedName = deriveProjectName(projectPath, currentWorkingDirectory);
+    return { resolvedPath, derivedName };
+}
+/**
+ * Validates a project name according to npm package name requirements
+ *
+ * @param name - The project name to validate
+ * @returns true if valid, or an error message string if invalid
+ *
+ * @example
+ * validateProjectName('my-app') // true
+ * validateProjectName('') // 'Project name cannot be empty'
+ * validateProjectName('MyApp') // 'Project name must contain only lowercase letters, numbers, and hyphens'
+ */
+export function validateProjectName(name) {
+    if (!name || name.length === 0) {
+        return 'Project name cannot be empty';
+    }
+    if (name.length > 214) {
+        return 'Project name must be 214 characters or less';
+    }
+    if (name.startsWith('.') || name.startsWith('_')) {
+        return 'Project name cannot start with . or _';
+    }
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        return 'Project name must contain only lowercase letters, numbers, and hyphens';
+    }
+    if (name.startsWith('-') || name.endsWith('-')) {
+        return 'Project name cannot start or end with a hyphen';
+    }
+    return true;
+}

package/dist/utils/template.d.ts

@@ -0,0 +1,2 @@
+export declare const templatesDir: string;
+export declare function copyDir(source: string, destination: string, replacements: Record<string, string>, progressFn: (createdFilePath: string) => void): Promise<void>;

package/dist/utils/template.js

@@ -0,0 +1,30 @@
+import fs from 'fs/promises';
+import path from 'path';
+export const templatesDir = path.join(import.meta.dirname, '../../templates');
+const ignoredTemplateFiles = ['.DS_Store', 'thumbs.db', 'node_modules', '.git', 'dist'];
+const dotfileNames = ['_gitignore', '_claude'];
+export 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetryos/cli",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "description": "The official TelemetryOS application CLI package. Use it to build applications that run on the TelemetryOS platform",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
   "license": "",
   "repository": "github:TelemetryTV/Application-API",
   "dependencies": {
-    "@telemetryos/development-application-host-ui": "^1.17.0",
+    "@telemetryos/development-application-host-ui": "^1.17.1",
     "@types/serve-handler": "^6.1.4",
     "commander": "^14.0.0",
     "ignore": "^6.0.2",