@kispace-io/core 0.7.0

package/src/core/logger.ts

@@ -0,0 +1,187 @@
+import { rootContext } from './di';
+
+export type LogLevel = 'info' | 'warning' | 'error' | 'debug';
+
+const LogLevelPriority: Record<LogLevel, number> = {
+    'debug': 0,
+    'info': 1,
+    'warning': 2,
+    'error': 3,
+};
+
+// Global log level filter
+let globalLogLevel: LogLevel = 'debug';
+
+// Store original console methods before any interception
+const originalConsole = {
+    log: console.log.bind(console),
+    info: console.info.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    debug: console.debug.bind(console)
+};
+
+// Log handler type
+type LogHandler = (source: string, message: string, level: LogLevel) => void;
+
+// Registered log handler (set by UI components like k-log-terminal)
+let logHandler: LogHandler | null = null;
+
+// Message buffer for logs that occur before handler is registered
+const messageBuffer: Array<{source: string, message: string, level: LogLevel}> = [];
+
+// Format console arguments
+function formatArg(arg: any): string {
+    if (arg === null) return 'null';
+    if (arg === undefined) return 'undefined';
+    if (typeof arg === 'string') return arg;
+    if (typeof arg === 'number' || typeof arg === 'boolean') return String(arg);
+    if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+    
+    try {
+        return JSON.stringify(arg);
+    } catch {
+        return String(arg);
+    }
+}
+
+/**
+ * Global logger utility for logging messages
+ */
+export class Logger {
+    constructor(private source: string) {}
+
+    info(message: string) {
+        this.log(message, 'info');
+    }
+
+    warning(message: string) {
+        this.log(message, 'warning');
+    }
+
+    warn(message: string) {
+        this.log(message, 'warning');
+    }
+
+    error(message: string) {
+        this.log(message, 'error');
+    }
+
+    debug(message: string) {
+        this.log(message, 'debug');
+    }
+
+    private log(message: string, level: LogLevel) {
+        dispatch(this.source, message, level);
+    }
+}
+
+/**
+ * Check if a log level should be displayed based on current filter
+ */
+function shouldLog(level: LogLevel): boolean {
+    return LogLevelPriority[level] >= LogLevelPriority[globalLogLevel];
+}
+
+/**
+ * Dispatch a log message to the registered handler (or buffer it if no handler registered)
+ */
+function dispatch(source: string, message: string, level: LogLevel) {
+    if (!shouldLog(level)) {
+        return;
+    }
+
+    if (logHandler) {
+        logHandler(source, message, level);
+    } else {
+        // Buffer the message until handler is registered
+        messageBuffer.push({ source, message, level });
+        // Also log to console as fallback
+        originalConsole[level === 'error' ? 'error' : level === 'warning' ? 'warn' : level === 'debug' ? 'debug' : 'log'](
+            `[${source}] ${message}`
+        );
+    }
+}
+
+/**
+ * Initialize console interception globally
+ * Note: This is called automatically when the logger module is imported
+ */
+export function initializeConsoleInterception() {
+    console.log = function(...args: any[]) {
+        originalConsole.log.apply(console, args);
+        dispatch('Console', args.map(a => formatArg(a)).join(' '), 'info');
+    };
+    
+    console.info = function(...args: any[]) {
+        originalConsole.info.apply(console, args);
+        dispatch('Console', args.map(a => formatArg(a)).join(' '), 'info');
+    };
+    
+    console.warn = function(...args: any[]) {
+        originalConsole.warn.apply(console, args);
+        dispatch('Console', args.map(a => formatArg(a)).join(' '), 'warning');
+    };
+    
+    console.error = function(...args: any[]) {
+        originalConsole.error.apply(console, args);
+        dispatch('Console', args.map(a => formatArg(a)).join(' '), 'error');
+    };
+    
+    console.debug = function(...args: any[]) {
+        originalConsole.debug.apply(console, args);
+        dispatch('Console', args.map(a => formatArg(a)).join(' '), 'debug');
+    };
+}
+
+// Auto-initialize console interception when this module is imported
+initializeConsoleInterception();
+
+/**
+ * Register a handler to receive log messages
+ * Also flushes any buffered messages to the new handler
+ */
+export function registerLogHandler(handler: LogHandler) {
+    logHandler = handler;
+    
+    // Flush buffered messages
+    while (messageBuffer.length > 0) {
+        const msg = messageBuffer.shift();
+        if (msg) {
+            handler(msg.source, msg.message, msg.level);
+        }
+    }
+}
+
+/**
+ * Unregister the current log handler
+ */
+export function unregisterLogHandler() {
+    logHandler = null;
+}
+
+/**
+ * Create a logger instance for a specific source
+ */
+export function createLogger(source: string): Logger {
+    return new Logger(source);
+}
+
+/**
+ * Set the global log level filter
+ */
+export function setLogLevel(level: LogLevel) {
+    globalLogLevel = level;
+}
+
+/**
+ * Default logger instance for backward compatibility
+ * This provides a simple logger similar to the old logging.ts
+ */
+const defaultLogger = createLogger('System');
+
+// Register default logger in DI container for backward compatibility
+rootContext.put('logger', defaultLogger);
+
+export default defaultLogger;
+

