sitevision-cli 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/utils/tasks.js

@@ -0,0 +1,371 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { useSyncExternalStore } from 'react';
+import { WebpackRunner, hasLocalWebpackConfig } from './webpack-runner.js';
+import { hasSitevisionScripts, runSitevisionScriptsBuild, getDelegatedZipPath, checkSitevisionScriptsCompatibility, } from './sitevision-scripts-runner.js';
+import { copyStaticToBuild, copySrcToBuild, cleanBuild, createBuildZip, zipExists, } from './zip.js';
+import { isBundledApp, getAppType, getFullAppId, getZipPath, getSignedZipPath, localizedText, } from './project-detection.js';
+import { signApp, deployApp, deployProduction, activateApp, } from './sitevision-api.js';
+import { ProcessRunner } from './process-runner.js';
+const MAX_LINES = 2000;
+const emitter = new EventEmitter();
+let tasks = [];
+let nextId = 1;
+function notify() {
+    tasks = [...tasks];
+    emitter.emit('change');
+}
+export function getTasks() {
+    return tasks;
+}
+export function useTasks() {
+    return useSyncExternalStore(callback => {
+        emitter.on('change', callback);
+        return () => emitter.off('change', callback);
+    }, () => tasks);
+}
+export function runningTasks(appRoot) {
+    return tasks.filter(t => t.status === 'running' && (!appRoot || t.appRoot === appRoot));
+}
+export function clearFinished() {
+    tasks = tasks.filter(t => t.status === 'running');
+    notify();
+}
+function createTask(kind, project, label, stop = () => { }) {
+    const task = {
+        id: nextId++,
+        kind,
+        appRoot: project.root,
+        appName: localizedText(project.manifest.name) || project.manifest.id,
+        label,
+        status: 'running',
+        phase: 'starting',
+        startedAt: Date.now(),
+        lines: [],
+        stop,
+    };
+    tasks.push(task);
+    notify();
+    const log = (tag, text, level = 'info') => {
+        for (const line of text.trimEnd().split('\n')) {
+            task.lines.push({ time: Date.now(), tag, level, text: line });
+        }
+        if (task.lines.length > MAX_LINES) {
+            task.lines.splice(0, task.lines.length - MAX_LINES);
+        }
+        notify();
+    };
+    const finish = (status, error) => {
+        if (task.status !== 'running')
+            return;
+        task.status = status;
+        task.error = error;
+        task.endedAt = Date.now();
+        task.phase = status;
+        if (error)
+            log('svc', error, 'error');
+        notify();
+    };
+    return { task, log, finish };
+}
+function setPhase(task, phase) {
+    task.phase = phase;
+    notify();
+}
+const errorText = (error) => error instanceof Error ? error.message : String(error);
+// ---------------------------------------------------------------------------
+// One-shot steps shared by the tasks below.
+// ---------------------------------------------------------------------------
+/** Build the app to dist/<appId>.zip. Returns the zip path or throws. */
+async function buildOnce(project, task, log, mode) {
+    const { root, manifest } = project;
+    cleanBuild(root);
+    if (isBundledApp(manifest) && !hasLocalWebpackConfig(root)) {
+        if (!hasSitevisionScripts(root)) {
+            throw new Error('No webpack.config.js found and @sitevision/sitevision-scripts is not installed. Run npm install.');
+        }
+        const { warning } = checkSitevisionScriptsCompatibility(root);
+        if (warning)
+            log('bld', warning, 'warn');
+        setPhase(task, 'building');
+        log('bld', 'building via sitevision-scripts');
+        const result = await runSitevisionScriptsBuild(root, chunk => log('bld', chunk));
+        if (!result.success)
+            throw new Error(result.error ?? 'Build failed');
+        const zipPath = getDelegatedZipPath(root, manifest.id);
+        if (!zipExists(zipPath)) {
+            throw new Error(`Build reported success but no zip was found at ${zipPath}.`);
+        }
+        return zipPath;
+    }
+    if (isBundledApp(manifest)) {
+        if (!WebpackRunner.isWebpackAvailable(root)) {
+            throw new Error('webpack not found. Run npm install.');
+        }
+        setPhase(task, 'building');
+        log('bld', 'compiling with webpack');
+        const runner = new WebpackRunner(root, {
+            mode,
+            cssPrefix: manifest.id,
+            restApp: getAppType(manifest) !== 'web' && getAppType(manifest) !== 'widget',
+        });
+        const result = await runner.run();
+        await runner.close();
+        reportBuild(result, log);
+        if (!result.success)
+            throw new Error(result.errors?.join('\n') || 'Build failed');
+        copyStaticToBuild(root);
+    }
+    else {
+        setPhase(task, 'copying');
+        log('bld', 'copying source files');
+        copySrcToBuild(root);
+        copyStaticToBuild(root);
+    }
+    setPhase(task, 'zipping');
+    return createBuildZip(root, getFullAppId(manifest.id));
+}
+function reportBuild(result, log) {
+    for (const warning of result.warnings ?? [])
+        log('bld', warning, 'warn');
+    for (const error of result.errors ?? [])
+        log('bld', error, 'error');
+    if (result.success) {
+        log('bld', `compiled in ${result.stats?.time ?? 0}ms${result.stats?.assets?.length ? ` · ${result.stats.assets.join(', ')}` : ''}`, 'ok');
+    }
+}
+async function signOnce(project, task, log, zipPath, credentials) {
+    setPhase(task, 'signing');
+    log('sgn', `signing via developer.sitevision.se${credentials.certificateName ? ` · cert ${credentials.certificateName}` : ''}`);
+    const signedPath = getSignedZipPath(project.root, project.manifest);
+    const result = await signApp(zipPath, credentials, signedPath);
+    if (!result.success)
+        throw new Error(result.error ?? 'Signing failed');
+    log('sgn', `signed ${path.basename(signedPath)}`, 'ok');
+    return signedPath;
+}
+async function deployOnce(project, task, log, zipPath, config, options) {
+    setPhase(task, 'deploying');
+    const appType = getAppType(project.manifest);
+    log('dep', `POST multipart → ${options.production ? 'production' : 'dev'} import · ${config.addonName}`);
+    const result = options.production
+        ? await deployProduction(zipPath, { ...config, activate: options.activate }, appType)
+        : await deployApp(zipPath, config, appType, options.force);
+    if (!result.success)
+        throw new Error(result.error ?? 'Deployment failed');
+    log('dep', `${result.message ?? 'deployed'}${result.executableId ? ` · exec ${result.executableId}` : ''}`, 'ok');
+    return result.executableId;
+}
+// ---------------------------------------------------------------------------
+// Tasks
+// ---------------------------------------------------------------------------
+export function startBuild(project) {
+    const { task, log, finish } = createTask('build', project, 'build');
+    void (async () => {
+        try {
+            const zip = await buildOnce(project, task, log, 'production');
+            log('bld', `created ${zip}`, 'ok');
+            finish('success');
+        }
+        catch (error) {
+            finish('error', errorText(error));
+        }
+    })();
+    return task;
+}
+export function startSign(project, credentials) {
+    const { task, log, finish } = createTask('sign', project, 'sign');
+    void (async () => {
+        try {
+            const zipPath = getZipPath(project.root, project.manifest);
+            if (!zipExists(zipPath)) {
+                throw new Error(`Zip file not found: ${zipPath}. Run build first.`);
+            }
+            await signOnce(project, task, log, zipPath, credentials);
+            finish('success');
+        }
+        catch (error) {
+            finish('error', errorText(error));
+        }
+    })();
+    return task;
+}
+export function startDeploy(project, config, options) {
+    const { task, log, finish } = createTask('deploy', project, options.production ? 'deploy production' : 'deploy');
+    void (async () => {
+        try {
+            const zipPath = options.production
+                ? getSignedZipPath(project.root, project.manifest)
+                : getZipPath(project.root, project.manifest);
+            if (!zipExists(zipPath)) {
+                throw new Error(`${options.production ? 'Signed zip' : 'Zip'} not found: ${zipPath}. Run ${options.production ? 'sign' : 'build'} first.`);
+            }
+            await deployOnce(project, task, log, zipPath, config, options);
+            finish('success');
+        }
+        catch (error) {
+            finish('error', errorText(error));
+        }
+    })();
+    return task;
+}
+export function startActivate(project, config, executableId, versionLabel) {
+    const { task, log, finish } = createTask('activate', project, `activate ${versionLabel}`);
+    void (async () => {
+        try {
+            setPhase(task, 'activating');
+            log('act', `PUT activateCustomModuleExecutable · ${versionLabel}`);
+            const result = await activateApp(executableId, config, getAppType(project.manifest));
+            if (!result.success)
+                throw new Error(result.error ?? 'Activation failed');
+            log('act', `${versionLabel} is now active`, 'ok');
+            finish('success');
+        }
+        catch (error) {
+            finish('error', errorText(error));
+        }
+    })();
+    return task;
+}
+export function startInstall(project) {
+    const runner = new ProcessRunner('npm', ['install'], project.root);
+    const { task, log, finish } = createTask('install', project, 'npm install', () => runner.kill());
+    setPhase(task, 'installing');
+    runner.on('output', (output) => log('npm', output.data, output.type === 'stderr' ? 'warn' : 'info'));
+    runner
+        .run()
+        .then(result => finish(result.exitCode === 0 ? 'success' : 'error', result.exitCode === 0
+        ? undefined
+        : `npm install exited with ${result.exitCode}`))
+        .catch(error => finish('error', errorText(error)));
+    return task;
+}
+const WATCH_TARGETS = [
+    'src',
+    'static',
+    'i18n',
+    'resource',
+    'config',
+    'manifest.json',
+];
+/**
+ * Dev / watch loop: build on every source change, then optionally sign and
+ * deploy. Runs until `task.stop()`; the task stays in the registry meanwhile.
+ */
+export function startDev(project, options) {
+    const { root, manifest } = project;
+    const watchers = [];
+    let webpack = null;
+    let debounce;
+    let building = false;
+    let pending = false;
+    const stop = () => {
+        clearTimeout(debounce);
+        for (const watcher of watchers)
+            watcher.close();
+        void webpack?.close().catch(() => { });
+        finish('stopped');
+    };
+    const { task, log, finish } = createTask(options.deploy ? 'dev' : 'watch', project, options.deploy ? 'dev' : 'watch', stop);
+    const afterBuild = async (zipPath) => {
+        let deployZip = zipPath;
+        if (options.signingCredentials) {
+            deployZip = await signOnce(project, task, log, zipPath, options.signingCredentials);
+        }
+        if (options.deploy && options.deployConfig) {
+            await deployOnce(project, task, log, deployZip, options.deployConfig, {
+                force: true,
+            });
+        }
+        setPhase(task, 'watching');
+        log('svc', 'watching for changes');
+    };
+    const fail = (error) => {
+        log('svc', errorText(error), 'error');
+        setPhase(task, 'error');
+    };
+    const rebuild = async () => {
+        if (building) {
+            pending = true;
+            return;
+        }
+        building = true;
+        try {
+            do {
+                pending = false;
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    await afterBuild(await buildOnce(project, task, log, 'development'));
+                }
+                catch (error) {
+                    fail(error);
+                }
+            } while (pending);
+        }
+        finally {
+            building = false;
+        }
+    };
+    const onChange = (name, file) => {
+        log('fs', `changed ${file ?? name}`);
+        clearTimeout(debounce);
+        debounce = setTimeout(() => {
+            void rebuild();
+        }, 300);
+    };
+    const watchFiles = () => {
+        for (const name of WATCH_TARGETS) {
+            const target = path.join(root, name);
+            if (!fs.existsSync(target))
+                continue;
+            const isDir = fs.statSync(target).isDirectory();
+            watchers.push(fs.watch(target, { recursive: isDir }, (_event, file) => {
+                onChange(name, file);
+            }));
+        }
+        log('svc', `watching ${WATCH_TARGETS.join(', ')}`);
+    };
+    void (async () => {
+        try {
+            cleanBuild(root);
+            if (isBundledApp(manifest) && hasLocalWebpackConfig(root)) {
+                // Project ships its own webpack config: incremental in-process watch.
+                if (!WebpackRunner.isWebpackAvailable(root)) {
+                    throw new Error('webpack not found. Run npm install.');
+                }
+                setPhase(task, 'building');
+                webpack = new WebpackRunner(root, {
+                    mode: 'development',
+                    watch: true,
+                    cssPrefix: manifest.id,
+                    restApp: getAppType(manifest) !== 'web' && getAppType(manifest) !== 'widget',
+                });
+                await webpack.watch(result => {
+                    void (async () => {
+                        reportBuild(result, log);
+                        if (!result.success) {
+                            setPhase(task, 'error');
+                            return;
+                        }
+                        try {
+                            copyStaticToBuild(root);
+                            await afterBuild(await createBuildZip(root, getFullAppId(manifest.id)));
+                        }
+                        catch (error) {
+                            fail(error);
+                        }
+                    })();
+                });
+            }
+            else {
+                watchFiles();
+                await rebuild();
+            }
+        }
+        catch (error) {
+            finish('error', errorText(error));
+        }
+    })();
+    return task;
+}

