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

package/dist/shell/Tabs.js

@@ -0,0 +1,90 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { appTypeOf, getPackageJsonSyncChanges, readAncestorDevProperties, localizedText, } from '../utils/project-detection.js';
+import { checkSitevisionScriptsCompatibility } from '../utils/sitevision-scripts-runner.js';
+import { ACCENT, elapsed } from './Frame.js';
+import { t } from '../utils/i18n.js';
+export const TABS = [
+    { id: 'overview', label: 'Overview', short: 'Ovw' },
+    { id: 'config', label: 'Config', short: 'Cfg' },
+    { id: 'versions', label: 'Versions', short: 'Ver' },
+    { id: 'log', label: 'Log', short: 'Log' },
+];
+export function TabBar({ tab, narrow, focused, }) {
+    return (_jsx(Box, { paddingX: 1, children: TABS.map((entry, i) => (_jsxs(Text, { children: [_jsxs(Text, { bold: entry.id === tab, color: entry.id === tab ? ACCENT : undefined, dimColor: entry.id !== tab, underline: entry.id === tab && focused, children: [i + 1, " ", t(narrow ? entry.short : entry.label)] }), ' '.repeat(3)] }, entry.id))) }));
+}
+function Row({ label, value, dim, }) {
+    return (_jsx(Box, { height: 1, flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { dimColor: true, children: label.padEnd(14) }), value, dim && _jsxs(Text, { dimColor: true, children: [" ", dim] })] }) }));
+}
+const LEVEL_COLOR = {
+    info: undefined,
+    ok: 'green',
+    warn: 'yellow',
+    error: 'red',
+};
+const STATUS_GLYPH = {
+    running: _jsx(Spinner, { type: "dots" }),
+    success: _jsx(Text, { color: "green", children: "\u2713" }),
+    error: _jsx(Text, { color: "red", children: "\u2717" }),
+    stopped: _jsx(Text, { dimColor: true, children: "\u25A0" }),
+};
+function time(ms, seconds = false) {
+    const d = new Date(ms);
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return seconds ? `${hh}:${mm}:${ss}` : `${hh}:${mm}`;
+}
+export function Overview({ project, tasks, height, }) {
+    const dev = project.devProperties;
+    const inherited = new Set(project.inheritedKeys);
+    const ancestors = readAncestorDevProperties(project.root);
+    const src = (key) => inherited.has(key)
+        ? Object.hasOwn(ancestors, key)
+            ? t('↑ root')
+            : 'package.json'
+        : undefined;
+    const notSet = t('not set');
+    const sync = getPackageJsonSyncChanges(project.root).length;
+    const scripts = checkSitevisionScriptsCompatibility(project.root);
+    const recent = tasks
+        .filter(task => task.appRoot === project.root && task.status !== 'running')
+        .slice(-Math.max(1, height - 18))
+        .toReversed();
+    const status = (ok, okText, badText, warn = false) => (_jsxs(Text, { children: [_jsx(Text, { color: ok ? 'green' : warn ? 'yellow' : 'red', children: ok ? '✓' : warn ? '~' : '✗' }), ' ', ok ? okText : badText] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsx(Box, { height: 1, flexShrink: 0, children: _jsxs(Text, { bold: true, wrap: "truncate", children: [localizedText(project.manifest.name) || project.manifest.id, ' ', _jsxs(Text, { dimColor: true, children: [project.manifest.type, project.manifest.bundled ? t(' · bundled') : ''] })] }) }), _jsx(Row, { label: t('id'), value: project.manifest.id }), _jsx(Row, { label: t('version'), value: project.manifest.version }), _jsx(Row, { label: t('type'), value: `${project.manifest.type} (${appTypeOf(project.manifest) ?? '?'})` }), _jsx(Row, { label: t('addon'), value: dev?.addonName ?? notSet, dim: src('addonName') }), _jsx(Row, { label: t('site'), value: dev?.siteName ?? notSet, dim: src('siteName') }), _jsx(Row, { label: t('environment'), value: dev?.environmentName ?? 'dev', dim: dev?.productionEnvironment ? t('production') : undefined }), _jsx(Row, { label: t('domain'), value: dev?.domain ?? notSet, dim: src('domain') }), _jsx(Row, { label: t('auth'), value: dev?.authMethod ?? (dev ? 'basic' : notSet), dim: src('authMethod') }), _jsx(Row, { label: t('signing user'), value: dev?.signingUsername ?? notSet, dim: src('signingUsername') }), _jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { dimColor: true, children: [t('deps').padEnd(10), status(project.hasNodeModules, 'node_modules', t('missing · i to install'))] }), _jsxs(Text, { dimColor: true, children: [t('config').padEnd(10), status(Boolean(dev), t('dev properties'), t('missing · e to edit'))] }), _jsxs(Text, { dimColor: true, children: [t('sync').padEnd(10), status(sync === 0, 'package.json', sync === 1
+                                ? t('1 diff · y to apply')
+                                : t('{n} diffs · y to apply', { n: sync }), true)] }), _jsxs(Text, { dimColor: true, children: [t('signing').padEnd(10), status(project.hasSigningProperties, dev?.signingUsername ?? '', t('missing · / set up signing'))] }), _jsxs(Text, { dimColor: true, children: [t('scripts').padEnd(10), status(scripts.status === 'ok', scripts.installed ?? '', scripts.installed
+                                ? `${scripts.installed} · ${scripts.status}`
+                                : t('not installed · i to install'), scripts.status !== 'not-installed')] }), project.hasLegacyPassword && (_jsxs(Text, { color: "yellow", children: [' '.repeat(10), t('⚠ plaintext password in .dev_properties.json · / migrate')] }))] }), recent.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, dimColor: true, children: t('RECENT') }), recent.map(task => (_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { dimColor: true, children: [time(task.endedAt ?? task.startedAt), " "] }), STATUS_GLYPH[task.status], " ", task.label, ' ', _jsx(Text, { dimColor: true, children: task.error ?? elapsed(task) })] }, task.id)))] }))] }));
+}
+export function Versions({ project, state, selected, }) {
+    if (!project.devProperties) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "yellow", children: t('⚠ Configure dev properties first (e).') }) }));
+    }
+    if (!state) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: t('Press R to fetch versions from {domain}.', {
+                    domain: project.devProperties.domain,
+                }) }) }));
+    }
+    const list = state.executables ?? [];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsxs(Text, { dimColor: true, children: [t('APP IDENTIFIER').padEnd(30), t('VERSION').padEnd(12), t('ACTIVE'), state.loading && (_jsxs(Text, { color: ACCENT, children: [' '.repeat(3), _jsx(Spinner, { type: "dots" })] }))] }), state.error && _jsx(Text, { color: "red", children: state.error }), list.map((e, i) => (_jsxs(Text, { backgroundColor: i === selected ? ACCENT : undefined, color: i === selected ? 'black' : undefined, wrap: "truncate", children: [e.appIdentifier.padEnd(30).slice(0, 30), e.appVersion.padEnd(12), e.active ? '●' : '○', i === selected ? ` ${e.id}` : ''] }, e.id))), !state.loading && !state.error && list.length === 0 && (_jsx(Text, { dimColor: true, children: t('No versions uploaded to {addon}.', {
+                    addon: project.devProperties.addonName,
+                }) })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [list.length === 1
+                            ? t('1 version · a activate selected · R refresh')
+                            : t('{n} versions · a activate selected · R refresh', {
+                                n: list.length,
+                            }), state.fetchedAt
+                            ? t(' · fetched {time}', { time: time(state.fetchedAt) })
+                            : ''] }) })] }));
+}
+export function Log({ task, height, scroll, wrap, }) {
+    if (!task) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: t('No task yet. d dev · w watch · b build · s sign · p deploy') }) }));
+    }
+    const visible = Math.max(1, height - 2);
+    const end = Math.max(0, task.lines.length - scroll);
+    const lines = task.lines.slice(Math.max(0, end - visible), end);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsxs(Text, { children: [STATUS_GLYPH[task.status], " ", task.label, " ", task.appName, ' ', _jsxs(Text, { dimColor: true, children: [task.phase, " \u00B7 ", elapsed(task), scroll > 0 ? ` · ↑${scroll}` : t(' · following')] })] }), lines.map((line, i) => (_jsxs(Text, { wrap: wrap ? 'wrap' : 'truncate', color: LEVEL_COLOR[line.level], children: [_jsxs(Text, { dimColor: true, children: [time(line.time, true), " ", line.tag.padEnd(3)] }), ' ', line.text] }, i)))] }));
+}

