sitevision-cli 0.0.0

package/dist/commands/dev.js

@@ -0,0 +1,291 @@
+import React from 'react';
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { StatusIndicator } from '../components/StatusIndicator.js';
+import { WebpackRunner } from '../utils/webpack-runner.js';
+import { promptPassword } from '../utils/password-prompt.js';
+import { signApp, deployApp } from '../utils/sitevision-api.js';
+import { copyStaticToBuild, createBuildZip, cleanBuild, } from '../utils/zip.js';
+import { isBundledApp, getAppType, getFullAppId, getZipPath, getSignedZipPath, } from '../utils/project-detection.js';
+export function DevScreen({ projectRoot, manifest, devProperties, signed, signingCredentials, onBack, onRetryCredentials, }) {
+    const { exit } = useApp();
+    const [state, setState] = React.useState({
+        status: 'initializing',
+        message: 'Starting webpack watch...',
+        buildCount: 0,
+        webpackReady: false,
+    });
+    useInput((input, key) => {
+        if (onBack && (key.escape || input === 'q')) {
+            onBack();
+        }
+        if (onRetryCredentials && state.status === 'error' && input === 'r') {
+            onRetryCredentials();
+        }
+    });
+    const webpackRunnerRef = React.useRef(null);
+    const handleBuildComplete = React.useCallback(async (result) => {
+        if (!result.success) {
+            setState(prev => ({
+                ...prev,
+                status: 'error',
+                message: result.errors?.join('\n') || 'Build failed',
+                error: result.errors?.join('\n'),
+            }));
+            return;
+        }
+        try {
+            // Copy static files
+            copyStaticToBuild(projectRoot);
+            // Create zip
+            const appId = getFullAppId(manifest.id);
+            await createBuildZip(projectRoot, appId);
+            const zipPath = getZipPath(projectRoot, manifest);
+            let deployZipPath = zipPath;
+            // Sign if needed
+            if (signed && signingCredentials) {
+                setState(prev => ({
+                    ...prev,
+                    status: 'signing',
+                    message: 'Signing app...',
+                }));
+                const signedZipPath = getSignedZipPath(projectRoot, manifest);
+                const signResult = await signApp(zipPath, signingCredentials, signedZipPath);
+                if (!signResult.success) {
+                    setState(prev => ({
+                        ...prev,
+                        status: 'error',
+                        message: `Signing failed: ${signResult.error}`,
+                        error: signResult.error,
+                    }));
+                    return;
+                }
+                deployZipPath = signedZipPath;
+            }
+            // Deploy
+            setState(prev => ({
+                ...prev,
+                status: 'deploying',
+                message: 'Deploying to dev...',
+            }));
+            const appType = getAppType(manifest);
+            const deployResult = await deployApp(deployZipPath, {
+                domain: devProperties.domain,
+                siteName: devProperties.siteName,
+                addonName: devProperties.addonName,
+                username: devProperties.username,
+                password: devProperties.password,
+                useHTTP: devProperties.useHTTPForDevDeploy,
+            }, appType, true);
+            if (!deployResult.success) {
+                setState(prev => ({
+                    ...prev,
+                    status: 'error',
+                    message: `Deploy failed: ${deployResult.error}`,
+                    error: deployResult.error,
+                }));
+                return;
+            }
+            // Success - back to watching
+            setState(prev => ({
+                ...prev,
+                status: 'ready',
+                message: 'Deployed. Watching for changes...',
+                buildCount: prev.buildCount + 1,
+                lastBuildTime: result.stats?.time,
+                error: undefined,
+            }));
+        }
+        catch (error) {
+            setState(prev => ({
+                ...prev,
+                status: 'error',
+                message: error instanceof Error ? error.message : String(error),
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }, [projectRoot, manifest, devProperties, signed, signingCredentials]);
+    React.useEffect(() => {
+        const isBundled = isBundledApp(manifest);
+        async function startWatch() {
+            try {
+                // Clean build directory
+                cleanBuild(projectRoot);
+                if (isBundled) {
+                    // Check if webpack is available
+                    if (!WebpackRunner.isWebpackAvailable(projectRoot)) {
+                        setState({
+                            status: 'error',
+                            message: 'webpack not found. Run npm install.',
+                            buildCount: 0,
+                            webpackReady: false,
+                            error: 'webpack not found',
+                        });
+                        return;
+                    }
+                    setState(prev => ({
+                        ...prev,
+                        status: 'building',
+                        message: 'Starting initial build...',
+                    }));
+                    const appType = getAppType(manifest);
+                    const runner = new WebpackRunner(projectRoot, {
+                        mode: 'development',
+                        watch: true,
+                        cssPrefix: manifest.id,
+                        restApp: appType === 'rest',
+                    });
+                    webpackRunnerRef.current = runner;
+                    await runner.watch(handleBuildComplete);
+                    setState(prev => ({
+                        ...prev,
+                        status: 'watching',
+                        message: 'Building...',
+                        webpackReady: true,
+                    }));
+                }
+                else {
+                    // Non-bundled app: just copy and deploy
+                    setState(prev => ({
+                        ...prev,
+                        status: 'building',
+                        message: 'Copying files...',
+                    }));
+                    await handleBuildComplete({
+                        success: true,
+                        stats: { time: 0, hash: '', assets: [] },
+                    });
+                }
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    message: error instanceof Error ? error.message : String(error),
+                    buildCount: 0,
+                    webpackReady: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        startWatch();
+        // Cleanup
+        return () => {
+            if (webpackRunnerRef.current) {
+                webpackRunnerRef.current.close().catch(() => { });
+            }
+        };
+    }, [projectRoot, manifest, handleBuildComplete]);
+    // Handle Ctrl+C
+    React.useEffect(() => {
+        const handleExit = () => {
+            if (webpackRunnerRef.current) {
+                webpackRunnerRef.current.close().catch(() => { });
+            }
+            exit();
+        };
+        process.on('SIGINT', handleExit);
+        process.on('SIGTERM', handleExit);
+        return () => {
+            process.off('SIGINT', handleExit);
+            process.off('SIGTERM', handleExit);
+        };
+    }, [exit]);
+    const getStatusType = () => {
+        switch (state.status) {
+            case 'error':
+                return 'error';
+            case 'ready':
+                return 'success';
+            default:
+                return 'running';
+        }
+    };
+    const getStatusLabel = () => {
+        switch (state.status) {
+            case 'initializing':
+                return 'Initializing';
+            case 'watching':
+                return 'Watching';
+            case 'building':
+                return 'Building';
+            case 'signing':
+                return 'Signing';
+            case 'deploying':
+                return 'Deploying';
+            case 'ready':
+                return 'Ready';
+            case 'error':
+                return 'Error';
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(StatusIndicator, { status: getStatusType(), label: getStatusLabel(), message: state.message })),
+        state.buildCount > 0 && (React.createElement(Box, { marginLeft: 2, marginBottom: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Builds: ",
+                state.buildCount,
+                state.lastBuildTime ? ` | Last build: ${state.lastBuildTime}ms` : '',
+                signed ? ' | Signed mode' : ''))),
+        React.createElement(Box, { marginLeft: 2, marginBottom: 1 },
+            React.createElement(Text, { dimColor: true },
+                manifest.name,
+                " v",
+                manifest.version)),
+        devProperties && (React.createElement(Box, { marginLeft: 2, marginBottom: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Target: ",
+                devProperties.domain,
+                "/",
+                devProperties.siteName,
+                "/",
+                devProperties.addonName))),
+        state.status === 'error' && state.error && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "red" }, state.error))),
+        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 (Ctrl+C to stop process)")) : (React.createElement(Text, { dimColor: true }, "Press Ctrl+C to stop")))));
+}
+export const devCommand = {
+    name: 'dev',
+    description: 'Start development server with watch mode',
+    requiresProject: true,
+    flags: {
+        signed: {
+            type: 'boolean',
+            description: 'Use signed mode (sign before each deploy)',
+            alias: 's',
+            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 signed = Boolean(flags['signed']);
+        let signingCredentials;
+        // If signed mode, prompt for signing password
+        if (signed) {
+            if (!project.hasSigningProperties || !project.devProperties.signingUsername) {
+                console.log('\n\x1b[33mSigning credentials not configured.\x1b[0m');
+                console.log('Run \x1b[36msetup-signing\x1b[0m to configure credentials.\n');
+                return;
+            }
+            console.log('');
+            const password = await promptPassword('Signing password (developer.sitevision.se): ');
+            if (!password) {
+                console.log('\x1b[31mError: Password is required for signed mode\x1b[0m');
+                return;
+            }
+            signingCredentials = {
+                username: project.devProperties.signingUsername,
+                password,
+                certificateName: project.devProperties.certificateName,
+            };
+        }
+        const { waitUntilExit } = render(React.createElement(DevScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: project.devProperties, signed: signed, signingCredentials: signingCredentials }));
+        await waitUntilExit();
+    },
+};

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+import { type Command } from './types.js';
+export declare const commands: Command[];
+export declare function getCommand(name: string): Command | undefined;
+export declare function getAllCommands(): Command[];

package/dist/commands/index.js

@@ -0,0 +1,20 @@
+import { devCommand } from './dev.js';
+import { buildCommand } from './build.js';
+import { deployCommand } from './deploy.js';
+import { infoCommand } from './info.js';
+import { setupSigningCommand } from './setup-signing.js';
+import { signCommand } from './sign.js';
+export const commands = [
+    devCommand,
+    buildCommand,
+    signCommand,
+    deployCommand,
+    infoCommand,
+    setupSigningCommand,
+];
+export function getCommand(name) {
+    return commands.find((cmd) => cmd.name === name);
+}
+export function getAllCommands() {
+    return commands;
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from './types.js';
+export declare const infoCommand: Command;

package/dist/commands/info.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { render } from 'ink';
+import { Box, Text } from 'ink';
+import { getAppType } from '../utils/project-detection.js';
+function InfoScreen({ project }) {
+    const appType = getAppType(project.manifest);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "Sitevision Project Information")),
+        React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            React.createElement(Box, null,
+                React.createElement(Text, { bold: true }, "Name: "),
+                React.createElement(Text, null, project.manifest.name)),
+            React.createElement(Box, null,
+                React.createElement(Text, { bold: true }, "ID: "),
+                React.createElement(Text, null, project.manifest.id)),
+            React.createElement(Box, null,
+                React.createElement(Text, { bold: true }, "Version: "),
+                React.createElement(Text, null, project.manifest.version)),
+            React.createElement(Box, null,
+                React.createElement(Text, { bold: true }, "Type: "),
+                React.createElement(Text, { color: "green" }, project.manifest.type),
+                React.createElement(Text, { dimColor: true },
+                    " (",
+                    appType,
+                    ")")),
+            React.createElement(Box, null,
+                React.createElement(Text, { bold: true }, "Bundled: "),
+                React.createElement(Text, null, project.manifest.bundled ? 'Yes' : 'No'))),
+        project.hasDevProperties && project.devProperties && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1, marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "cyan" }, "Development Configuration")),
+            React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true }, "Domain: "),
+                    React.createElement(Text, null, project.devProperties.domain)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true }, "Site: "),
+                    React.createElement(Text, null, project.devProperties.siteName)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true }, "Addon: "),
+                    React.createElement(Text, null, project.devProperties.addonName)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true }, "Username: "),
+                    React.createElement(Text, null, project.devProperties.username)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true }, "Use HTTP: "),
+                    React.createElement(Text, null, project.devProperties.useHTTPForDevDeploy ? 'Yes' : 'No'))))),
+        !project.hasDevProperties && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" },
+                "\u26A0 No dev properties found. Run",
+                ' ',
+                React.createElement(Text, { bold: true }, "setup-dev-properties"),
+                " to configure."))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { bold: true }, "Project Root: "),
+            React.createElement(Text, { dimColor: true }, project.root))));
+}
+export const infoCommand = {
+    name: 'info',
+    description: 'Show project information',
+    requiresProject: true,
+    async execute({ project }) {
+        render(React.createElement(InfoScreen, { project: project }));
+    },
+};

