sitevision-cli 0.0.0

package/dist/components/StatusIndicator.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type Status = 'pending' | 'running' | 'success' | 'error';
+interface Props {
+    status: Status;
+    label: string;
+    message?: string;
+}
+export declare function StatusIndicator({ status, label, message }: Props): React.JSX.Element;
+export {};

package/dist/components/StatusIndicator.js

@@ -0,0 +1,36 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+export function StatusIndicator({ status, label, message }) {
+    const getIcon = () => {
+        switch (status) {
+            case 'pending':
+                return React.createElement(Text, { dimColor: true }, "\u25CB");
+            case 'running':
+                return (React.createElement(Text, { color: "cyan" },
+                    React.createElement(Spinner, { type: "dots" })));
+            case 'success':
+                return React.createElement(Text, { color: "green" }, "\u2713");
+            case 'error':
+                return React.createElement(Text, { color: "red" }, "\u2717");
+        }
+    };
+    const getColor = () => {
+        switch (status) {
+            case 'pending':
+                return 'gray';
+            case 'running':
+                return 'cyan';
+            case 'success':
+                return 'green';
+            case 'error':
+                return 'red';
+        }
+    };
+    return (React.createElement(Box, null,
+        getIcon(),
+        React.createElement(Box, { marginLeft: 1 },
+            React.createElement(Text, { color: getColor(), bold: true }, label)),
+        message && (React.createElement(Box, { marginLeft: 1 },
+            React.createElement(Text, { dimColor: true }, message)))));
+}

package/dist/components/TextInput.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface Props {
+    label: string;
+    defaultValue?: string;
+    placeholder?: string;
+    onSubmit: (value: string) => void;
+    onCancel?: () => void;
+    type?: 'text' | 'password';
+}
+export declare function TextInput({ label, defaultValue, placeholder, onSubmit, onCancel, type, }: Props): React.JSX.Element;
+export {};

package/dist/components/TextInput.js

@@ -0,0 +1,37 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function TextInput({ label, defaultValue = '', placeholder, onSubmit, onCancel, type = 'text', }) {
+    const [value, setValue] = useState(defaultValue);
+    useInput((input, key) => {
+        if (key.return) {
+            if (value === '' && defaultValue) {
+                onSubmit(defaultValue);
+            }
+            else {
+                onSubmit(value);
+            }
+            return;
+        }
+        if (key.escape && onCancel) {
+            onCancel();
+            return;
+        }
+        if (key.delete || key.backspace) {
+            setValue((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (!key.ctrl && !key.meta) {
+            setValue((prev) => prev + input);
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, label)),
+        React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 },
+            React.createElement(Text, null, type === 'password' ? '*'.repeat(value.length) : value),
+            value === '' && placeholder && (React.createElement(Text, { dimColor: true }, placeholder))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press Enter to submit",
+                onCancel ? ', Esc to cancel' : ''))));
+}