package/src/core/marketplaceregistry.ts

@@ -0,0 +1,197 @@
+import {appSettings} from "./settingsservice";
+import {publish} from "./events";
+import {createLogger} from "./logger";
+import {extensionRegistry, Extension} from "./extensionregistry";
+import {rootContext} from "./di";
+
+const logger = createLogger('MarketplaceRegistry');
+
+export const TOPIC_MARKETPLACE_CHANGED = "events/marketplaceregistry/changed";
+
+export interface MarketplaceCatalog {
+    name?: string;
+    description?: string;
+    extensions?: Extension[];
+}
+
+const KEY_CATALOG_URLS = "marketplace.catalogUrls";
+
+class MarketplaceRegistry {
+    private catalogUrls: string[] = [];
+    private loadingPromises: Map<string, Promise<MarketplaceCatalog>> = new Map();
+
+    constructor() {
+        // Load catalog URLs and refresh catalogs
+        this.loadCatalogUrls().then(() => {
+            this.refreshCatalogs().catch(err => {
+                logger.error(`Failed to refresh catalogs on init: ${err.message}`);
+            });
+        });
+    }
+
+    private async loadCatalogUrls(): Promise<void> {
+        try {
+            const urls = await appSettings.get(KEY_CATALOG_URLS);
+            this.catalogUrls = Array.isArray(urls) ? urls : [];
+            logger.debug(`Loaded ${this.catalogUrls.length} catalog URLs`);
+        } catch (error) {
+            logger.error(`Failed to load catalog URLs: ${error}`);
+            this.catalogUrls = [];
+        }
+    }
+
+    private async saveCatalogUrls(): Promise<void> {
+        await appSettings.set(KEY_CATALOG_URLS, this.catalogUrls);
+        publish(TOPIC_MARKETPLACE_CHANGED, {type: 'catalogs', urls: this.catalogUrls});
+    }
+
+    async addCatalogUrl(url: string): Promise<void> {
+        if (!this.isValidUrl(url)) {
+            throw new Error(`Invalid catalog URL: ${url}`);
+        }
+
+        if (this.catalogUrls.includes(url)) {
+            logger.debug(`Catalog URL already exists: ${url}`);
+            return;
+        }
+
+        this.catalogUrls.push(url);
+        await this.saveCatalogUrls();
+        logger.info(`Added catalog URL: ${url}`);
+
+        try {
+            await this.refreshCatalogs();
+        } catch (error) {
+            logger.warn(`Failed to refresh catalogs immediately after adding: ${error}`);
+        }
+    }
+
+    async removeCatalogUrl(url: string): Promise<void> {
+        const index = this.catalogUrls.indexOf(url);
+        if (index === -1) {
+            return;
+        }
+
+        this.catalogUrls.splice(index, 1);
+        await this.saveCatalogUrls();
+        logger.info(`Removed catalog URL: ${url}`);
+    }
+
+    getCatalogUrls(): string[] {
+        return [...this.catalogUrls];
+    }
+
+    private isValidUrl(url: string): boolean {
+        try {
+            const parsed = new URL(url);
+            return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+        } catch {
+            return false;
+        }
+    }
+
+    private async fetchCatalog(url: string): Promise<MarketplaceCatalog> {
+        const existingPromise = this.loadingPromises.get(url);
+        if (existingPromise) {
+            return existingPromise;
+        }
+
+        const fetchPromise = (async () => {
+            try {
+                logger.debug(`Fetching catalog from: ${url}`);
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        'Accept': 'application/json',
+                    },
+                });
+
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+
+                const data = await response.json() as MarketplaceCatalog;
+
+                if (!data.extensions || !Array.isArray(data.extensions)) {
+                    throw new Error('Invalid catalog format: extensions array is required');
+                }
+
+                const catalog: MarketplaceCatalog = {
+                    name: data.name,
+                    description: data.description,
+                    extensions: data.extensions || [],
+                };
+
+                const extCount = catalog.extensions?.length || 0;
+                logger.debug(`Successfully fetched catalog from ${url}: ${extCount} extensions`);
+                return catalog;
+            } catch (error) {
+                logger.error(`Failed to fetch catalog from ${url}: ${error}`);
+                throw error;
+            } finally {
+                this.loadingPromises.delete(url);
+            }
+        })();
+
+        this.loadingPromises.set(url, fetchPromise);
+        return fetchPromise;
+    }
+
+    async refreshCatalogs(): Promise<void> {
+        logger.info(`Refreshing ${this.catalogUrls.length} catalogs...`);
+        
+        const promises = this.catalogUrls.map(url =>
+            this.fetchCatalog(url).catch(error => {
+                logger.warn(`Failed to refresh catalog ${url}: ${error.message}`);
+                return null;
+            })
+        );
+
+        const catalogs = await Promise.allSettled(promises);
+        
+        // Register all marketplace extensions from successfully fetched catalogs
+        // Extensions will register apps themselves when loaded
+        catalogs.forEach((result, index) => {
+            if (result.status === 'fulfilled' && result.value) {
+                const catalog = result.value;
+                
+                // Register extensions
+                if (catalog.extensions) {
+                    catalog.extensions.forEach(marketplaceExt => {
+                        // Only register if not already registered
+                        if (!extensionRegistry.getExtensions().find(e => e.id === marketplaceExt.id)) {
+                            const extension: Extension = {
+                                ...marketplaceExt,
+                                external: true
+                            };
+                            extensionRegistry.registerExtension(extension);
+                            logger.debug(`Registered marketplace extension: ${marketplaceExt.id}`);
+                        }
+                    });
+                }
+            }
+        });
+        
+        // Publish event after registration
+        publish(TOPIC_MARKETPLACE_CHANGED, {type: 'refreshed'});
+        logger.info('Catalog refresh completed');
+    }
+
+    getMarketplaceExtension(extensionId: string): Extension | undefined {
+        // Check if extension is registered in extensionRegistry and is external
+        const extension = extensionRegistry.getExtensions().find(e => e.id === extensionId);
+        if (extension && extension.external) {
+            return extension;
+        }
+        return undefined;
+    }
+
+    isMarketplaceExtension(extensionId: string): boolean {
+        const extension = extensionRegistry.getExtensions().find(e => e.id === extensionId);
+        return extension !== undefined && extension.external === true;
+    }
+}
+
+export const marketplaceRegistry = new MarketplaceRegistry();
+rootContext.put("marketplaceRegistry", marketplaceRegistry);
+

