sitevision-cli 0.0.0

package/dist/app.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type ProjectInfo } from './utils/project-detection.js';
+type Props = {
+    project: ProjectInfo;
+};
+export default function App({ project }: Props): React.JSX.Element | null;
+export {};

package/dist/app.js

@@ -0,0 +1,180 @@
+import React, { useState } from 'react';
+import { MainMenu } from './components/MainMenu.js';
+import { InfoScreen } from './components/InfoScreen.js';
+import { SetupFlow } from './components/SetupFlow.js';
+import { PasswordInput } from './components/PasswordInput.js';
+import { DevScreen } from './commands/dev.js';
+import { BuildScreen } from './commands/build.js';
+import { DeployScreen } from './commands/deploy.js';
+import { SignScreen } from './commands/sign.js';
+import { SigningPropertiesForm } from './components/SigningPropertiesForm.js';
+export default function App({ project }) {
+    const [state, setState] = useState('setup');
+    const [currentCommand, setCurrentCommand] = useState('');
+    const [signingPassword, setSigningPassword] = useState('');
+    const [devPassword, setDevPassword] = useState('');
+    // Check if dev password is available (either from file or session)
+    const hasDevPassword = Boolean(project.devProperties?.password || devPassword);
+    // Get effective dev properties with session password if needed
+    const getEffectiveDevProperties = () => {
+        if (!project.devProperties)
+            return undefined;
+        if (project.devProperties.password)
+            return project.devProperties;
+        return { ...project.devProperties, password: devPassword };
+    };
+    const handleDevPasswordSubmit = (password) => {
+        setDevPassword(password);
+        // Continue to the intended command
+        if (currentCommand === 'dev' || currentCommand === 'dev-signed') {
+            if (currentCommand === 'dev-signed' && !signingPassword) {
+                setState('signing-password-input');
+            }
+            else {
+                setState('dev');
+            }
+        }
+        else if (currentCommand.startsWith('deploy')) {
+            setState('deploy');
+        }
+    };
+    const handleSigningPasswordSubmit = (password) => {
+        setSigningPassword(password);
+        if (currentCommand === 'dev-signed') {
+            setState('dev');
+        }
+        else {
+            setState('sign');
+        }
+    };
+    const handleCommandSelect = (command) => {
+        setCurrentCommand(command);
+        switch (command) {
+            case 'info':
+                setState('info');
+                break;
+            case 'setup-signing':
+                setState('setup-signing');
+                break;
+            case 'dev':
+                if (!project.hasDevProperties || !project.devProperties) {
+                    console.log('\x1b[31mDevelopment properties not configured. Create a .dev_properties.json file first.\x1b[0m');
+                    return;
+                }
+                if (!hasDevPassword) {
+                    setState('dev-password-input');
+                }
+                else {
+                    setState('dev');
+                }
+                break;
+            case 'dev-signed':
+                if (!project.hasDevProperties || !project.devProperties) {
+                    console.log('\x1b[31mDevelopment properties not configured. Create a .dev_properties.json file first.\x1b[0m');
+                    return;
+                }
+                if (!project.hasSigningProperties) {
+                    console.log('\x1b[31mSigning credentials not configured. Run svc setup-signing first.\x1b[0m');
+                    return;
+                }
+                // Need both dev password and signing password
+                if (!hasDevPassword) {
+                    setState('dev-password-input');
+                }
+                else if (!signingPassword) {
+                    setState('signing-password-input');
+                }
+                else {
+                    setState('dev');
+                }
+                break;
+            case 'sign':
+                if (!project.hasDevProperties || !project.devProperties) {
+                    console.log('\x1b[31mDevelopment properties not configured. Create a .dev_properties.json file first.\x1b[0m');
+                    return;
+                }
+                if (!project.hasSigningProperties) {
+                    console.log('\x1b[31mSigning credentials not configured. Run svc setup-signing first.\x1b[0m');
+                    return;
+                }
+                if (signingPassword) {
+                    setState('sign');
+                }
+                else {
+                    setState('signing-password-input');
+                }
+                break;
+            case 'build':
+                setState('build');
+                break;
+            case 'deploy':
+            case 'deploy-force':
+            case 'deploy-production':
+                if (!project.hasDevProperties || !project.devProperties) {
+                    console.log('\x1b[31mDevelopment properties not configured. Create a .dev_properties.json file first.\x1b[0m');
+                    return;
+                }
+                if (!hasDevPassword) {
+                    setState('dev-password-input');
+                }
+                else {
+                    setState('deploy');
+                }
+                break;
+        }
+    };
+    if (state === 'setup') {
+        return React.createElement(SetupFlow, { project: project, onComplete: () => setState('menu') });
+    }
+    if (state === 'menu') {
+        return React.createElement(MainMenu, { project: project, onSelect: handleCommandSelect });
+    }
+    if (state === 'info') {
+        return React.createElement(InfoScreen, { project: project, onBack: () => setState('menu') });
+    }
+    if (state === 'dev-password-input') {
+        return (React.createElement(PasswordInput, { key: "dev-password", label: "Enter Development Password (usually Sitevision Cloud Password)", onSubmit: handleDevPasswordSubmit, onCancel: () => setState('menu') }));
+    }
+    if (state === 'signing-password-input') {
+        return (React.createElement(PasswordInput, { key: "signing-password", label: "Enter Signing Password (developer.sitevision.se)", onSubmit: handleSigningPasswordSubmit, onCancel: () => setState('menu') }));
+    }
+    if (state === 'dev') {
+        return (React.createElement(DevScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: getEffectiveDevProperties(), signed: currentCommand === 'dev-signed', onBack: () => setState('menu'), onRetryCredentials: () => {
+                setDevPassword('');
+                if (currentCommand === 'dev-signed') {
+                    setSigningPassword('');
+                }
+                setState('dev-password-input');
+            }, signingCredentials: currentCommand === 'dev-signed' && project.devProperties?.signingUsername
+                ? {
+                    username: project.devProperties.signingUsername,
+                    password: signingPassword,
+                    certificateName: project.devProperties.certificateName,
+                }
+                : undefined }));
+    }
+    if (state === 'build') {
+        return (React.createElement(BuildScreen, { projectRoot: project.root, manifest: project.manifest, createZip: true, onBack: () => setState('menu') }));
+    }
+    if (state === 'sign') {
+        return (React.createElement(SignScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: project.devProperties, password: signingPassword, onBack: () => setState('menu'), onRetryCredentials: () => {
+                setSigningPassword('');
+                setState('signing-password-input');
+            } }));
+    }
+    if (state === 'deploy') {
+        return (React.createElement(DeployScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: getEffectiveDevProperties(), force: currentCommand === 'deploy-force', production: currentCommand === 'deploy-production', activate: currentCommand === 'deploy-production', onBack: () => setState('menu'), onRetryCredentials: () => {
+                setDevPassword('');
+                setState('dev-password-input');
+            } }));
+    }
+    if (state === 'setup-signing') {
+        return (React.createElement(SigningPropertiesForm, { projectRoot: project.root, onComplete: () => {
+                // We can't easily update project info here without full reload,
+                // but since we are just returning to menu, it's fine.
+                // The user might need to restart CLI or we implement a reload mechanism.
+                setState('menu');
+            }, onCancel: () => setState('menu') }));
+    }
+    return null;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import { Text, Box } from 'ink';
+import meow from 'meow';
+import App from './app.js';
+import { getCommand } from './commands/index.js';
+import { requireProject } from './utils/project-detection.js';
+const cli = meow(`
+	Usage
+	  $ svc                    Start interactive menu
+	  $ svc <command> [options]
+
+	Commands
+	  dev           Start development server with watch mode
+	  build         Build the application for production
+	  deploy        Deploy the application
+	  info          Show project information
+
+	Options
+	  --help        Show this help message
+	  --version     Show version number
+
+	Examples
+	  $ svc                     # Interactive menu
+	  $ svc dev
+	  $ svc dev --signed
+	  $ svc build
+	  $ svc deploy --force
+	  $ svc deploy --production
+	  $ svc info
+`, {
+    importMeta: import.meta,
+    flags: {
+        signed: {
+            type: 'boolean',
+            default: false,
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            default: false,
+        },
+        production: {
+            type: 'boolean',
+            alias: 'p',
+            default: false,
+        },
+    },
+});
+const [commandName, ...args] = cli.input;
+async function main() {
+    // Check if we're in a Sitevision project
+    const project = (() => {
+        try {
+            return requireProject();
+        }
+        catch (error) {
+            render(React.createElement(Box, { flexDirection: "column", padding: 1 },
+                React.createElement(Text, { color: "red" },
+                    "Error: ",
+                    error.message),
+                React.createElement(Text, { dimColor: true }, "Make sure you're in a Sitevision project directory")));
+            process.exit(1);
+        }
+    })();
+    // If no command, show interactive menu
+    if (!commandName) {
+        render(React.createElement(App, { project: project }));
+        return;
+    }
+    // Get the command
+    const command = getCommand(commandName);
+    if (!command) {
+        render(React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "red" },
+                "Unknown command: ",
+                commandName),
+            React.createElement(Text, null,
+                "Run ",
+                React.createElement(Text, { bold: true }, "svc --help"),
+                " to see available commands")));
+        process.exit(1);
+    }
+    // Execute the command
+    await command.execute({
+        project,
+        flags: cli.flags,
+        args,
+    });
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/commands/build.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type Command } from './types.js';
+import type { SitevisionManifest } from '../types/index.js';
+interface BuildScreenProps {
+    projectRoot: string;
+    manifest: SitevisionManifest;
+    createZip?: boolean;
+    onBack?: () => void;
+}
+export declare function BuildScreen({ projectRoot, manifest, createZip, onBack }: BuildScreenProps): React.JSX.Element;
+export declare const buildCommand: Command;
+export {};

