slicejs-cli 3.5.1 → 3.6.1

package/commands/utils/updateManager.js

@@ -7,6 +7,7 @@ import ora from "ora";
 import Print from "../Print.js";
 import versionChecker from "./VersionChecker.js";
 import { getProjectRoot, getApiPath, getPath } from "../utils/PathHelper.js";
+import { resolvePackageManager, installCommand } from "../utils/PackageManager.js";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs-extra";
@@ -18,28 +19,45 @@ export class UpdateManager {
         this.packagesToUpdate = [];
     }
 
+    getPackageManager() {
+        if (!this._packageManager) {
+            this._packageManager = resolvePackageManager(getProjectRoot(import.meta.url)).name;
+        }
+        return this._packageManager;
+    }
+
     async detectCliInstall() {
         try {
             const moduleDir = path.dirname(fileURLToPath(import.meta.url));
             const cliRoot = path.join(moduleDir, '../../');
             const projectRoot = getProjectRoot(import.meta.url);
+            const packageManager = this.getPackageManager();
+            const localNodeModules = path.join(projectRoot, 'node_modules');
+
+            if (cliRoot.startsWith(localNodeModules)) {
+                return { type: 'local', cliRoot, projectRoot, packageManager };
+            }
+
+            // Global pnpm installs live under PNPM_HOME — `npm config get prefix`
+            // knows nothing about them (and npm may not even exist on the machine).
+            const pnpmHome = process.env.PNPM_HOME;
+            if (pnpmHome && cliRoot.startsWith(pnpmHome)) {
+                return { type: 'global', cliRoot, projectRoot, packageManager: 'pnpm' };
+            }
+
             let globalPrefix = '';
             try {
                 const { stdout } = await execAsync('npm config get prefix');
                 globalPrefix = stdout.toString().trim();
             } catch {}
-            const localNodeModules = path.join(projectRoot, 'node_modules');
             const globalNodeModules = globalPrefix ? path.join(globalPrefix, 'node_modules') : '';
-
-            if (cliRoot.startsWith(localNodeModules)) {
-                return { type: 'local', cliRoot, projectRoot, globalPrefix };
-            }
             if (globalNodeModules && cliRoot.startsWith(globalNodeModules)) {
-                return { type: 'global', cliRoot, projectRoot, globalPrefix };
+                return { type: 'global', cliRoot, projectRoot, packageManager: 'npm' };
             }
-            return { type: 'unknown', cliRoot, projectRoot, globalPrefix };
+
+            return { type: 'unknown', cliRoot, projectRoot, packageManager };
         } catch (error) {
-            return { type: 'unknown' };
+            return { type: 'unknown', packageManager: this.getPackageManager() };
         }
     }
 