package/dist/types/index.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Sitevision CLI - Shared Type Definitions
+ *
+ * This file contains all shared types used across the CLI.
+ */
+/**
+ * App types supported by Sitevision
+ */
+export type AppType = 'WebApp' | 'Widget' | 'RESTApp';
+/**
+ * Simplified app type for internal use
+ */
+export type SimpleAppType = 'web' | 'widget' | 'rest';
+/**
+ * Sitevision app manifest (manifest.json)
+ */
+export interface SitevisionManifest {
+    id: string;
+    name: string;
+    version: string;
+    type: AppType;
+    bundled?: boolean;
+    description?: string;
+    author?: string;
+    helpUrl?: string;
+    license?: string;
+    categories?: string[];
+}
+/**
+ * Development properties stored in .dev_properties.json
+ */
+export interface DevProperties {
+    domain: string;
+    siteName: string;
+    addonName: string;
+    username: string;
+    password: string;
+    useHTTPForDevDeploy?: boolean;
+    signingUsername?: string;
+    certificateName?: string;
+}
+/**
+ * Signing credentials (password is runtime-only, not persisted)
+ */
+export interface SigningCredentials {
+    username: string;
+    password: string;
+    certificateName?: string;
+}
+/**
+ * Deployment configuration
+ */
+export interface DeployConfig {
+    domain: string;
+    siteName: string;
+    addonName: string;
+    username: string;
+    password: string;
+    useHTTP?: boolean;
+}
+/**
+ * Production deployment configuration
+ */
+export interface ProductionDeployConfig extends DeployConfig {
+    activate?: boolean;
+}
+/**
+ * Package.json sitevision_scripts_properties section
+ */
+export interface SitevisionScriptsProperties {
+    transpile?: boolean;
+    transpilePackages?: string[];
+    babel?: Record<string, unknown>;
+}
+/**
+ * Full project information detected from the filesystem
+ */
+export interface ProjectInfo {
+    root: string;
+    manifest: SitevisionManifest;
+    hasDevProperties: boolean;
+    hasSigningProperties: boolean;
+    devProperties?: DevProperties;
+    packageJson: PackageJson;
+    hasSitevisionScripts: boolean;
+    hasNodeModules: boolean;
+    paths: ProjectPaths;
+}
+/**
+ * Standard project paths
+ */
+export interface ProjectPaths {
+    root: string;
+    src: string;
+    static: string;
+    build: string;
+    dist: string;
+    manifest: string;
+    devProperties: string | null;
+    packageJson: string;
+    nodeModules: string;
+}
+/**
+ * Partial package.json with fields we care about
+ */
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    sitevision_scripts_properties?: SitevisionScriptsProperties;
+    developmentDomain?: string;
+    productionDomain?: string;
+    addonName?: string;
+    siteName?: string;
+}
+/**
+ * REST API endpoints by app type
+ */
+export interface ApiEndpoints {
+    addon: string;
+    import: string;
+}
+/**
+ * API response from app signing
+ */
+export interface SigningResponse {
+    success: boolean;
+    signedFilePath?: string;
+    error?: string;
+}
+/**
+ * API response from deployment
+ */
+export interface DeployResponse {
+    success: boolean;
+    executableId?: string;
+    message?: string;
+    error?: string;
+}
+/**
+ * API response from addon creation
+ */
+export interface CreateAddonResponse {
+    success: boolean;
+    addonId?: string;
+    error?: string;
+}
+/**
+ * API response from activation
+ */
+export interface ActivationResponse {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Build mode
+ */
+export type BuildMode = 'development' | 'production';
+/**
+ * Build options for webpack
+ */
+export interface BuildOptions {
+    mode: BuildMode;
+    watch?: boolean;
+    cssPrefix?: string;
+    restApp?: boolean;
+}
+/**
+ * Build result
+ */
+export interface BuildResult {
+    success: boolean;
+    outputPath?: string;
+    errors?: string[];
+    warnings?: string[];
+    stats?: {
+        time: number;
+        hash: string;
+        assets: string[];
+    };
+}
+/**
+ * Watch callback for webpack watch mode
+ */
+export type WatchCallback = (result: BuildResult) => void;
+/**
+ * Command execution context
+ */
+export interface CommandContext {
+    project: ProjectInfo;
+    flags: Record<string, unknown>;
+    args: string[];
+}
+/**
+ * Command definition
+ */
+export interface Command {
+    name: string;
+    description: string;
+    requiresProject: boolean;
+    flags?: Record<string, CommandFlag>;
+    execute: (context: CommandContext) => Promise<void>;
+}
+/**
+ * Command flag definition
+ */
+export interface CommandFlag {
+    type: 'string' | 'boolean';
+    description: string;
+    alias?: string;
+    default?: unknown;
+}
+/**
+ * Process output types
+ */
+export interface ProcessOutput {
+    type: 'stdout' | 'stderr';
+    data: string;
+}
+/**
+ * Process execution result
+ */
+export interface ProcessResult {
+    exitCode: number;
+    output: ProcessOutput[];
+}
+/**
+ * HTTP request options
+ */
+export interface HttpRequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: unknown;
+    auth?: {
+        username: string;
+        password: string;
+    };
+}
+/**
+ * Generic result type for operations that can fail
+ */
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};

package/dist/types/index.js

@@ -0,0 +1,6 @@
+/**
+ * Sitevision CLI - Shared Type Definitions
+ *
+ * This file contains all shared types used across the CLI.
+ */
+export {};

package/dist/utils/password-prompt.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Prompt for password input with masked display
+ */
+export declare function promptPassword(prompt: string): Promise<string>;

package/dist/utils/password-prompt.js