package/dist/commands/build.js

@@ -0,0 +1,168 @@
+import React from 'react';
+import { render, Box, Text, useInput } from 'ink';
+import { StatusIndicator } from '../components/StatusIndicator.js';
+import { WebpackRunner } from '../utils/webpack-runner.js';
+import { copyStaticToBuild, copySrcToBuild, cleanBuild, formatFileSize, createBuildZip, getZipSize, } from '../utils/zip.js';
+import { isBundledApp, getAppType, getFullAppId, } from '../utils/project-detection.js';
+export function BuildScreen({ projectRoot, manifest, createZip = true, onBack }) {
+    const [state, setState] = React.useState({
+        status: 'cleaning',
+        message: 'Cleaning build directory...',
+    });
+    useInput((input, key) => {
+        if (onBack && (key.escape || input === 'q') && (state.status === 'success' || state.status === 'error')) {
+            onBack();
+        }
+    });
+    const isBundled = isBundledApp(manifest);
+    React.useEffect(() => {
+        async function runBuild() {
+            try {
+                // Step 1: Clean build directory
+                setState({ status: 'cleaning', message: 'Cleaning build directory...' });
+                cleanBuild(projectRoot);
+                // Step 2: Build or copy files
+                if (isBundled) {
+                    // Check if webpack is available
+                    if (!WebpackRunner.isWebpackAvailable(projectRoot)) {
+                        setState({
+                            status: 'error',
+                            error: 'webpack not found. Run npm install to install dependencies.',
+                        });
+                        return;
+                    }
+                    setState({ status: 'building', message: 'Compiling with webpack...' });
+                    const appType = getAppType(manifest);
+                    const runner = new WebpackRunner(projectRoot, {
+                        mode: 'production',
+                        cssPrefix: manifest.id,
+                        restApp: appType === 'rest',
+                    });
+                    const result = await runner.run();
+                    await runner.close();
+                    if (!result.success) {
+                        setState({
+                            status: 'error',
+                            error: result.errors?.join('\n') || 'Build failed',
+                            result,
+                        });
+                        return;
+                    }
+                    // Copy static files after webpack build
+                    setState({ status: 'copying', message: 'Copying static files...' });
+                    copyStaticToBuild(projectRoot);
+                    setState(prev => ({ ...prev, result }));
+                }
+                else {
+                    // Non-bundled app: just copy files
+                    setState({ status: 'copying', message: 'Copying source files...' });
+                    copySrcToBuild(projectRoot);
+                    copyStaticToBuild(projectRoot);
+                }
+                // Step 3: Create zip if requested
+                if (createZip) {
+                    setState({ status: 'zipping', message: 'Creating zip archive...' });
+                    const appId = getFullAppId(manifest.id);
+                    const zipPath = await createBuildZip(projectRoot, appId);
+                    const zipSize = getZipSize(zipPath);
+                    setState(prev => ({
+                        ...prev,
+                        status: 'success',
+                        message: 'Build complete',
+                        zipPath,
+                        zipSize,
+                    }));
+                }
+                else {
+                    setState(prev => ({
+                        ...prev,
+                        status: 'success',
+                        message: 'Build complete',
+                    }));
+                }
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        runBuild();
+    }, [projectRoot, manifest, isBundled, createZip]);
+    const getStatusIndicator = () => {
+        switch (state.status) {
+            case 'cleaning':
+            case 'building':
+            case 'copying':
+            case 'zipping':
+                return 'running';
+            case 'success':
+                return 'success';
+            case 'error':
+                return 'error';
+        }
+    };
+    const getStatusLabel = () => {
+        switch (state.status) {
+            case 'cleaning':
+                return 'Cleaning';
+            case 'building':
+                return 'Building';
+            case 'copying':
+                return 'Copying files';
+            case 'zipping':
+                return 'Creating zip';
+            case 'success':
+                return 'Build complete';
+            case 'error':
+                return 'Build failed';
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(StatusIndicator, { status: getStatusIndicator(), label: getStatusLabel(), message: state.message })),
+        state.status === 'success' && state.result?.stats && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            React.createElement(Text, { dimColor: true },
+                "Compiled in ",
+                state.result.stats.time,
+                "ms"),
+            state.result.stats.assets && state.result.stats.assets.length > 0 && (React.createElement(Text, { dimColor: true },
+                "Assets: ",
+                state.result.stats.assets.join(', '))))),
+        state.status === 'success' && state.zipPath && (React.createElement(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1 },
+            React.createElement(Text, { color: "green" },
+                "\u2713 Created: ",
+                state.zipPath),
+            state.zipSize !== undefined && (React.createElement(Text, { dimColor: true },
+                "  Size: ",
+                formatFileSize(state.zipSize))))),
+        state.result?.warnings && state.result.warnings.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "Warnings:"),
+            state.result.warnings.slice(0, 5).map((warning, i) => (React.createElement(Text, { key: i, color: "yellow", dimColor: true }, warning.substring(0, 200)))),
+            state.result.warnings.length > 5 && (React.createElement(Text, { color: "yellow", dimColor: true },
+                "...and ",
+                state.result.warnings.length - 5,
+                " more")))),
+        state.status === 'error' && state.error && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "red" }, state.error))),
+        onBack && (state.status === 'success' || state.status === 'error') && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press q or Esc to return to menu")))));
+}
+export const buildCommand = {
+    name: 'build',
+    description: 'Build the application for production',
+    requiresProject: true,
+    flags: {
+        'no-zip': {
+            type: 'boolean',
+            description: 'Skip creating the zip archive',
+            default: false,
+        },
+    },
+    async execute({ project, flags }) {
+        const createZip = !flags['no-zip'];
+        const { waitUntilExit } = render(React.createElement(BuildScreen, { projectRoot: project.root, manifest: project.manifest, createZip: createZip }));
+        await waitUntilExit();
+    },
+};

