@arch-cadre/modules 0.0.63 → 0.0.64

package/dist/client/extension-point-client.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+interface ExtensionPointProps {
+    module: string;
+    point: string;
+    className?: string;
+    props?: any;
+    fallback?: React.ReactNode;
+}
+export declare function ExtensionPointClient({ module, point, className, props, fallback, }: ExtensionPointProps): any;
+export {};
+//# sourceMappingURL=extension-point-client.d.ts.map

package/dist/client/extension-point-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-point-client.d.ts","sourceRoot":"","sources":["../../src/client/extension-point-client.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,UAAU,mBAAmB;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,wBAAgB,oBAAoB,CAAC,EACnC,MAAM,EACN,KAAK,EACL,SAAS,EACT,KAAK,EACL,QAAQ,GACT,EAAE,mBAAmB,OAkBrB"}

package/dist/client/extension-point-client.js

@@ -0,0 +1,19 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: <> */
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { getExtensions } from "../server/ui";
+export function ExtensionPointClient({ module, point, className, props, fallback, }) {
+    const [extensions, setExtensions] = useState([]);
+    useEffect(() => {
+        getExtensions(module, point).then(setExtensions);
+    }, [module, point]);
+    if (extensions.length === 0)
+        return fallback || null;
+    return (_jsx("div", { className: className, children: extensions.map((ext) => {
+            const Component = ext.component;
+            if (!Component)
+                return null;
+            return _jsx(Component, { ...props }, ext.id);
+        }) }));
+}

package/dist/client/extension-point.d.ts

@@ -0,0 +1,10 @@
+interface ExtensionPointProps {
+    module: string;
+    point: string;
+    className?: string;
+    props?: any;
+    fallback?: React.ReactNode;
+}
+export declare function ExtensionPoint({ module, point, className, props, fallback, }: ExtensionPointProps): Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined>;
+export {};
+//# sourceMappingURL=extension-point.d.ts.map

package/dist/client/extension-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-point.d.ts","sourceRoot":"","sources":["../../src/client/extension-point.tsx"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,wBAAsB,cAAc,CAAC,EACnC,MAAM,EACN,KAAK,EACL,SAAS,EACT,KAAK,EACL,QAAQ,GACT,EAAE,mBAAmB,kJAarB"}

package/dist/client/extension-point.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// import * as React from "react";
+import { getExtensions } from "../server/ui";
+export async function ExtensionPoint({ module, point, className, props, fallback, }) {
+    const extensions = await getExtensions(module, point);
+    if (extensions.length === 0)
+        return fallback || null;
+    return (_jsx("div", { className: className, children: extensions.map((ext) => {
+            const Component = ext.component;
+            return _jsx(Component, { ...props }, ext.id);
+        }) }));
+}

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./extension-point";
+export * from "./extension-point-client";
+export * from "./widget-area";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,eAAe,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,3 @@
+export * from "./extension-point";
+export * from "./extension-point-client";
+export * from "./widget-area";

package/dist/client/widget-area.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface WidgetAreaProps {
+    area: string;
+    className?: string;
+    fallback?: React.ReactNode;
+    props?: any;
+}
+export declare function WidgetArea({ area, className, fallback, props, }: WidgetAreaProps): Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined>;
+export {};
+//# sourceMappingURL=widget-area.d.ts.map

package/dist/client/widget-area.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-area.d.ts","sourceRoot":"","sources":["../../src/client/widget-area.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAE3B,KAAK,CAAC,EAAE,GAAG,CAAC;CACb;AAED,wBAAsB,UAAU,CAAC,EAC/B,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,KAAK,GACN,EAAE,eAAe,wIAejB"}