@@ -0,0 +1,45 @@
+/**
+ * Prompt for password input with masked display
+ */
+export function promptPassword(prompt) {
+    return new Promise((resolve) => {
+        process.stdout.write(prompt);
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let password = '';
+        const onData = (data) => {
+            // Handle each character in the input (supports paste)
+            for (const char of data) {
+                const charCode = char.charCodeAt(0);
+                if (charCode === 13 || charCode === 10) {
+                    // Enter key
+                    stdin.setRawMode(false);
+                    stdin.removeListener('data', onData);
+                    stdin.pause();
+                    process.stdout.write('\n');
+                    resolve(password);
+                    return;
+                }
+                else if (charCode === 127 || charCode === 8) {
+                    // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else if (charCode === 3) {
+                    // Ctrl+C
+                    process.exit();
+                }
+                else if (charCode >= 32) {
+                    // Printable characters
+                    password += char;
+                    process.stdout.write('*');
+                }
+            }
+        };
+        stdin.on('data', onData);
+    });
+}

package/dist/utils/process-runner.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'events';
+export interface ProcessOutput {
+    type: 'stdout' | 'stderr';
+    data: string;
+}
+export interface ProcessResult {
+    exitCode: number;
+    output: ProcessOutput[];
+}
+export declare class ProcessRunner extends EventEmitter {
+    private command;
+    private args;
+    private cwd?;
+    private interactive;
+    private customEnv?;
+    private process;
+    private output;
+    constructor(command: string, args?: string[], cwd?: string | undefined, interactive?: boolean, customEnv?: Record<string, string> | undefined);
+    run(): Promise<ProcessResult>;
+    kill(): void;
+    getOutput(): ProcessOutput[];
+}
+/**
+ * Run a sitevision-scripts command in the project directory
+ */
+export declare function runSitevisionScript(scriptName: string, args?: string[], projectRoot?: string): ProcessRunner;
+/**
+ * Run an NPM script
+ */
+export declare function runNpmScript(scriptName: string, args?: string[], projectRoot?: string, customEnv?: Record<string, string>): ProcessRunner;

package/dist/utils/process-runner.js

@@ -0,0 +1,119 @@
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+export class ProcessRunner extends EventEmitter {
+    constructor(command, args = [], cwd, interactive = false, customEnv) {
+        super();
+        Object.defineProperty(this, "command", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: command
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: args
+        });
+        Object.defineProperty(this, "cwd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cwd
+        });
+        Object.defineProperty(this, "interactive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: interactive
+        });
+        Object.defineProperty(this, "customEnv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: customEnv
+        });
+        Object.defineProperty(this, "process", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    run() {
+        return new Promise((resolve, reject) => {
+            this.process = spawn(this.command, this.args, {
+                cwd: this.cwd || process.cwd(),
+                env: { ...process.env, ...this.customEnv },
+                shell: true,
+                stdio: this.interactive ? 'inherit' : 'pipe',
+            });
+            // Only capture output if not in interactive mode
+            if (!this.interactive) {
+                this.process.stdout?.on('data', data => {
+                    const output = {
+                        type: 'stdout',
+                        data: data.toString(),
+                    };
+                    this.output.push(output);
+                    if (this.output.length > 1000) {
+                        this.output.shift();
+                    }
+                    this.emit('output', output);
+                });
+                this.process.stderr?.on('data', data => {
+                    const output = {
+                        type: 'stderr',
+                        data: data.toString(),
+                    };
+                    this.output.push(output);
+                    if (this.output.length > 1000) {
+                        this.output.shift();
+                    }
+                    this.emit('output', output);
+                });
+            }
+            this.process.on('error', error => {
+                this.emit('error', error);
+                reject(error);
+            });
+            this.process.on('close', code => {
+                const exitCode = code ?? 0;
+                this.emit('exit', exitCode);
+                resolve({
+                    exitCode,
+                    output: this.output,
+                });
+            });
+        });
+    }
+    kill() {
+        if (this.process) {
+            this.process.kill('SIGTERM');
+        }
+    }
+    getOutput() {
+        return this.output;
+    }
+}
+/**
+ * Run a sitevision-scripts command in the project directory
+ */
+export function runSitevisionScript(scriptName, args = [], projectRoot) {
+    // Check if sitevision-scripts is available locally
+    const runner = new ProcessRunner('npm', ['run', scriptName, '--', ...args], projectRoot);
+    return runner;
+}
+/**
+ * Run an NPM script
+ */
+export function runNpmScript(scriptName, args = [], projectRoot, customEnv) {
+    const runner = new ProcessRunner('npm', ['run', scriptName, ...args], projectRoot, false, customEnv);
+    return runner;
+}

