@telemetryos/cli 1.11.0 → 1.13.0

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @telemetryos/cli
 
+## 1.13.0
+
+### Minor Changes
+
+- ### New Features
+  - **Web mount point support** — Applications can now define a third UI surface (`/web`) alongside Render and Settings, enabling web-portal-style interfaces with full navigation control via a postMessage bridge.
+  - **`playlist.getDuration()`** — New async method returns the playlist-configured page duration in seconds.
+  - **Custom logo support** — Projects can specify a `logoPath` in `telemetry.config.json` for branding in the dev host.
+  - **`tos claude-code` command** — New CLI command to apply or update Claude Code skills and settings in existing projects.
+  - **Web project template** — New `vite-react-typescript-web` template scaffolds a project with all three mount points pre-configured.
+
+  ### Bug Fixes
+  - Fixed SDK client not properly validating bridge message responses.
+  - Fixed canvas not resizing when the sidebar toggles or window resizes after a manual drag-resize.
+  - Fixed `isLoading` usage and `useEffect` dependency arrays in Claude Code skill examples.
+  - Fixed stale active tab when the tabs array changes in the dev host.
+
+  ### Infrastructure
+  - Renamed `generate-application` to `create-project`; extracted shared template utilities.
+  - Added unit tests for Navigation, Currency, and Weather classes.
+
+### Patch Changes
+
+- Updated dependencies
+  - @telemetryos/development-application-host-ui@1.13.0
+
+## 1.12.0
+
+### Minor Changes
+
+- Revamp the dev host
+
+### Patch Changes
+
+- Updated dependencies
+  - @telemetryos/development-application-host-ui@1.12.0
+
 ## 1.11.0
 
 ### Minor Changes

package/dist/commands/claude-code.d.ts

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

package/dist/commands/claude-code.js