@@ -180,17 +198,12 @@ export class UpdateManager {
     async buildUpdatePlan(packages) {
         const plan = [];
         const info = await this.detectCliInstall();
+        const pm = info.packageManager || this.getPackageManager();
         for (const pkg of packages) {
-            if (pkg === 'slicejs-cli') {
-                if (info.type === 'global') {
-                    plan.push({ package: pkg, target: 'global', command: 'npm install -g slicejs-cli@latest' });
-                } else {
-                    plan.push({ package: pkg, target: 'project', command: 'npm install slicejs-cli@latest' });
-                }
-            } else if (pkg === 'slicejs-web-framework') {
-                plan.push({ package: pkg, target: 'project', command: 'npm install slicejs-web-framework@latest' });
+            if (pkg === 'slicejs-cli' && info.type === 'global') {
+                plan.push({ package: pkg, target: 'global', command: installCommand(pm, 'slicejs-cli@latest', { global: true }) });
             } else {
-                plan.push({ package: pkg, target: 'project', command: `npm install ${pkg}@latest` });
+                plan.push({ package: pkg, target: 'project', command: installCommand(pm, `${pkg}@latest`) });
             }
         }
         return plan;
@@ -201,15 +214,15 @@ export class UpdateManager {
      */
     async updatePackage(packageName) {
         try {
-            let installCmd = `npm install ${packageName}@latest`;
-            let uninstallCmd = `npm uninstall ${packageName}`;
+            const pm = this.getPackageManager();
+            let installCmd = installCommand(pm, `${packageName}@latest`);
             let options = {};
 
             if (packageName === 'slicejs-cli') {
                 const info = await this.detectCliInstall();
                 if (info.type === 'global') {
-                    installCmd = `npm install -g slicejs-cli@latest`;
-                    uninstallCmd = `npm uninstall -g slicejs-cli`;
+                    const globalPm = info.packageManager || pm;
+                    installCmd = installCommand(globalPm, 'slicejs-cli@latest', { global: true });
                 } else {
                     options.cwd = info.projectRoot || getProjectRoot(import.meta.url);
                 }
@@ -217,11 +230,9 @@ export class UpdateManager {
                 options.cwd = getProjectRoot(import.meta.url);
             }
 
-            // Try uninstall first (ignore failure)
-            try {
-                await execAsync(uninstallCmd, options);
-            } catch {}
-
+            // Install directly — npm/pnpm upgrade in place. (We used to uninstall
+            // first, which left the project without the package whenever the
+            // subsequent install failed, e.g. offline or under a release-age policy.)
             const { stdout, stderr } = await execAsync(installCmd, options);
 
             return {
@@ -284,13 +295,12 @@ export class UpdateManager {
                 return false;
             }
 
-            if (updateInfo.allCurrent) {
-                Print.success('✅ All components are up to date!');
-                return true;
-            }
-
-            if (!updateInfo.hasUpdates) {
+            if (updateInfo.allCurrent || !updateInfo.hasUpdates) {
                 Print.success('✅ All components are up to date!');
+                // --update-api works even when no package update runs.
+                if (options.updateApi) {
+                    await this.updateApiIndexIfNeeded(options);
+                }
                 return true;
             }
 
@@ -341,7 +351,7 @@ export class UpdateManager {
                 }
             } else {
                 Print.warning('Global CLI detected. It is recommended to update slicejs-cli globally to keep aligned with the framework.');
-                console.log('   Suggestion: npm install -g slicejs-cli@latest');
+                console.log(`   Suggestion: ${installCommand(cliInfo.packageManager || this.getPackageManager(), 'slicejs-cli@latest', { global: true })}`);
                 console.log('');
             }
         }
@@ -386,7 +396,7 @@ export class UpdateManager {
             }
 
             const frameworkUpdated = results.find(r => r.packageName === 'slicejs-web-framework' && r.success);
-            if (frameworkUpdated) {
+            if (frameworkUpdated || options.updateApi) {
                 await this.updateApiIndexIfNeeded(options);
             }
 
@@ -417,7 +427,16 @@ export class UpdateManager {
 
             Print.warning('⚠️ Detected changes in framework api/index.js.');
 
-            let confirmUpdate = options.yes === true;
+            // Overwriting api/index.js is opt-in: `--update-api` is the only way
+            // to auto-confirm. `-y/--yes` deliberately does NOT imply it — the
+            // project file may carry local changes, so a blanket "yes to updates"
+            // must not silently replace it.
+            let confirmUpdate = options.updateApi === true;
+            if (!confirmUpdate && options.yes === true) {
+                Print.info('Skipping api/index.js update (not updated by default).');
+                Print.info('Run "slice update --update-api" to update it (a .bak backup is created).');
+                return;
+            }
             if (!confirmUpdate) {
                 const answers = await inquirer.prompt([
                     {

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "slicejs-cli",
-  "version": "3.5.1",
+  "version": "3.6.1",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {
     "slice": "./client.js"
   },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "client.js",
+    "post.js",
+    "commands",
+    "assets"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/vkneider/slicejs-cli.git"
@@ -14,6 +23,7 @@
     "test": "node --test",
     "postinstall": "node post.js",
     "slice:dev": "slice dev",
+    "slice:build": "slice build",
     "slice:start": "slice start",
     "slice:create": "slice component create",
     "slice:list": "slice component list",
@@ -38,6 +48,7 @@
   ],
   "author": "vkneider",
   "type": "module",
+  "packageManager": "pnpm@11.1.1",
   "preferGlobal": false,
   "license": "ISC",
   "dependencies": {

package/post.js

@@ -2,35 +2,29 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { getProjectRoot, getPath } from './commands/utils/PathHelper.js';
+import { SLICE_SCRIPTS } from './commands/utils/sliceScripts.js';
+import { resolvePackageManager, runScriptCommand } from './commands/utils/PackageManager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 
-const isGlobal = process.env.npm_config_global === 'true';
+// npm sets npm_config_global; pnpm does not — for pnpm a global install lives
+// under PNPM_HOME, so detect it by where this script is running from.
+const pnpmHome = process.env.PNPM_HOME;
+const isGlobal = process.env.npm_config_global === 'true'
+    || (pnpmHome && __filename.startsWith(pnpmHome));
 
 if (isGlobal) {
     console.log('⚠️  Global installation of slicejs-cli detected.');
     console.log('   We strongly recommend using a local installation to avoid version mismatches.');
-    console.log('   Uninstall global: npm uninstall -g slicejs-cli');
+    console.log(`   Uninstall global: ${pnpmHome ? 'pnpm remove -g slicejs-cli' : 'npm uninstall -g slicejs-cli'}`);
     process.exit(0);
 }
 
 const projectRoot = getProjectRoot(import.meta.url);
 const pkgPath = getPath(import.meta.url, 'package.json');
+const packageManager = resolvePackageManager(projectRoot).name;
 
-const sliceScripts = {
-    'slice:dev': 'slice dev',
-    'slice:start': 'slice start',
-    'slice:create': 'slice component create',
-    'slice:list': 'slice component list',
-    'slice:delete': 'slice component delete',
-    'slice:init': 'slice init',
-    'slice:get': 'slice get',
-    'slice:browse': 'slice browse',
-    'slice:sync': 'slice sync',
-    'slice:version': 'slice version',
-    'slice:update': 'slice update',
-    'slice:types': 'slice types generate',
-};
+const sliceScripts = SLICE_SCRIPTS;
 
 try {
     let pkg = {};
@@ -55,12 +49,12 @@ try {
     }
 
     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2), 'utf-8');
-    console.log(`✅  slicejs-cli installed successfully. Added ${addedCount} npm scripts to package.json.`);
-    console.log('   Run: npm run slice:dev');
+    console.log(`✅  slicejs-cli installed successfully. Added ${addedCount} package scripts to package.json.`);
+    console.log(`   Run: ${runScriptCommand(packageManager, 'slice:dev')}`);
 } catch (err) {
     console.log('✅  slicejs-cli installed successfully.');
     console.log('   Could not auto-configure scripts:', err.message);
-    console.log('   Run: npx slice dev');
+    console.log(`   Configure scripts manually and run: ${runScriptCommand(packageManager, 'slice:dev')}`);
 }
 
 process.exit(0);

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug Report
-about: Report a bug in a component or the parser
-title: ''
-labels: bug
-assignees: ''
----
-
-## Description
-A clear description of the bug.
-
-## Reproduction
-Steps to reproduce:
-1. Go to '...'
-2. Click on '...'
-3. Error: '...'
-
-## Expected behavior
-What should have happened.
-
-## Environment
-- Browser/Node version:
-- OS:
-- slice.js_visual_library version:
-
-## Screenshots / Console output
-If applicable.
-
-## Additional context

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,25 +0,0 @@
----
-name: Feature Request
-about: Suggest a new component or improvement
-title: ''
-labels: enhancement
-assignees: ''
----
-
-## Problem
-What problem does this solve? (e.g. "I need a component that...")
-
-## Proposed solution
-How should it work? Include props, behavior, and visual details if applicable.
-
-## Alternatives considered
-What other approaches have you considered?
-
-## Example usage
-```javascript
-const component = await slice.build('ComponentName', {
-  // props here
-});
-```
-
-## Additional context

package/.github/pull_request_template.md

@@ -1,22 +0,0 @@
-## Summary
-- 
-
-## Docs Scope
-- [ ] Visual library docs pages (`src/markdown/` and generated outputs)
-- [ ] Parser logic (`parser/`)
-- [ ] Routes/index sync (`documentationRoutes.generated.js`, `docsIndex.js`, `components.js`)
-
-## Verification
-- [ ] `npm run docs:lint-md`
-- [ ] `npm run docs:generate`
-- [ ] `node --test parser/tests/index.test.js`
-
-## Screenshots / UI Notes
-- 
-
-## Breaking Changes
-- [ ] None
-- [ ] Yes (describe below)
-
-## Additional Context
-- 

package/.github/workflows/ci.yml

@@ -1,43 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [master, main]
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 11
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Install Playwright browser
-        run: pnpm exec playwright install --with-deps chromium
-
-      # Serialized to avoid resource contention between the build-heavy
-      # integration tests under parallel runners.
-      - name: Unit & integration tests
-        run: node --test --test-concurrency=1
-
-      - name: Browser E2E tests
-        run: pnpm exec playwright test
-
-      - uses: actions/upload-artifact@v4
-        if: ${{ !cancelled() }}
-        with:
-          name: playwright-report
-          path: playwright-report/
-          retention-days: 7

package/AGENTS.md

@@ -1,247 +0,0 @@
-# Slice.js CLI — Agent Context
-
-## Project Structure
-
-```
-slicejs-cli/
-├── client.js                          # CLI entry point (commander)
-├── commands/
-│   ├── init/init.js                   # slice init
-│   ├── startServer/startServer.js     # slice dev / slice start
-│   ├── build/build.js                 # slice build
-│   ├── getComponent/getComponent.js   # slice get / browse / sync
-│   ├── createComponent/               # slice component create
-│   ├── listComponents/                # slice component list
-│   ├── deleteComponent/                # slice component delete
-│   ├── doctor/doctor.js               # slice doctor
-│   ├── types/types.js                 # slice types generate
-│   ├── bundle/bundle.js               # bundling logic
-│   ├── utils/
-│   │   ├── PathHelper.js              # Path resolution (critical)
-│   │   ├── bundling/BundleGenerator.js
-│   │   ├── updateManager.js
-│   │   ├── VersionChecker.js
-│   │   └── LocalCliDelegation.js
-│   └── Print.js                       # Wrapper for console.log/error
-├── tests/
-│   ├── helpers/setup.js               # Shared test helper (createTestProject, withTestProject)
-│   ├── fixtures/                      # Minimal fixture files for tests
-│   ├── bundle-generator.test.js
-│   ├── bundle-v2-register-output.test.js
-│   ├── client-launcher-contract.test.js
-│   ├── client-update-flow-contract.test.js
-│   ├── component-registry-parse.test.js
-│   ├── dependency-analyzer.test.js
-│   ├── init-command-contract.test.js
-│   ├── local-cli-delegation.test.js
-│   ├── path-helper.test.js
-│   ├── postinstall-command.test.js
-│   ├── types-generator.test.js
-│   └── update-manager-notifications.test.js
-├── package.json                       # type: "module" — ES modules only
-└── AGENTS.md                          # This file
-```
-
-## Testing System
-
-### Runner
-- Uses Node.js built-in test runner: `node --test`
-- Run: `npm test`
-- Watch mode: `node --test --watch`
-
-### Shared Test Helper (`tests/helpers/setup.js`)
-Three exported functions:
-
-```js
-import { createTestProject, cleanupTestProject, withTestProject } from './helpers/setup.js';
-```
-
-**`createTestProject(options)`** — Creates a temp directory with full Slice.js project scaffold.
-- Copies real framework files from `../slice.js/` (sibling directory in monorepo)
-- Falls back to `tests/fixtures/` minimal scaffold if framework not available
-- Options:
-  - `visualComponents: ['Button']` — creates stub component files + rewrites `components.js` to include only those
-  - `frameworkDir` — custom framework source path
-- Returns the temp directory path
-- Temp dir path: `{os.tmpdir()}/slice-test-{PID}-{N}-{random}/`
-
-**`cleanupTestProject(dir)`** — Removes the temp directory recursively.
-
-**`withTestProject(fn, options)`** — Convenience wrapper that:
-1. Calls `createTestProject(options)`
-2. Saves and sets `process.env.INIT_CWD = dir`
-3. Runs `fn(dir)`
-4. Restores `process.env.INIT_CWD` to original value
-5. Calls `cleanupTestProject(dir)` in `finally`
-
-### Patterns
-
-**For tests that need INIT_CWD pointing to the project:**
-```js
-test('my test', async () => {
-  await withTestProject(async (tmpDir) => {
-    // process.env.INIT_CWD is already set to tmpDir
-    const result = someFunction(import.meta.url);
-    assert.ok(result);
-  });
-});
-```
-
-**For tests that pass projectRoot explicitly:**
-```js
-test('my test', async () => {
-  const tmpRoot = await createTestProject({ visualComponents: ['Button'] });
-  try {
-    const result = await someFunction({ projectRoot: tmpRoot });
-    assert.equal(result, 1);
-  } finally {
-    await cleanupTestProject(tmpRoot);
-  }
-});
-```
-
-**For tests with shared project setup across a describe block:**
-```js
-let tmpRoot;
-before(async () => {
-  tmpRoot = await createTestProject();
-  process.env.INIT_CWD = tmpRoot;
-});
-after(async () => {
-  delete process.env.INIT_CWD;
-  await cleanupTestProject(tmpRoot);
-});
-```
-
-### Test types
-
-1. **Contract tests** (`*-contract.test.js`) — Static analysis of `client.js` source code via `@babel/parser` + AST or regex. Verify command registration, option flags, and function calls. No runtime execution.
-2. **Unit tests** — Test individual functions/modules in isolation. Use temp dirs for filesystem-dependent code.
-3. **Snapshot/Integration tests** — Verify output files, generated declarations, bundle configs.
-
-### Rules
-- No external mocking libraries (sinon, jest, etc.). Use monkey-patching + try/finally restore.
-- All temp dirs MUST be cleaned up in `finally` blocks.
-- `process.env.INIT_CWD` must be saved before modification and restored in `finally`.
-- Dynamic `import()` is used where module caching matters, but PathHelper reads env vars at call time so cached modules work correctly.
-
-## PathHelper Rules (`commands/utils/PathHelper.js`)
-
-### Project Root Resolution
-`getProjectRoot(moduleUrl)` resolves in this order:
-1. `process.env.INIT_CWD` — set by npm or by `withTestProject` during tests
-2. `process.cwd()` — current working directory
-3. `candidates(moduleUrl)` — heuristic: walk up `../../` and `../../../../` from module location, check for `src/` or `api/`
-
-### Functions
-
-| Function | Returns | Notes |
-|---|---|---|
-| `getProjectRoot(moduleUrl)` | Resolved project root path | |
-| `getSrcPath(moduleUrl, ...seg)` | `<root>/src/[...seg]` | |
-| `getApiPath(moduleUrl, ...seg)` | `<root>/api/[...seg]` | |
-| `getDistPath(moduleUrl, ...seg)` | `<root>/dist/[...seg]` | |
-| `getPath(moduleUrl, ...seg)` | `<root>/[...seg]` | General purpose |
-| `getConfigPath(moduleUrl, root?)` | `src/sliceConfig.json` | Optional explicit root param |
-| `getComponentsJsPath(moduleUrl, root?)` | `src/Components/components.js` | Optional explicit root param |
-| `joinRoot(root, ...seg)` | `<root>/[...seg]` | No moduleUrl needed, pure path join |
-
-### Critical Rules
-
-1. **`import.meta.url` must be passed** as first argument to all PathHelper functions (except `joinRoot`).
-2. **Explicit root parameter** (`getConfigPath`, `getComponentsJsPath`) is used by `types/types.js` when generating types for a non-cwd project. This keeps functions testable without global state.
-3. **`INIT_CWD` is the primary mechanism** for project root resolution. It's set by npm lifecycle scripts and by `withTestProject`.
-4. **`candidates()` fallback** only works when the CLI is installed inside a project that has `src/` or `api/`. This is intentionally limited.
-
-## Code Quality Standards
-
-### ES Modules Only
-- `"type": "module"` in `package.json`
-- Use `import`/`export` everywhere
-- NO `require()`, NO `__dirname` at module scope (use `path.dirname(fileURLToPath(import.meta.url))` inline where needed)
-
-### No eval()
-- `eval()` has been fully replaced with `JSON.parse()` for reading `components.js` files
-- Components are written via `JSON.stringify()`, so content is always valid JSON
-- Use `JSON.parse()` or the AST-based `ComponentRegistry` for component registry parsing
-
-### Error Messages
-- Bare error messages (just the error message without context) must NOT be used
-- Always wrap errors with context: `Print.error('Context:', error.message)`
-- Use `Print.error()` / `Print.success()` / `Print.info()` / `Print.warning()` instead of raw `console.log`/`console.error`
-- EXCEPTION: Formatted help/command listing output can use `console.log` directly (avoids `ℹ️ Info:` prefix pollution)
-
-### Empty Catch Blocks
-- Silent catches are acceptable ONLY for:
-  - Non-critical operations (update checks, optional config reads)
-  - Graceful degradation paths
-- All silent catches MUST have a comment explaining why: `catch { /* intentional: non-critical */ }`
-
-### Port Resolution (startServer)
-Priority order:
-1. `--port` CLI flag (if provided by user)
-2. `config.server.port` from `sliceConfig.json`
-3. Hardcoded `3000` fallback
-
-Commander `.option()` defaults must NOT override config values. Pass `undefined` when flag is not provided:
-```js
-port: options.port ? parseInt(options.port) : undefined
-```
-
-### Dependency Injection for Testability
-- Functions that need a project root accept it as a parameter (`projectRoot`, `root`)
-- PathHelper functions that accept an explicit root param enable testing without INIT_CWD gymnastics
-- Avoid reading `process.env.INIT_CWD` or `process.cwd()` directly inside business logic; use PathHelper
-
-## CLI Architecture (client.js)
-
-### Command Registration Pattern
-```js
-sliceClient
-  .command("mycommand")
-  .description("...")
-  .option("-x, --flag <value>", "...")
-  .action(async (options) => {
-    // 1. Handle --yes / non-interactive flags before prompts
-    // 2. Prompt for missing required values
-    // 3. Delegate to command implementation
-    await runWithVersionCheck(async () => {
-      await myCommandImplementation(options);
-    });
-  });
-```
-
-### `runWithVersionCheck(commandFunction)`
-- Wraps every command action
-- Responsibilities:
-  1. Fire-and-forget update notification (`notifyAvailableUpdates().catch(() => {})`)
-  2. Execute the command
-  3. Background version check (`checkForUpdates(false)` after 100ms delay)
-- Does NOT block or prompt the user (pre-flight checks were removed)
-- Errors are caught and logged via `Print.error()`
-
-### Init Command (`slice init`)
-- Default project name: `my-slice-app`
-- `-y`/`--yes [name]` flag skips interactive prompts
-- Creates project directory, `chdir`s into it, sets `INIT_CWD`
-- Calls `initializeProject()` from `commands/init/init.js`
-- Name normalization: trim → lowercase → spaces to hyphens → strip non-alphanumeric → collapse hyphens → trim hyphens
-
-### Local CLI Delegation
-- `maybeDelegateToLocalCli()` runs at module level before command parsing
-- If a local `node_modules/slicejs-cli/` exists, spawns it instead of running the global CLI
-- Controlled by `SLICE_NO_LOCAL_DELEGATION` env var
-
-## Visual Component Registry
-- Components downloaded from GitHub: `https://raw.githubusercontent.com/VKneider/slice.js_visual_library/master/src/Components/{category}/{Name}/{file}`
-- Registry URL: same base + `src/Components/components.js`
-- Starter visual components on init: Button, Link, Loading, MultiRoute, Navbar, NotFound, Route
-- Components are registered by writing to `src/Components/components.js`
-
-### File Download Rules (in `getAvailableComponents`)
-- **Routing/navigation components** (`Route`, `MultiRoute`, `Link`): only `.js` file
-- **Other Visual components** (Button, Loading, Navbar, etc.): `.js`, `.html`, `.css`
-- **Service components** (FetchManager, etc.): only `.js` file
-- File list is determined by hardcoded rules, NOT by checking the remote server
-- If `.js` download fails → component install fails (fatal)
-- If `.html`/`.css` fails → component install succeeds with warning