sitevision-cli 1.0.0-beta.2 → 1.0.0-beta.21

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,17 @@
+import { type ProjectInfo } from './project-detection.js';
+import type { DevProperties } from '../types/index.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;
+/** Missing something nothing can deploy without. */
+export declare function configIncomplete(dev?: Partial<DevProperties>): boolean;
+/**
+ * True when a workspace has apps but nothing usable to deploy with: neither the
+ * shared root config nor the apps themselves carry domain/site/username. The
+ * shell then opens on Workspace settings instead of the first app.
+ */
+export declare function needsOnboarding(root: string, apps: ProjectInfo[]): boolean;

package/dist/utils/workspace.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { detectProject, readWorkspaceDevProperties, } 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);
+    // Group first, then path: a deeper folder (webapps/nested) must not split
+    // its parent's run of apps, or the same group heading renders twice.
+    return found.toSorted((a, b) => path.dirname(a.root).localeCompare(path.dirname(b.root)) ||
+        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;
+}
+/** Missing something nothing can deploy without. */
+export function configIncomplete(dev) {
+    if (!dev?.domain || !dev.siteName)
+        return true;
+    return (dev.authMethod ?? 'basic') === 'basic' && !dev.username;
+}
+/**
+ * True when a workspace has apps but nothing usable to deploy with: neither the
+ * shared root config nor the apps themselves carry domain/site/username. The
+ * shell then opens on Workspace settings instead of the first app.
+ */
+export function needsOnboarding(root, apps) {
+    return (apps.length > 0 &&
+        configIncomplete(readWorkspaceDevProperties(root)) &&
+        apps.some(app => configIncomplete(app.devProperties)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sitevision-cli",
-	"version": "1.0.0-beta.2",
+	"version": "1.0.0-beta.21",
 	"license": "MIT",
 	"bin": {
 		"svc": "dist/cli.js"
@@ -24,6 +24,8 @@
 		"ink": "^7.1.0",
 		"ink-spinner": "^5.0.0",
 		"meow": "^14.1.0",
+		"open": "^11.0.3",
+		"puppeteer-core": "^25.10.0",
 		"react": "^19.2.7"
 	},
 	"devDependencies": {