package/dist/utils/project-detection.d.ts

@@ -0,0 +1,103 @@
+import type { SitevisionManifest, DevProperties, ProjectPaths, SimpleAppType, PackageJson, ApiEndpoints } from '../types/index.js';
+export type { SitevisionManifest, DevProperties } from '../types/index.js';
+/**
+ * Project information with paths
+ */
+export interface ProjectInfo {
+    root: string;
+    manifest: SitevisionManifest;
+    hasDevProperties: boolean;
+    hasSigningProperties: boolean;
+    devProperties?: DevProperties;
+    packageJson: PackageJson;
+    hasSitevisionScripts: boolean;
+    hasNodeModules: boolean;
+    paths: ProjectPaths;
+}
+/**
+ * Get standard project paths for a given root directory
+ */
+export declare function getProjectPaths(root: string, manifestPath: string, devPropertiesPath: string | null): ProjectPaths;
+/**
+ * Find the dev properties file path (supports both naming conventions)
+ */
+export declare function findDevPropertiesPath(root: string): string | null;
+/**
+ * Get the default dev properties path (for creating new files)
+ */
+export declare function getDefaultDevPropertiesPath(root: string): string;
+/**
+ * Get the full app ID including any prefix/suffix from environment
+ *
+ * This combines: prefix + baseId + suffix
+ * Used for generating zip filenames and deployment identifiers
+ */
+export declare function getFullAppId(baseId: string): string;
+/**
+ * Get the zip filename for an app
+ */
+export declare function getZipFilename(manifest: SitevisionManifest): string;
+/**
+ * Get the signed zip filename for an app
+ */
+export declare function getSignedZipFilename(manifest: SitevisionManifest): string;
+/**
+ * Get the full path to the zip file in dist/
+ */
+export declare function getZipPath(projectRoot: string, manifest: SitevisionManifest): string;
+/**
+ * Get the full path to the signed zip file in dist/
+ */
+export declare function getSignedZipPath(projectRoot: string, manifest: SitevisionManifest): string;
+/**
+ * Get API endpoints for the given app type
+ */
+export declare function getApiEndpoints(appType: SimpleAppType): ApiEndpoints;
+/**
+ * Build the base URL for API requests
+ */
+export declare function buildApiBaseUrl(domain: string, siteName: string, useHTTP?: boolean): string;
+/**
+ * Build the addon endpoint URL
+ */
+export declare function buildAddonEndpointUrl(domain: string, siteName: string, appType: SimpleAppType, useHTTP?: boolean): string;
+/**
+ * Build the import endpoint URL
+ */
+export declare function buildImportEndpointUrl(domain: string, siteName: string, addonName: string, appType: SimpleAppType, useHTTP?: boolean): string;
+/**
+ * Detect if the current directory is a Sitevision project
+ */
+export declare function detectProject(cwd?: string): ProjectInfo | null;
+/**
+ * Validate that we're in a Sitevision project directory
+ */
+export declare function requireProject(cwd?: string): ProjectInfo;
+/**
+ * Get the app type (web, widget, rest)
+ */
+export declare function getAppType(manifest: SitevisionManifest): SimpleAppType;
+/**
+ * Check if the app uses webpack bundling
+ */
+export declare function isBundledApp(manifest: SitevisionManifest): boolean;
+/**
+ * Read and parse the dev properties file
+ */
+export declare function readDevProperties(projectRoot: string): DevProperties | null;
+/**
+ * Write dev properties to file
+ */
+export declare function writeDevProperties(projectRoot: string, properties: DevProperties): void;
+/**
+ * Ensure the dist directory exists
+ */
+export declare function ensureDistDir(projectRoot: string): string;
+/**
+ * Ensure the build directory exists
+ */
+export declare function ensureBuildDir(projectRoot: string): string;
+/**
+ * Clean the build directory
+ */
+export declare function cleanBuildDir(projectRoot: string): void;