package/dist/shell/actions.d.ts

@@ -0,0 +1,45 @@
+import type { ProjectInfo, DeployConfig } from '../types/index.js';
+export type Tab = 'overview' | 'config' | 'versions' | 'log';
+export type Credential = {
+    accessToken?: string;
+    sessionCookie?: string;
+};
+export interface ActionContext {
+    project: ProjectInfo;
+    reload: () => void;
+    askPassword: (label: string, rememberLabel?: string) => Promise<{
+        password: string;
+        remember: boolean;
+    } | null>;
+    login: (method: 'oauth2' | 'cookie') => Promise<Credential | null>;
+    confirm: (message: string) => Promise<boolean>;
+    setTab: (tab: Tab) => void;
+    openWorkspaceSettings?: () => void;
+    openSettings: () => void;
+    environment: string;
+    isProduction: boolean;
+    cycleEnvironment: () => void;
+    addEnvironment: () => Promise<void>;
+    notify: (text: string, level?: 'info' | 'ok' | 'warn' | 'error') => void;
+    quit: () => void;
+}
+export interface Action {
+    id: string;
+    key?: string;
+    group: 'app' | 'setup' | 'auth';
+    label: string;
+    detail?: (project: ProjectInfo) => string | undefined;
+    enabled?: (project: ProjectInfo) => boolean;
+    run: (ctx: ActionContext) => Promise<void>;
+}
+export declare function forgetSession(project: ProjectInfo): void;
+/** Top-bar auth state without prompting for anything. */
+export declare function authState(project: ProjectInfo): {
+    ready: boolean;
+    label: string;
+};
+export declare function resolveDeployConfig(ctx: ActionContext, fresh?: boolean): Promise<DeployConfig | null>;
+export declare const actions: Action[];
+export declare function actionForKey(key: string): Action | undefined;
+/** Subsequence match, case-insensitive: "dpp" matches "Deploy to production". */
+export declare function fuzzyMatch(query: string, text: string): boolean;