package/dist/commands/deploy.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { type Command } from './types.js';
+import type { SitevisionManifest, DevProperties } from '../types/index.js';
+interface DeployScreenProps {
+    projectRoot: string;
+    manifest: SitevisionManifest;
+    devProperties: DevProperties;
+    force: boolean;
+    production: boolean;
+    activate: boolean;
+    signingPassword?: string;
+    onBack?: () => void;
+    onRetryCredentials?: () => void;
+}
+export declare function DeployScreen({ projectRoot, manifest, devProperties, force, production, activate, signingPassword, onBack, onRetryCredentials, }: DeployScreenProps): React.JSX.Element;
+export declare const deployCommand: Command;
+export {};

package/dist/commands/deploy.js

@@ -0,0 +1,162 @@
+import React from 'react';
+import { render, Box, Text, useInput } from 'ink';
+import { StatusIndicator } from '../components/StatusIndicator.js';
+import { deployApp, deployProduction } from '../utils/sitevision-api.js';
+import { getZipPath, getSignedZipPath, getAppType, } from '../utils/project-detection.js';
+import { zipExists } from '../utils/zip.js';
+export function DeployScreen({ projectRoot, manifest, devProperties, force, production, activate, signingPassword, onBack, onRetryCredentials, }) {
+    const [state, setState] = React.useState({
+        status: 'deploying',
+        message: production ? 'Deploying to production...' : 'Deploying to dev...',
+    });
+    useInput((input, key) => {
+        if (state.status !== 'deploying') {
+            if (onBack && (key.escape || input === 'q')) {
+                onBack();
+            }
+            if (onRetryCredentials && state.status === 'error' && input === 'r') {
+                onRetryCredentials();
+            }
+        }
+    });
+    React.useEffect(() => {
+        async function runDeploy() {
+            try {
+                const appType = getAppType(manifest);
+                if (production) {
+                    // Production deployment requires a signed zip
+                    const signedZipPath = getSignedZipPath(projectRoot, manifest);
+                    if (!zipExists(signedZipPath)) {
+                        setState({
+                            status: 'error',
+                            error: `Signed zip not found: ${signedZipPath}\nRun 'sign' first to create the signed zip.`,
+                        });
+                        return;
+                    }
+                    const config = {
+                        domain: devProperties.domain,
+                        siteName: devProperties.siteName,
+                        addonName: devProperties.addonName,
+                        username: devProperties.username,
+                        password: devProperties.password,
+                        useHTTP: devProperties.useHTTPForDevDeploy,
+                        activate,
+                    };
+                    const result = await deployProduction(signedZipPath, config, appType);
+                    if (!result.success) {
+                        setState({
+                            status: 'error',
+                            error: result.error || 'Deployment failed',
+                        });
+                        return;
+                    }
+                    setState({
+                        status: 'success',
+                        message: result.message || 'Deployed to production successfully',
+                        executableId: result.executableId,
+                    });
+                }
+                else {
+                    // Dev deployment can use unsigned zip
+                    const zipPath = getZipPath(projectRoot, manifest);
+                    if (!zipExists(zipPath)) {
+                        setState({
+                            status: 'error',
+                            error: `Zip not found: ${zipPath}\nRun 'build' first to create the zip.`,
+                        });
+                        return;
+                    }
+                    const config = {
+                        domain: devProperties.domain,
+                        siteName: devProperties.siteName,
+                        addonName: devProperties.addonName,
+                        username: devProperties.username,
+                        password: devProperties.password,
+                        useHTTP: devProperties.useHTTPForDevDeploy,
+                    };
+                    const result = await deployApp(zipPath, config, appType, force);
+                    if (!result.success) {
+                        setState({
+                            status: 'error',
+                            error: result.error || 'Deployment failed',
+                        });
+                        return;
+                    }
+                    setState({
+                        status: 'success',
+                        message: 'Deployed to dev successfully',
+                        executableId: result.executableId,
+                    });
+                }
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        runDeploy();
+    }, [projectRoot, manifest, devProperties, force, production, activate, signingPassword]);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(StatusIndicator, { status: state.status === 'deploying' ? 'running' : state.status, label: state.status === 'deploying' ? 'Deploying' : state.status === 'success' ? 'Deployed' : 'Failed', message: state.message })),
+        state.status === 'success' && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            React.createElement(Text, { color: "green" },
+                production ? 'Production deployment' : 'Dev deployment',
+                " complete"),
+            state.executableId && (React.createElement(Text, { dimColor: true },
+                "Executable ID: ",
+                state.executableId)),
+            force && React.createElement(Text, { dimColor: true }, "(Force mode - overwrote existing)"),
+            activate && production && React.createElement(Text, { dimColor: true }, "(Activated)"))),
+        state.status === 'error' && state.error && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "red" }, state.error))),
+        state.status !== 'deploying' && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            state.status === 'error' && onRetryCredentials && (React.createElement(Text, { dimColor: true }, "Press r to retry with new credentials")),
+            onBack && (React.createElement(Text, { dimColor: true }, "Press q or Esc to return to menu"))))));
+}
+export const deployCommand = {
+    name: 'deploy',
+    description: 'Deploy the application',
+    requiresProject: true,
+    flags: {
+        force: {
+            type: 'boolean',
+            description: 'Force deployment (overwrite existing)',
+            alias: 'f',
+            default: false,
+        },
+        production: {
+            type: 'boolean',
+            description: 'Deploy to production (requires signed app)',
+            alias: 'p',
+            default: false,
+        },
+        activate: {
+            type: 'boolean',
+            description: 'Activate the app after production deployment',
+            alias: 'a',
+            default: false,
+        },
+    },
+    async execute({ project, flags }) {
+        // Check if dev properties are configured
+        if (!project.hasDevProperties || !project.devProperties) {
+            console.log('\n\x1b[33mDeployment credentials not configured.\x1b[0m');
+            console.log('Create a .dev_properties.json file with domain, siteName, addonName, username, and password.\n');
+            return;
+        }
+        const production = Boolean(flags['production']);
+        const force = Boolean(flags['force']);
+        const activate = Boolean(flags['activate']);
+        // For production, we need the signed zip, which requires signing credentials
+        let signingPassword;
+        if (production && project.hasSigningProperties && project.devProperties.signingUsername) {
+            // We already have a signed zip, no need to prompt for password here
+            // The sign command should have been run separately
+        }
+        const { waitUntilExit } = render(React.createElement(DeployScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: project.devProperties, force: force, production: production, activate: activate, signingPassword: signingPassword }));
+        await waitUntilExit();
+    },
+};

package/dist/commands/dev.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type Command } from './types.js';
+import type { SitevisionManifest, DevProperties, SigningCredentials } from '../types/index.js';
+interface DevScreenProps {
+    projectRoot: string;
+    manifest: SitevisionManifest;
+    devProperties: DevProperties;
+    signed: boolean;
+    signingCredentials?: SigningCredentials;
+    onBack?: () => void;
+    onRetryCredentials?: () => void;
+}
+export declare function DevScreen({ projectRoot, manifest, devProperties, signed, signingCredentials, onBack, onRetryCredentials, }: DevScreenProps): React.JSX.Element;
+export declare const devCommand: Command;
+export {};