package/dist/utils/workspace.d.ts

@@ -0,0 +1,8 @@
+import { type ProjectInfo } from './project-detection.js';
+/**
+ * Find every Sitevision app below `root` (e.g. root/webapps/x, root/restapps/y).
+ * Depth-limited walk that skips dependency and output folders.
+ */
+export declare function discoverApps(root: string): ProjectInfo[];
+/** Group label for an app: its parent folder relative to the workspace root. */
+export declare function appGroup(root: string, appRoot: string): string;

package/dist/utils/workspace.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { detectProject } from './project-detection.js';
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build']);
+const MAX_DEPTH = 3;
+/**
+ * Find every Sitevision app below `root` (e.g. root/webapps/x, root/restapps/y).
+ * Depth-limited walk that skips dependency and output folders.
+ */
+export function discoverApps(root) {
+    const found = [];
+    const walk = (dir, depth) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || SKIP_DIRS.has(entry.name))
+                continue;
+            if (entry.name.startsWith('.'))
+                continue;
+            const full = path.join(dir, entry.name);
+            let project = null;
+            try {
+                project = detectProject(full);
+            }
+            catch {
+                // Unparseable manifest: skip it; the app can still be opened directly.
+            }
+            if (project) {
+                found.push(project);
+            }
+            else if (depth < MAX_DEPTH) {
+                walk(full, depth + 1);
+            }
+        }
+    };
+    walk(root, 1);
+    return found.toSorted((a, b) => a.root.localeCompare(b.root));
+}
+/** Group label for an app: its parent folder relative to the workspace root. */
+export function appGroup(root, appRoot) {
+    const relative = path.relative(root, path.dirname(appRoot));
+    return relative === '' ? '.' : relative;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sitevision-cli",
-	"version": "1.0.0-beta.13",
+	"version": "1.0.0-beta.14",
 	"license": "MIT",
 	"bin": {
 		"svc": "dist/cli.js"

package/readme.md

@@ -25,33 +25,85 @@ npm install --global sitevision-cli
 
 The CLI must be run inside a Sitevision project directory (containing a `manifest.json`).
 
-### Interactive Mode
+### Interactive shell
+
+Run `svc` with no arguments to open the full-screen shell. It works in two
+places:
+
+- **Inside an app** (a directory with `manifest.json`): single-app mode.
+- **At the root of a repo** that contains apps in subfolders such as
+  `webapps/*`, `restapps/*` or `widgets/*`: workspace mode, with every app in
+  the left navigator and per-app status dots (dependencies, config,
+  package.json sync, signing).
+
+The right pane has four tabs: **Overview**, **Config** (the whole
+`.dev_properties.json` as one form, plus signing and keychain secrets; `Tab`
+moves between fields, `Enter` saves, `Ctrl+O` on the addon field picks an
+addon from the site's Addon Repository), **Versions** (the versions uploaded
+to the site, `a` activates one) and **Log** (streaming build and deploy
+output). Dev and watch keep running in the background while you navigate
+between apps.
+
+Single-letter keys drive everything; the bottom bar shows the ones that apply.
+`/` opens the command palette with every action, `Tab` switches between the
+navigator and the content pane, `1`–`4` pick a tab, `q` quits.
+
+| Key             | Action                                                            |
+| --------------- | ----------------------------------------------------------------- |
+| `d` / `w`       | Dev (build, sign, deploy on change) / Watch (build and sign only) |
+| `b` / `s`       | Build / Sign                                                      |
+| `p` / `P`       | Deploy to dev / force deploy                                      |
+| `a`             | Versions tab: list and activate remote versions                   |
+| `e` / `y` / `l` | Edit dev properties / apply package.json sync / log in            |
+| `K`             | Stop the running task for the selected app                        |
+
+### Settings
+
+`,` (or "Settings" in the palette) opens the global preferences, stored in
+`~/.config/sitevision-cli/config.json`: the UI language (English or Swedish,
+which also picks the manifest name language) and whether the intro animation
+plays. In workspace mode the same screen has a row that jumps to the shared
+workspace config.
+
+### Environments
+
+The top-level fields of `.dev_properties.json` are one environment, called
+**dev** unless `baseEnvironment` says otherwise (a repo that only has a
+production site can set `"baseEnvironment": "prod"`). Add more under
+`environments`, overriding only what differs:
 
-Simply run `svc` to launch the interactive menu:
-
-```bash
-svc
+```json
+{
+	"domain": "acme-use.sitevision-cloud.se",
+	"siteName": "Intranet",
+	"username": "me@acme.se",
+	"environments": {
+		"test": {"domain": "acme-tse.sitevision-cloud.se"},
+		"prod": {"domain": "acme.sitevision-cloud.se", "authMethod": "oauth2"}
+	}
+}
 ```
 
-On first run (or if setup is incomplete), the CLI will:
-
-1. Check if `node_modules` exists and offer to run `npm install` if missing
-2. Check if dev properties are configured and offer to set them up if missing
-3. Check if you have setup signing credentials and offer to do so if missing
-4. Display project information
-5. Show the main menu
-
-Use arrow keys to navigate and Enter to select:
-
-- **Dev** - Start development server with watch mode
-- **Dev (Signed)** - Development with automatic signing before each deploy
-- **Build** - Build a dist bundle
-- **Sign** - Sign built dist bundle
-- **Deploy** - Deploy to configured development environment
-- **Deploy (Force)** - Force deploy (overwrite existing)
-- **Deploy Production** - Deploy signed app to configured production environment
-- **Info** - Show project info
-- **Exit**
+`E` cycles the active environment (also "Switch environment" and "Add
+environment" in the palette); the choice is remembered in `.svcconfig`. The
+top bar shows a badge, green for dev, yellow for others, red for production.
+Versions, deploy, login state and the Config tab all follow the active
+environment; on a non-dev environment the Config tab edits that environment's
+overrides. Override names containing `prod`, or any environment with `"production":
+true`, are production: deploy needs the signed zip, confirms, and activates,
+and dev or watch refuse to run against them. The base environment is never
+production by name, only by the flag, so a prod-only repo keeps its dev loop.
+Both settings have rows in the Config tab under ENVIRONMENT.
+
+### Shared configuration in a workspace
+
+`.dev_properties.json` is resolved by merging every ancestor directory's file
+(up to the repo root) under the app's own file, nearest wins. Put the shared
+fields (`domain`, `siteName`, `username`, `authMethod`, `oauth2`,
+`signingUsername`, ...) once at the repo root and keep only `addonName` in each
+app. The Config tab marks inherited values with `↑ root`, and saving an app's
+config never copies inherited values into the app file. Keychain entries are
+keyed by domain and username, so one login covers every app on the site.
 
 ### Direct Commands