package/dist/types/index.d.ts

@@ -6,21 +6,27 @@
 /**
  * App types supported by Sitevision
  */
-export type AppType = 'WebApp' | 'Widget' | 'RESTApp';
+export type AppType = 'WebApp' | 'Widget' | 'RESTApp' | 'MCPServer';
 /**
  * Simplified app type for internal use
  */
-export type SimpleAppType = 'web' | 'widget' | 'rest';
+export type SimpleAppType = 'web' | 'widget' | 'rest' | 'mcp';
+/**
+ * A manifest text field that may be a plain string or a localized object keyed
+ * by language code, e.g. `{sv: 'Namn', en: 'Name'}`. Sitevision allows either
+ * form for human-facing fields like `name` and `description`.
+ */
+export type LocalizedString = string | Record<string, string>;
 /**
  * Sitevision app manifest (manifest.json)
  */
 export interface SitevisionManifest {
     id: string;
-    name: string;
+    name: LocalizedString;
     version: string;
     type: AppType;
     bundled?: boolean;
-    description?: string;
+    description?: LocalizedString;
     author?: string;
     helpUrl?: string;
     license?: string;
@@ -42,6 +48,33 @@ export interface DevProperties {
     useHTTPForDevDeploy?: boolean;
     signingUsername?: string;
     certificateName?: string;
+    authMethod?: 'basic' | 'oauth2' | 'cookie';
+    oauth2?: OAuth2Config;
+    sessionLoginUrl?: string;
+    baseEnvironment?: string;
+    production?: boolean;
+    environments?: Record<string, EnvironmentOverride>;
+    accessToken?: string;
+    sessionCookie?: string;
+    environmentName?: string;
+    productionEnvironment?: boolean;
+}
+/** Fields an environment may override; everything else comes from the base. */
+export type EnvironmentOverride = Partial<Pick<DevProperties, 'domain' | 'siteName' | 'addonName' | 'username' | 'authMethod' | 'oauth2' | 'sessionLoginUrl' | 'useHTTPForDevDeploy'>> & {
+    production?: boolean;
+};
+/**
+ * OAuth2 provider config for bearer-token deploys.
+ *
+ * Deliberately secret-free: the client secret and refresh token live in the OS
+ * keychain, so nothing here is unsafe to write to .dev_properties.json.
+ */
+export interface OAuth2Config {
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    clientId: string;
+    scopes?: string[];
+    redirectPort?: number;
 }
 /**
  * Signing credentials (password is runtime-only, not persisted)
@@ -59,7 +92,9 @@ export interface DeployConfig {
     siteName: string;
     addonName: string;
     username: string;
-    password: string;
+    password?: string;
+    accessToken?: string;
+    sessionCookie?: string;
     useHTTP?: boolean;
 }
 /**
@@ -86,6 +121,7 @@ export interface ProjectInfo {
     hasSigningProperties: boolean;
     hasLegacyPassword: boolean;
     devProperties?: DevProperties;
+    inheritedKeys: string[];
     packageJson: PackageJson;
     hasSitevisionScripts: boolean;
     hasNodeModules: boolean;
@@ -143,6 +179,7 @@ export interface DeployResponse {
     executableId?: string;
     message?: string;
     error?: string;
+    authExpired?: boolean;
 }
 /**
  * API response from addon creation
@@ -151,6 +188,7 @@ export interface CreateAddonResponse {
     success: boolean;
     addonId?: string;
     error?: string;
+    authExpired?: boolean;
 }
 /**
  * API response from activation
@@ -158,6 +196,7 @@ export interface CreateAddonResponse {
 export interface ActivationResponse {
     success: boolean;
     error?: string;
+    authExpired?: boolean;
 }
 /**
  * Build mode

package/dist/utils/config.d.ts

@@ -1,3 +1,13 @@
+import { type Language } from './i18n.js';
+/** User-facing preferences editable from the shell's Settings screen. */
+export interface Settings {
+    language: Language;
+    introAnimation: boolean;
+}
+export declare function getSettings(): Settings;
+export declare function setSettings(patch: Partial<Settings>): void;
+/** Path of the config file, for display. */
+export declare function settingsFile(): string;
 /**
  * True until the user has completed the first-run welcome at least once.
  */

package/dist/utils/config.js

@@ -26,6 +26,20 @@ function writeConfig(config) {
         // shows again next time, which is harmless.
     }
 }