package/dist/commands/setup-signing.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from './types.js';
+export declare const setupSigningCommand: Command;

package/dist/commands/setup-signing.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+function question(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+export const setupSigningCommand = {
+    name: 'setup-signing',
+    description: 'Configure signing credentials for developer.sitevision.se',
+    requiresProject: true,
+    async execute({ project }) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        console.log('\n\x1b[36m\x1b[1mSetup Signing Credentials\x1b[0m\n');
+        console.log('Configure credentials for signing apps on developer.sitevision.se');
+        console.log('(Password will be prompted when running signing commands)\n');
+        // Find existing dev properties file
+        const devPropertiesPaths = [
+            path.join(project.root, '.dev_properties.json'),
+            path.join(project.root, '.dev-properties.json'),
+        ];
+        let devPropertiesPath = devPropertiesPaths[0];
+        let existingProperties = {};
+        for (const p of devPropertiesPaths) {
+            if (fs.existsSync(p)) {
+                devPropertiesPath = p;
+                try {
+                    existingProperties = JSON.parse(fs.readFileSync(p, 'utf-8'));
+                }
+                catch {
+                    // Invalid file, start fresh
+                }
+                break;
+            }
+        }
+        try {
+            // Get signing username
+            const defaultUsername = existingProperties['signingUsername'] || '';
+            const usernamePrompt = defaultUsername
+                ? `Signing username [${defaultUsername}]: `
+                : 'Signing username: ';
+            let signingUsername = await question(rl, usernamePrompt);
+            if (!signingUsername && defaultUsername) {
+                signingUsername = defaultUsername;
+            }
+            if (!signingUsername) {
+                console.log('\x1b[31mError: Signing username is required\x1b[0m');
+                rl.close();
+                return;
+            }
+            // Get certificate name (optional)
+            const defaultCertName = existingProperties['certificateName'] || '';
+            const certPrompt = defaultCertName
+                ? `Certificate name (blank for default) [${defaultCertName}]: `
+                : 'Certificate name (blank for default): ';
+            let certificateName = await question(rl, certPrompt);
+            if (!certificateName && defaultCertName) {
+                certificateName = defaultCertName;
+            }
+            rl.close();
+            // Update dev properties (remove any stored password from old config)
+            const { signingPassword: _removed, ...cleanedProperties } = existingProperties;
+            const updatedProperties = {
+                ...cleanedProperties,
+                signingUsername,
+                ...(certificateName && { certificateName }),
+            };
+            fs.writeFileSync(devPropertiesPath, JSON.stringify(updatedProperties, null, 2));
+            console.log(`\n\x1b[32mSigning credentials saved to ${path.basename(devPropertiesPath)}\x1b[0m\n`);
+        }
+        catch (error) {
+            rl.close();
+            console.error('\x1b[31mError setting up signing credentials:\x1b[0m', error);
+        }
+    },
+};