@@ -0,0 +1,29 @@
+import { Command } from 'commander';
+import path from 'path';
+import { loadProjectConfig } from '../services/project-config.js';
+import { copyDir, templatesDir } from '../utils/template.js';
+import { ansi } from '../utils/ansi.js';
+export const claudeCodeCommand = new Command('claude-code')
+    .description('Apply or update Claude Code skills and settings in a project')
+    .argument('[project-path]', 'Path to the telemetryOS project (defaults to current directory)', process.cwd())
+    .action(handleClaudeCodeCommand);
+async function handleClaudeCodeCommand(projectPath) {
+    var _a, _b, _c;
+    const resolvedPath = path.resolve(projectPath);
+    let config;
+    try {
+        config = await loadProjectConfig(resolvedPath);
+    }
+    catch (error) {
+        console.error(`\n${ansi.red}Error:${ansi.reset} ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+    const name = (_a = config.name) !== null && _a !== void 0 ? _a : '';
+    const description = (_b = config.description) !== null && _b !== void 0 ? _b : '';
+    const version = (_c = config.version) !== null && _c !== void 0 ? _c : '';
+    console.log(`\nApplying Claude Code skills and settings...\n`);
+    await copyDir(path.join(templatesDir, 'claude-code'), resolvedPath, { name, version, description, author: '' }, (createdFilePath) => {
+        console.log(`.${path.sep}${path.relative(process.cwd(), createdFilePath)}`);
+    });
+    console.log(`\n${ansi.green}Done!${ansi.reset} Claude Code skills and settings have been applied.`);
+}

package/dist/commands/init.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { generateApplication, checkDirectoryConflicts, removeConflictingFiles, } from '../services/generate-application.js';
+import { createProject, checkDirectoryConflicts, removeConflictingFiles, } from '../services/create-project.js';
 import inquirer from 'inquirer';
 import path from 'path';
 import { resolveProjectPathAndName, validateProjectName } from '../utils/path-utils.js';
@@ -26,10 +26,11 @@ export const initCommand = new Command('init')
     .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)', '')
+    .option('-t, --template <string>', 'The template to use (vite-react-typescript, vite-react-typescript-web)', '')
     .option('-y, --yes', 'Skip all prompts and use defaults', false)
     .action(handleInitCommand);
 async function handleInitCommand(projectPathArg, options) {
+    var _a, _b, _c, _d, _e, _f;
     // Step 1: Resolve path and derive name
     const cwd = process.cwd();
     const inputPath = projectPathArg || '.';
@@ -80,6 +81,7 @@ async function handleInitCommand(projectPathArg, options) {
     let author = options.author;
     let version = options.version;
     let template = options.template;
+    let claudeCode = true;
     // Step 5: Build prompt questions (skipped with --yes)
     if (options.yes) {
         if (!name) {
@@ -138,23 +140,34 @@ async function handleInitCommand(projectPathArg, options) {
                 type: 'list',
                 name: 'template',
                 message: 'Which template would you like to use?',
-                choices: [{ name: 'Vite + React + TypeScript', value: 'vite-react-typescript' }],
+                choices: [
+                    { name: 'Vite + React + TypeScript', value: 'vite-react-typescript' },
+                    { name: 'Vite + React + TypeScript + Web', value: 'vite-react-typescript-web' },
+                ],
             });
+        questions.push({
+            type: 'confirm',
+            name: 'claudeCode',
+            message: 'Include Claude Code skills and settings?',
+            default: true,
+        });
         // 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;
+        name = (_a = answers.name) !== null && _a !== void 0 ? _a : name;
+        version = (_b = answers.version) !== null && _b !== void 0 ? _b : version;
+        description = (_c = answers.description) !== null && _c !== void 0 ? _c : description;
+        author = (_d = answers.author) !== null && _d !== void 0 ? _d : author;
+        template = (_e = answers.template) !== null && _e !== void 0 ? _e : template;
+        claudeCode = (_f = answers.claudeCode) !== null && _f !== void 0 ? _f : claudeCode;
     }
     // Step 7: Generate application
-    await generateApplication({
+    await createProject({
         name,
         description,
         author,
         version,
         template,
+        claudeCode,
         projectPath: resolvedPath,
         progressFn: (createdFilePath) => {
             console.log(`.${path.sep}${path.relative(cwd, createdFilePath)}`);

package/dist/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import { authCommand } from './commands/auth.js';
+import { claudeCodeCommand } from './commands/claude-code.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(claudeCodeCommand);
 rootCommand.addCommand(serveCommand);
 rootCommand.addCommand(initCommand);
 rootCommand.addCommand(publishCommand);

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

@@ -0,0 +1,13 @@
+export type CreateProjectOptions = {
+    name: string;
+    description: string;
+    author: string;
+    version: string;
+    template: string;
+    claudeCode: boolean;
+    projectPath: string;
+    progressFn: (createdFilePath: string) => void;
+};
+export declare function createProject(options: CreateProjectOptions): Promise<void>;
+export declare function checkDirectoryConflicts(projectPath: string): Promise<string[]>;
+export declare function removeConflictingFiles(projectPath: string, conflicts: string[]): Promise<void>;

package/dist/services/create-project.js

@@ -0,0 +1,188 @@
+import { spawn, execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { ansi } from '../utils/ansi.js';
+import { copyDir, templatesDir } from '../utils/template.js';
+// 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 createProject(options) {
+    const { name, description, author, version, template, claudeCode, 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);
+    // Optionally apply Claude Code overlay (skills and settings)
+    if (claudeCode) {
+        await copyDir(path.join(templatesDir, 'claude-code'), 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}
+
+`);
+}

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

@@ -2,6 +2,8 @@ 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;
@@ -15,6 +17,7 @@ export declare const projectConfigSchema: z.ZodObject<{
     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;

package/dist/services/project-config.js

@@ -16,11 +16,14 @@ const containerSchema = z.object({
 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(),