+export function getSettings() {
+    const config = readConfig();
+    return {
+        language: config.language ?? 'en',
+        introAnimation: config.introAnimation ?? true,
+    };
+}
+export function setSettings(patch) {
+    writeConfig({ ...readConfig(), ...patch });
+}
+/** Path of the config file, for display. */
+export function settingsFile() {
+    return configFile();
+}
 /**
  * True until the user has completed the first-run welcome at least once.
  */

package/dist/utils/environments.d.ts

@@ -0,0 +1,20 @@
+import type { DevProperties, EnvironmentOverride, ProjectInfo } from '../types/index.js';
+/** Name of the environment the top-level dev properties describe. */
+export declare function baseEnvironment(dev?: Partial<DevProperties>): string;
+export declare function environmentNames(dev?: Partial<DevProperties>): string[];
+export declare function isProductionEnvironment(name: string, dev?: Partial<DevProperties>): boolean;
+/** Badge colour: dev green, production red, anything else yellow. */
+export declare function environmentColor(name: string, dev?: Partial<DevProperties>): 'green' | 'yellow' | 'red';
+/**
+ * The effective dev properties for one environment: the base with that
+ * environment's overrides applied and credentials resolved for its
+ * domain/username. The base ("dev") is returned as-is.
+ */
+export declare function resolveEnvironment(dev: DevProperties, name: string): DevProperties;
+/** A project view whose dev properties are resolved for `name`. */
+export declare function environmentProject(project: ProjectInfo, name: string): ProjectInfo;
+/**
+ * Write one environment's override into the base: keep only the keys whose
+ * value differs from the base, so the file stays minimal.
+ */
+export declare function withEnvironmentOverride(base: DevProperties, name: string, values: EnvironmentOverride): DevProperties;