package/src/core/packageinfoservice.ts

@@ -0,0 +1,56 @@
+import { html, TemplateResult } from "lit";
+import { rootContext } from "./di";
+
+export interface PackageInfo {
+    name: string;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+
+class PackageInfoService {
+    private packages: PackageInfo[] = [];
+
+    addPackage(packageInfo: PackageInfo): void {
+        this.packages.push(packageInfo);
+    }
+
+    hasPackages(): boolean {
+        return this.packages.length > 0 && this.packages.some(pkg => 
+            pkg.dependencies && Object.keys(pkg.dependencies).length > 0
+        );
+    }
+
+    renderTree(): TemplateResult {
+        if (this.packages.length === 0) {
+            return html``;
+        }
+
+        return html`
+            <wa-tree style="--indent-guide-width: 1px;">
+                ${this.packages.map(pkg => {
+                    const deps = pkg.dependencies || {};
+                    const depEntries = Object.entries(deps);
+                    
+                    if (depEntries.length === 0) {
+                        return html``;
+                    }
+                    
+                    return html`
+                        <wa-tree-item expanded>
+                            <span>${pkg.name}</span>
+                            ${depEntries.map(([name, version]) => html`
+                                <wa-tree-item>
+                                    <span>${name} <small>${version}</small></span>
+                                </wa-tree-item>
+                            `)}
+                        </wa-tree-item>
+                    `;
+                })}
+            </wa-tree>
+        `;
+    }
+}
+
+export const packageInfoService = new PackageInfoService();
+rootContext.put("packageInfoService", packageInfoService);

package/src/core/persistenceservice.ts

@@ -0,0 +1,15 @@
+import {get, set} from 'idb-keyval';
+import {rootContext} from "./di";
+
+export class PersistenceService {
+    async persistObject(key: string, value: any) {
+        return set(key, value);
+    }
+
+    async getObject(key: string): Promise<any> {
+        return get(key)
+    }
+}
+
+export const persistenceService = new PersistenceService()
+rootContext.put("persistenceService", persistenceService)

package/src/core/settingsservice.ts

@@ -0,0 +1,70 @@
+import {publish} from "./events";
+import {persistenceService} from "./persistenceservice";
+import {rootContext} from "./di";
+
+export const SETTINGS_FILE_PATH = ".geospace/settings.json"
+
+export const DIALOG_SETTINGS_KEY = "dialogSettings"
+
+export interface AppSettings {
+    [key: string]: any;
+}
+
+export const TOPIC_SETTINGS_CHANGED = "events/settings/changed"
+
+class SettingsService {
+
+    private appSettings?: AppSettings;
+
+    private async checkSettings() {
+        if (!this.appSettings) {
+            this.appSettings = await persistenceService.getObject(SETTINGS_FILE_PATH)
+            if (!this.appSettings) {
+                this.appSettings = {}
+                await persistenceService.persistObject(SETTINGS_FILE_PATH, this.appSettings)
+            }
+            publish(TOPIC_SETTINGS_CHANGED, this.appSettings)
+        }
+    }
+
+    public async get(key: string) {
+        await this.checkSettings()
+        return this.appSettings![key]
+    }
+
+    public async set(key: string, value: any) {
+        await this.checkSettings()
+        this.appSettings![key] = value
+        await persistenceService.persistObject(SETTINGS_FILE_PATH, this.appSettings)
+        publish(TOPIC_SETTINGS_CHANGED, this.appSettings)
+    }
+
+    public async getAll() {
+        await this.checkSettings()
+        return this.appSettings!;
+    }
+
+    public async setAll(settings: AppSettings) {
+        this.appSettings = settings
+        await persistenceService.persistObject(SETTINGS_FILE_PATH, this.appSettings)
+        publish(TOPIC_SETTINGS_CHANGED, this.appSettings)
+    }
+
+    public async getDialogSetting(key: string) {
+        await this.checkSettings()
+        const dialogSettings = this.appSettings![DIALOG_SETTINGS_KEY] || {}
+        return dialogSettings[key]
+    }
+
+    public async setDialogSetting(key: string, value: any) {
+        await this.checkSettings()
+        const dialogSettings = this.appSettings![DIALOG_SETTINGS_KEY] || {}
+        dialogSettings[key] = value
+        this.appSettings![DIALOG_SETTINGS_KEY] = dialogSettings
+        await persistenceService.persistObject(SETTINGS_FILE_PATH, this.appSettings)
+        publish(TOPIC_SETTINGS_CHANGED, this.appSettings)
+    }
+}
+
+export const appSettings = new SettingsService();
+rootContext.put("appSettings", appSettings)

package/src/core/signals.ts

@@ -0,0 +1,18 @@
+import {Signal} from "@lit-labs/signals";
+
+export const watchSignal = (signal: Signal.State<any> | Signal.Computed<any>, callback: (value: any) => void): (() => void) => {
+    const watcher = new Signal.subtle.Watcher(async () => {
+        try {
+            await 0;
+            callback(signal.get());
+        } finally {
+            watcher.watch(signal);
+        }
+    });
+    watcher.watch(signal);
+    signal.get();
+    
+    return () => {
+        watcher.unwatch(signal);
+    };
+}

package/src/core/taskservice.ts

@@ -0,0 +1,72 @@
+import {activeTasksSignal} from "./appstate";
+import {rootContext} from "./di";
+
+export interface ProgressMonitor {
+    name: string
+    message: string
+    currentStep: number
+    totalSteps: number
+    progress: number  // Manual progress percentage (0-100), overrides step-based calculation if >= 0
+}
+
+export type Task = (progressMonitor: ProgressMonitor) => any
+export type AsyncTask = (progressMonitor: ProgressMonitor) => Promise<any>
+
+export class TaskService {
+    private tasks: ProgressMonitor[] = []
+    private updateCounter = 0
+
+    private notifyUpdate() {
+        // Always increment counter to ensure signal value changes and triggers re-render
+        this.updateCounter++
+        activeTasksSignal.set(this.updateCounter)
+    }
+
+    public run(name: string, task: Task) {
+        const progressMonitor = this.createProgressMonitor(name)
+        try {
+            this.tasks.push(progressMonitor)
+            this.notifyUpdate()
+            task(progressMonitor)
+        } finally {
+            this.tasks.splice(this.tasks.indexOf(progressMonitor), 1)
+            this.notifyUpdate()
+        }
+    }
+
+    public async runAsync(name: string, task: AsyncTask) {
+        const progressMonitor = this.createProgressMonitor(name)
+        this.tasks.push(progressMonitor)
+        this.notifyUpdate()
+        return task(progressMonitor).finally(() => {
+            this.tasks.splice(this.tasks.indexOf(progressMonitor), 1)
+            this.notifyUpdate()
+        })
+    }
+
+    private createProgressMonitor(name: string): ProgressMonitor {
+        const monitor = {
+            name: name,
+            message: "",
+            currentStep: 0,
+            totalSteps: -1,  // -1 indicates indefinite progress
+            progress: -1  // -1 means use step-based calculation
+        } as ProgressMonitor
+        
+        // Create a proxy to detect property changes and trigger UI updates
+        return new Proxy(monitor, {
+            set: (target, prop, value) => {
+                (target as any)[prop] = value
+                this.notifyUpdate()
+                return true
+            }
+        })
+    }
+
+    getActiveTasks() {
+        return this.tasks
+    }
+}
+
+export const taskService = new TaskService()
+rootContext.put("taskService", taskService)

package/src/core/toast.ts

@@ -0,0 +1,11 @@
+export const toastInfo = (msg: string) => {
+    console.info("[TOAST] INFO:", msg);
+}
+
+export const toastError = (msg: string) => {
+    console.error("[TOAST] ERROR:", msg);
+}
+
+export const toastWarning = (msg: string) => {
+    console.warn("[TOAST] WARNING:", msg);
+}

package/src/core/tree-utils.ts

@@ -0,0 +1,24 @@
+import {Contribution} from "./contributionregistry";
+
+export interface TreeNode {
+    data: any;
+    label: string;
+    icon?: string;
+    leaf: boolean;
+    children: TreeNode[];
+}
+
+export const treeNodeComparator = (c1: TreeNode, c2: TreeNode) => {
+    if (!c1.leaf && c2.leaf) {
+        return -1
+    }
+    if (c1.leaf && !c2.leaf) {
+        return 1
+    }
+    return c1.label.localeCompare(c2.label)
+}
+
+export interface TreeContribution extends Contribution {
+    contributionId?: string;
+    state?: { [key: string]: any }
+}