package/dist/client/widget-area.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getModuleWidgets } from "../server/ui";
+export async function WidgetArea({ area, className, fallback, props, }) {
+    const widgets = await getModuleWidgets(area);
+    if (widgets.length === 0) {
+        return fallback || null;
+    }
+    return (_jsx("div", { className: className, children: widgets.map((widget) => {
+            const Component = widget.component;
+            return _jsx(Component, { ...props }, widget.id);
+        }) }));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { ExtensionPoint } from "./client/extension-point";
+export { ExtensionPointClient } from "./client/extension-point-client";
+export { WidgetArea } from "./client/widget-area";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIlD,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { ExtensionPoint } from "./client/extension-point";
+export { ExtensionPointClient } from "./client/extension-point-client";
+export { WidgetArea } from "./client/widget-area";
+// Shared Constants & Models (Safe for Browser)
+// export * from "./server/ui";
+export * from "./types";

package/dist/server/lifecycle.d.ts

@@ -0,0 +1,6 @@
+export declare function pushModuleSchema(moduleId: string): Promise<void>;
+export declare function toggleModuleState(moduleId: string, isEnabled: boolean): Promise<{
+    success: boolean;
+}>;
+export declare function initOperationalModules(): Promise<void>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/server/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/server/lifecycle.ts"],"names":[],"mappings":"AA4GA,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,iBA6DtD;AA2HD,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO;;GAS3E;AAED,wBAAsB,sBAAsB,kBAc3C"}

package/dist/server/lifecycle.js

@@ -0,0 +1,250 @@
+"use server";
+import { exec } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { systemModulesTable } from "@arch-cadre/core";
+import { db } from "@arch-cadre/core/server";
+import { eq } from "drizzle-orm";
+import { getModuleInstance, getModules } from "./manage";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function updateStep(moduleId, step) {
+    console.log(`[Kernel] "${moduleId}" step: ${step}`);
+    await db
+        .update(systemModulesTable)
+        .set({ lastStep: step })
+        .where(eq(systemModulesTable.id, moduleId));
+}
+async function resolveSchemaPath(moduleId) {
+    // const path = await import("node:path");
+    // const fs = await import("node:fs/promises");
+    const root = process.cwd();
+    // 1. Special case for core
+    if (moduleId === "@arch-cadre/core" || moduleId === "core") {
+        const p = path.join(root, "node_modules", "@kryo", "core", "dist", "server", "database", "schema.cjs");
+        try {
+            await fs.access(p);
+            return p;
+        }
+        catch {
+            // Monorepo dev fallback
+            const devP = path.resolve(root, "../../packages/kryo-core/src/server/database/schema.ts");
+            try {
+                await fs.access(devP);
+                return devP;
+            }
+            catch { }
+        }
+        return null;
+    }
+    // Normalize moduleId (remove @arch-cadre/ prefix if present for directory searching)
+    const cleanId = moduleId.replace("@arch-cadre/", "");
+    const possible = [
+        // Local module
+        path.join(root, "modules", cleanId, "schema.ts"),
+        path.join(root, "modules", moduleId, "schema.ts"),
+        // node_modules (installed or symlinked)
+        path.join(root, "node_modules", moduleId, "dist", "schema.cjs"),
+        path.join(root, "node_modules", `@arch-cadre/${cleanId}`, "dist", "schema.cjs"),
+        path.join(root, "node_modules", moduleId, "src", "schema.ts"),
+        path.join(root, "node_modules", `@arch-cadre/${cleanId}`, "src", "schema.ts"),
+        // Monorepo packages (searching by various naming conventions)
+        path.resolve(root, "../../packages", cleanId, "src", "schema.ts"),
+        path.resolve(root, "../../packages", `kryo-${cleanId}`, "src", "schema.ts"),
+        path.resolve(root, "../../packages", cleanId, "schema.ts"),
+    ];
+    for (const p of possible) {
+        try {
+            await fs.access(p);
+            console.log(`[Kernel:Lifecycle] Resolved schema for ${moduleId} at: ${p}`);
+            return p;
+        }
+        catch {
+            console.warn(`[Kernel:Lifecycle] Unresolved schema for ${moduleId} at: ${p}`);
+        }
+    }
+    console.warn(`[Kernel:Lifecycle] Could not resolve schema path for: ${moduleId}`);
+    return null;
+}
+export async function pushModuleSchema(moduleId) {
+    const execAsync = promisify(exec);
+    console.log(`[Kernel:Lifecycle] Targeted sync for module: ${moduleId}`);
+    const root = process.cwd();
+    // 1. Get all currently enabled modules to avoid dropping their tables
+    const enabledFromDb = await db
+        .select({ id: systemModulesTable.id })
+        .from(systemModulesTable)
+        .where(eq(systemModulesTable.enabled, true));
+    const activeModuleIds = new Set(enabledFromDb.map((m) => m.id));
+    activeModuleIds.add("@arch-cadre/core");
+    activeModuleIds.add(moduleId);
+    // 2. Resolve physical paths for all active schemas
+    const schemaPaths = [];
+    for (const id of Array.from(activeModuleIds)) {
+        const p = await resolveSchemaPath(id);
+        if (p)
+            schemaPaths.push(p);
+    }
+    if (schemaPaths.length === 0) {
+        console.warn(`[Kernel:Lifecycle] No schema paths resolved for ${moduleId}, skipping push.`);
+        return;
+    }
+    // 3. Prepare command
+    const configPath = path.join(root, "drizzle.config.ts");
+    const drizzleKitBin = path.join(root, "node_modules", ".bin", "drizzle-kit");
+    const cmd = `"${drizzleKitBin}" push --force --config=${configPath}`;
+    console.log(`[Kernel:Lifecycle] Executing isolated migration. Modules: ${Array.from(activeModuleIds).join(", ")}`);
+    try {
+        await execAsync(cmd, {
+            env: {
+                ...process.env,
+                CI: "true",
+                // Pass the calculated schemas to our dynamic drizzle.config.ts
+                DRIZZLE_SCHEMA_OVERRIDE: schemaPaths.join(","),
+            },
+            cwd: root,
+        });
+        console.log(`[Kernel:Lifecycle] Isolated migration successful for ${moduleId}`);
+    }
+    catch (e) {
+        console.error(`[Kernel:Lifecycle] Isolated migration failed for ${moduleId}:`);
+        console.error(e.stdout || e.message);
+        throw new Error(`Migration failed: ${moduleId}`);
+    }
+}
+async function performToggle(moduleId, isEnabled) {
+    var _a;
+    try {
+        const allModules = await getModules();
+        const manifest = allModules.find((m) => m.id === moduleId);
+        await updateStep(moduleId, "Validate module...");
+        await sleep(500);
+        if (!manifest)
+            return;
+        if (isEnabled) {
+            await updateStep(moduleId, "Queued...");
+            await sleep(500);
+            /*
+             * 1. Check dependencies
+             * 2. Enable module in DB (but not marked as installed yet)
+             * 3. Run onMigrate (or default push) to sync DB
+             * 4. Run onEnable
+             * 5. Mark as installed
+             */
+            if ((_a = manifest.dependencies) === null || _a === void 0 ? void 0 : _a.length) {
+                const pendingDeps = manifest.dependencies.filter((depId) => {
+                    const dep = allModules.find((m) => m.id === depId);
+                    return dep && !dep.enabled && !dep.system;
+                });
+                if (pendingDeps.length > 0) {
+                    // await updateStep(moduleId, "Waiting for dependencies...");
+                    for (const depId of pendingDeps) {
+                        await updateStep(moduleId, `Waiting for dependency "${depId}"...`);
+                        await performToggle(depId, true);
+                        await sleep(500);
+                    }
+                }
+            }
+            await updateStep(moduleId, "Initializing...");
+            await sleep(500);
+            await db
+                .update(systemModulesTable)
+                .set({ enabled: true })
+                .where(eq(systemModulesTable.id, moduleId));
+            const instance = await getModuleInstance(moduleId);
+            await updateStep(moduleId, "Migrate database...");
+            await sleep(500);
+            try {
+                if (instance === null || instance === void 0 ? void 0 : instance.onMigrate) {
+                    await instance.onMigrate();
+                }
+                else {
+                    // Fallback to default push if no hook provided but schema might exist
+                    await pushModuleSchema(moduleId);
+                }
+                await updateStep(moduleId, "Migration successful");
+            }
+            catch (e) {
+                console.error(`[Kernel] Migration failed for ${moduleId}:`, e);
+                await updateStep(moduleId, `Migration failed: ${e.message}`);
+                await sleep(500);
+            }
+            if (instance === null || instance === void 0 ? void 0 : instance.onEnable) {
+                await updateStep(moduleId, "Running setup...");
+                await sleep(500);
+                await instance.onEnable();
+            }
+            await updateStep(moduleId, "Finishing...");
+            await sleep(500);
+            await db
+                .update(systemModulesTable)
+                .set({ installed: true, lastStep: null })
+                .where(eq(systemModulesTable.id, moduleId));
+        }
+        else {
+            const dependents = allModules.filter((m) => {
+                var _a, _b;
+                if (!m.enabled || m.id === moduleId)
+                    return false;
+                if ((_a = m.dependencies) === null || _a === void 0 ? void 0 : _a.includes(moduleId))
+                    return true;
+                if ((_b = m.extends) === null || _b === void 0 ? void 0 : _b.includes(moduleId)) {
+                    const otherActiveTargets = m.extends.filter((targetId) => {
+                        if (targetId === moduleId)
+                            return false;
+                        const target = allModules.find((mod) => mod.id === targetId);
+                        return target === null || target === void 0 ? void 0 : target.enabled;
+                    });
+                    return otherActiveTargets.length === 0;
+                }
+                return false;
+            });
+            if (dependents.length > 0) {
+                await updateStep(moduleId, `Deactivating dependents...`);
+                for (const dep of dependents) {
+                    await performToggle(dep.id, false);
+                    await sleep(500);
+                }
+            }
+            await updateStep(moduleId, "Deactivating...");
+            const instance = await getModuleInstance(moduleId);
+            if (instance === null || instance === void 0 ? void 0 : instance.onDisable)
+                await instance.onDisable();
+            await db
+                .update(systemModulesTable)
+                .set({ enabled: false, installed: false })
+                .where(eq(systemModulesTable.id, moduleId));
+            await updateStep(moduleId, null);
+        }
+    }
+    catch (e) {
+        console.error(`[Kernel] Fatal error for ${moduleId}:`, e);
+        await updateStep(moduleId, `Error: ${e.message}`);
+    }
+}
+export async function toggleModuleState(moduleId, isEnabled) {
+    const allModules = await getModules();
+    const manifest = allModules.find((m) => m.id === moduleId);
+    if (!manifest)
+        throw new Error(`Module "${moduleId}" not found`);
+    if (manifest.enabled === isEnabled)
+        return { success: true };
+    void performToggle(moduleId, isEnabled);
+    return { success: true };
+}
+export async function initOperationalModules() {
+    const allModules = await getModules();
+    for (const mod of allModules) {
+        if (mod.enabled) {
+            try {
+                const instance = await getModuleInstance(mod.id);
+                if (instance === null || instance === void 0 ? void 0 : instance.init) {
+                    await instance.init();
+                }
+            }
+            catch (e) {
+                console.error(`[Kernel] Failed to init module ${mod.id}:`, e);
+            }
+        }
+    }
+}

package/dist/server/manage.d.ts

@@ -0,0 +1,27 @@
+import { type IModule } from "../types";
+export declare function registerModules(modules: IModule[]): Promise<void>;
+export declare function getModules(): Promise<{
+    enabled: boolean;
+    installed: boolean;
+    lastStep: string | null | undefined;
+    hasDocs: boolean;
+    id: string;
+    name: string;
+    version: string;
+    dependencies: string[];
+    extends: string[];
+    system: boolean;
+    description?: string | undefined;
+    npmDependencies?: string[] | undefined;
+    npmDevDependencies?: string[] | undefined;
+}[]>;
+export declare function getModuleStatus(moduleId: string): Promise<{
+    enabled: boolean;
+    installed: boolean;
+    lastStep: string | null;
+}>;
+export declare function isModuleEnabled(moduleId: string): Promise<boolean>;
+export declare function getModuleInstance(moduleId: string): Promise<IModule | null>;
+export declare function getModuleConfig<T>(moduleId: string): Promise<T | null>;
+export declare function updateModuleConfig(moduleId: string, config: any): Promise<void>;
+//# sourceMappingURL=manage.d.ts.map

package/dist/server/manage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage.d.ts","sourceRoot":"","sources":["../../src/server/manage.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,OAAO,EAAwB,MAAM,UAAU,CAAC;AAQ9D,wBAAsB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,iBAOvD;AAED,wBAAsB,UAAU;;;;;;;;;;;;;;KAiD/B;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM;;;;GAerD;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUxE;AAED,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CA2CzB;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAW5E;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,iBASrE"}

package/dist/server/manage.js

@@ -0,0 +1,143 @@
+"use server";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { systemModulesTable } from "@arch-cadre/core";
+import { db, getModulesDir } from "@arch-cadre/core/server";
+import { eq } from "drizzle-orm";
+import { ModuleManifestSchema } from "../types";
+const globalForModules = globalThis;
+if (!globalForModules.__KRYO_REGISTERED_MODULES__) {
+    globalForModules.__KRYO_REGISTERED_MODULES__ = new Map();
+}
+export async function registerModules(modules) {
+    var _a;
+    const store = globalForModules.__KRYO_REGISTERED_MODULES__;
+    for (const mod of modules) {
+        if ((_a = mod.manifest) === null || _a === void 0 ? void 0 : _a.id) {
+            store.set(mod.manifest.id, mod);
+        }
+    }
+}
+export async function getModules() {
+    try {
+        const modulesDir = await getModulesDir();
+        const manifests = [];
+        const entries = await fs.readdir(modulesDir).catch(() => []);
+        for (const dir of entries) {
+            if (dir.startsWith("."))
+                continue;
+            try {
+                const content = await fs.readFile(path.join(modulesDir, dir, "manifeston"), "utf-8");
+                const manifest = ModuleManifestSchema.parse(JSON.parse(content));
+                manifests.push({ ...manifest, hasDocs: false });
+            }
+            catch { }
+        }
+        const store = globalForModules.__KRYO_REGISTERED_MODULES__;
+        for (const mod of store.values()) {
+            if (!manifests.some((m) => m.id === mod.manifest.id)) {
+                manifests.push({ ...mod.manifest, hasDocs: false });
+            }
+        }
+        const dbModules = await db
+            .select()
+            .from(systemModulesTable)
+            .catch(() => []);
+        const dbMap = new Map(dbModules.map((m) => [m.id, m]));
+        return manifests.map((mod) => {
+            var _a, _b;
+            const dbEntry = dbMap.get(mod.id);
+            return {
+                ...mod,
+                enabled: mod.system ? true : ((_a = dbEntry === null || dbEntry === void 0 ? void 0 : dbEntry.enabled) !== null && _a !== void 0 ? _a : false),
+                installed: mod.system ? true : ((_b = dbEntry === null || dbEntry === void 0 ? void 0 : dbEntry.installed) !== null && _b !== void 0 ? _b : false),
+                lastStep: dbEntry === null || dbEntry === void 0 ? void 0 : dbEntry.lastStep,
+                hasDocs: mod.hasDocs,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export async function getModuleStatus(moduleId) {
+    try {
+        const [mod] = await db
+            .select()
+            .from(systemModulesTable)
+            .where(eq(systemModulesTable.id, moduleId));
+        return {
+            enabled: mod === null || mod === void 0 ? void 0 : mod.enabled,
+            installed: mod === null || mod === void 0 ? void 0 : mod.installed,
+            lastStep: mod === null || mod === void 0 ? void 0 : mod.lastStep,
+        };
+    }
+    catch {
+        return { enabled: false, installed: false, lastStep: null };
+    }
+}
+export async function isModuleEnabled(moduleId) {
+    try {
+        const [mod] = await db
+            .select()
+            .from(systemModulesTable)
+            .where(eq(systemModulesTable.id, moduleId));
+        return !!(mod === null || mod === void 0 ? void 0 : mod.enabled) || !!(mod === null || mod === void 0 ? void 0 : mod.system);
+    }
+    catch {
+        return false;
+    }
+}
+export async function getModuleInstance(moduleId) {
+    try {
+        const store = globalForModules.__KRYO_REGISTERED_MODULES__;
+        // 1. Check if module is already registered in the global store
+        if (store.has(moduleId)) {
+            console.log(`[Kernel:Manage] Module "${moduleId}" found in registry.`);
+            return store.get(moduleId) || null;
+        }
+        console.log(`[Kernel:Manage] Module "${moduleId}" not in registry. Registry size: ${store.size}. Keys: ${Array.from(store.keys()).join(", ")}`);
+        // 2. Try to load as an NPM package (for modules installed via npm/pnpm)
+        // We only try this if it doesn't look like a local module path
+        if (!moduleId.startsWith(".") && !moduleId.startsWith("/")) {
+            try {
+                const mod = await import(`@arch-cadre/${moduleId}`);
+                console.log(`[Kernel:Manage] Module "${moduleId}" loaded via import().`);
+                return mod.default || mod || null;
+            }
+            catch (e) {
+                console.warn(`[Kernel:Manage] Failed to import module "${moduleId} via import().": ${e.message}`);
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        console.error(`[Kernel:Manage] Error in getModuleInstance for "${moduleId}":`, error);
+        return null;
+    }
+}
+export async function getModuleConfig(moduleId) {
+    try {
+        const [mod] = await db
+            .select({ config: systemModulesTable.config })
+            .from(systemModulesTable)
+            .where(eq(systemModulesTable.id, moduleId));
+        if (!(mod === null || mod === void 0 ? void 0 : mod.config))
+            return null;
+        return JSON.parse(mod.config);
+    }
+    catch {
+        return null;
+    }
+}
+export async function updateModuleConfig(moduleId, config) {
+    try {
+        await db
+            .update(systemModulesTable)
+            .set({ config: JSON.stringify(config) })
+            .where(eq(systemModulesTable.id, moduleId));
+    }
+    catch (e) {
+        console.warn(`[Kernel:Manage] Failed to update config for ${moduleId}:`, e);
+    }
+}

package/dist/server/registry.d.ts

@@ -0,0 +1,2 @@
+export declare function initModules(force?: boolean): Promise<void>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/server/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/server/registry.ts"],"names":[],"mappings":"AAWA,wBAAsB,WAAW,CAAC,KAAK,UAAQ,iBAwI9C"}