package/dist/utils/environments.js

@@ -0,0 +1,74 @@
+import { resolveRuntimeSecrets } from './project-detection.js';
+/** Name of the environment the top-level dev properties describe. */
+export function baseEnvironment(dev) {
+    return dev?.baseEnvironment?.trim() || 'dev';
+}
+export function environmentNames(dev) {
+    const base = baseEnvironment(dev);
+    return [
+        base,
+        ...Object.keys(dev?.environments ?? {}).filter(name => name !== base),
+    ];
+}
+export function isProductionEnvironment(name, dev) {
+    if (name === baseEnvironment(dev))
+        return dev?.production ?? false;
+    return dev?.environments?.[name]?.production ?? /prod/i.test(name);
+}
+/** Badge colour: dev green, production red, anything else yellow. */
+export function environmentColor(name, dev) {
+    if (isProductionEnvironment(name, dev))
+        return 'red';
+    return name === baseEnvironment(dev) ? 'green' : 'yellow';
+}
+/**
+ * The effective dev properties for one environment: the base with that
+ * environment's overrides applied and credentials resolved for its
+ * domain/username. The base ("dev") is returned as-is.
+ */
+export function resolveEnvironment(dev, name) {
+    const production = isProductionEnvironment(name, dev);
+    if (name === baseEnvironment(dev)) {
+        return { ...dev, environmentName: name, productionEnvironment: production };
+    }
+    const override = dev.environments?.[name] ?? {};
+    const { production: _production, ...fields } = override;
+    const resolved = {
+        ...dev,
+        ...fields,
+        password: undefined,
+        accessToken: undefined,
+        sessionCookie: undefined,
+        environmentName: name,
+        productionEnvironment: production,
+    };
+    return resolveRuntimeSecrets(resolved);
+}
+/** A project view whose dev properties are resolved for `name`. */
+export function environmentProject(project, name) {
+    if (!project.devProperties)
+        return project;
+    return {
+        ...project,
+        devProperties: resolveEnvironment(project.devProperties, name),
+    };
+}
+/**
+ * Write one environment's override into the base: keep only the keys whose
+ * value differs from the base, so the file stays minimal.
+ */
+export function withEnvironmentOverride(base, name, values) {
+    const current = { ...base.environments?.[name] };
+    const changed = Object.fromEntries(Object.entries(values).map(([key, value]) => {
+        const baseValue = base[key];
+        const same = value === undefined ||
+            value === '' ||
+            JSON.stringify(value) === JSON.stringify(baseValue);
+        return [key, same ? undefined : value];
+    }));
+    const override = Object.fromEntries(Object.entries({ ...current, ...changed }).filter(([, value]) => value !== undefined));
+    return {
+        ...base,
+        environments: { ...base.environments, [name]: override },
+    };
+}

package/dist/utils/i18n.d.ts

@@ -0,0 +1,12 @@
+/**
+ * UI language. English strings are the keys; `t()` returns them untouched in
+ * English and looks them up in the Swedish table otherwise, falling back to
+ * English for anything untranslated. `{name}` placeholders are filled from
+ * the vars argument.
+ */
+export type Language = 'en' | 'sv';
+export declare const LANGUAGES: Language[];
+export declare const LANGUAGE_NAMES: Record<Language, string>;
+export declare function getLanguage(): Language;
+export declare function setLanguage(language: Language): void;
+export declare function t(text: string, vars?: Record<string, string | number>): string;