package/dist/commands/sign.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type Command } from './types.js';
+import type { SitevisionManifest, DevProperties } from '../types/index.js';
+interface SignScreenProps {
+    projectRoot: string;
+    manifest: SitevisionManifest;
+    devProperties: DevProperties;
+    password: string;
+    onBack?: () => void;
+    onRetryCredentials?: () => void;
+}
+export declare function SignScreen({ projectRoot, manifest, devProperties, password, onBack, onRetryCredentials }: SignScreenProps): React.JSX.Element;
+export declare const signCommand: Command;
+export {};

package/dist/commands/sign.js

@@ -0,0 +1,103 @@
+import React from 'react';
+import { render, Box, Text, useInput } from 'ink';
+import { StatusIndicator } from '../components/StatusIndicator.js';
+import { signApp } from '../utils/sitevision-api.js';
+import { promptPassword } from '../utils/password-prompt.js';
+import { getZipPath, getSignedZipPath, } from '../utils/project-detection.js';
+import { formatFileSize, getZipSize, zipExists } from '../utils/zip.js';
+export function SignScreen({ projectRoot, manifest, devProperties, password, onBack, onRetryCredentials }) {
+    const [state, setState] = React.useState({
+        status: 'signing',
+        message: 'Signing app via developer.sitevision.se...',
+    });
+    useInput((input, key) => {
+        if (state.status !== 'signing') {
+            if (onBack && (key.escape || input === 'q')) {
+                onBack();
+            }
+            if (onRetryCredentials && state.status === 'error' && input === 'r') {
+                onRetryCredentials();
+            }
+        }
+    });
+    React.useEffect(() => {
+        async function runSign() {
+            try {
+                const zipPath = getZipPath(projectRoot, manifest);
+                const signedZipPath = getSignedZipPath(projectRoot, manifest);
+                // Validate zip exists
+                if (!zipExists(zipPath)) {
+                    setState({
+                        status: 'error',
+                        error: `Zip file not found: ${zipPath}\nRun 'build' first to create the zip file.`,
+                    });
+                    return;
+                }
+                // Sign the app
+                const result = await signApp(zipPath, {
+                    username: devProperties.signingUsername,
+                    password,
+                    certificateName: devProperties.certificateName,
+                }, signedZipPath);
+                if (!result.success) {
+                    setState({
+                        status: 'error',
+                        error: result.error || 'Signing failed',
+                    });
+                    return;
+                }
+                const signedSize = getZipSize(signedZipPath);
+                setState({
+                    status: 'success',
+                    message: 'App signed successfully',
+                    signedPath: signedZipPath,
+                    signedSize,
+                });
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        runSign();
+    }, [projectRoot, manifest, devProperties, password]);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(StatusIndicator, { status: state.status === 'signing' ? 'running' : state.status, label: state.status === 'signing' ? 'Signing' : state.status === 'success' ? 'Signed' : 'Failed', message: state.message })),
+        state.status === 'success' && state.signedPath && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            React.createElement(Text, { color: "green" },
+                "Created: ",
+                state.signedPath),
+            state.signedSize !== undefined && (React.createElement(Text, { dimColor: true },
+                "Size: ",
+                formatFileSize(state.signedSize))))),
+        state.status === 'error' && state.error && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "red" }, state.error))),
+        state.status !== 'signing' && (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 signCommand = {
+    name: 'sign',
+    description: 'Sign the app for production deployment',
+    requiresProject: true,
+    async execute({ project }) {
+        // Check if signing credentials are configured
+        if (!project.hasSigningProperties || !project.devProperties?.signingUsername) {
+            console.log('\n\x1b[33mSigning credentials not configured.\x1b[0m');
+            console.log('Run \x1b[36msetup-signing\x1b[0m to configure credentials.\n');
+            return;
+        }
+        // Prompt for password
+        console.log('');
+        const password = await promptPassword('Signing password (developer.sitevision.se: ');
+        if (!password) {
+            console.log('\x1b[31mError: Password is required\x1b[0m');
+            return;
+        }
+        const { waitUntilExit } = render(React.createElement(SignScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: project.devProperties, password: password }));
+        await waitUntilExit();
+    },
+};

package/dist/commands/types.d.ts

@@ -0,0 +1,18 @@
+import { type ProjectInfo } from '../utils/project-detection.js';
+export interface CommandContext {
+    project: ProjectInfo;
+    flags: Record<string, any>;
+    args: string[];
+}
+export interface Command {
+    name: string;
+    description: string;
+    requiresProject: boolean;
+    flags?: Record<string, {
+        type: 'string' | 'boolean';
+        description: string;
+        alias?: string;
+        default?: any;
+    }>;
+    execute: (context: CommandContext) => Promise<void>;
+}

package/dist/commands/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/DevPropertiesForm.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { DevProperties, PackageJson } from '../types/index.js';
+interface Props {
+    projectRoot: string;
+    initialProperties?: DevProperties;
+    packageJson: PackageJson;
+    onComplete: () => void;
+    onCancel: () => void;
+}
+export declare function DevPropertiesForm({ projectRoot, initialProperties, packageJson, onComplete, onCancel }: Props): React.JSX.Element;
+export {};