@arch-cadre/modules 0.0.49 → 0.0.50

package/dist/server/lifecycle.cjs

@@ -1,193 +1,217 @@
+"use strict";
 "use server";
 
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_manage = require('./manage.cjs');
-let _arch_cadre_core_server = require("@arch-cadre/core/server");
-let node_fs_promises = require("node:fs/promises");
-node_fs_promises = require_runtime.__toESM(node_fs_promises);
-let node_path = require("node:path");
-node_path = require_runtime.__toESM(node_path);
-let _arch_cadre_core = require("@arch-cadre/core");
-let drizzle_orm = require("drizzle-orm");
-let node_child_process = require("node:child_process");
-let node_util = require("node:util");
-
-//#region src/server/lifecycle.ts
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initOperationalModules = initOperationalModules;
+exports.pushModuleSchema = pushModuleSchema;
+exports.toggleModuleState = toggleModuleState;
+var _nodeChild_process = require("node:child_process");
+var _promises = _interopRequireDefault(require("node:fs/promises"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeUtil = require("node:util");
+var _core = require("@arch-cadre/core");
+var _server = require("@arch-cadre/core/server");
+var _drizzleOrm = require("drizzle-orm");
+var _manage = require("./manage.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 async function updateStep(moduleId, step) {
-	console.log(`[Kernel] "${moduleId}" step: ${step}`);
-	await _arch_cadre_core_server.db.update(_arch_cadre_core.systemModulesTable).set({ lastStep: step }).where((0, drizzle_orm.eq)(_arch_cadre_core.systemModulesTable.id, moduleId));
+  console.log(`[Kernel] "${moduleId}" step: ${step}`);
+  await _server.db.update(_core.systemModulesTable).set({
+    lastStep: step
+  }).where((0, _drizzleOrm.eq)(_core.systemModulesTable.id, moduleId));
 }
 async function resolveSchemaPath(moduleId) {
-	const root = process.cwd();
-	if (moduleId === "@arch-cadre/core" || moduleId === "core") {
-		const p = node_path.default.join(root, "node_modules", "@kryo", "core", "dist", "server", "database", "schema.cjs");
-		try {
-			await node_fs_promises.default.access(p);
-			return p;
-		} catch {
-			const devP = node_path.default.resolve(root, "../../packages/kryo-core/src/server/database/schema.ts");
-			try {
-				await node_fs_promises.default.access(devP);
-				return devP;
-			} catch {}
-		}
-		return null;
-	}
-	const cleanId = moduleId.replace("@arch-cadre/", "");
-	const possible = [
-		node_path.default.join(root, "modules", cleanId, "schema.ts"),
-		node_path.default.join(root, "modules", moduleId, "schema.ts"),
-		node_path.default.join(root, "node_modules", moduleId, "dist", "schema.cjs"),
-		node_path.default.join(root, "node_modules", `@arch-cadre/${cleanId}`, "dist", "schema.cjs"),
-		node_path.default.join(root, "node_modules", moduleId, "src", "schema.ts"),
-		node_path.default.join(root, "node_modules", `@arch-cadre/${cleanId}`, "src", "schema.ts"),
-		node_path.default.resolve(root, "../../packages", cleanId, "src", "schema.ts"),
-		node_path.default.resolve(root, "../../packages", `kryo-${cleanId}`, "src", "schema.ts"),
-		node_path.default.resolve(root, "../../packages", cleanId, "schema.ts")
-	];
-	for (const p of possible) try {
-		await node_fs_promises.default.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;
+  const root = process.cwd();
+  if (moduleId === "@arch-cadre/core" || moduleId === "core") {
+    const p = _nodePath.default.join(root, "node_modules", "@kryo", "core", "dist", "server", "database", "schema.cjs");
+    try {
+      await _promises.default.access(p);
+      return p;
+    } catch {
+      const devP = _nodePath.default.resolve(root, "../../packages/kryo-core/src/server/database/schema.ts");
+      try {
+        await _promises.default.access(devP);
+        return devP;
+      } catch {}
+    }
+    return null;
+  }
+  const cleanId = moduleId.replace("@arch-cadre/", "");
+  const possible = [
+  // Local module
+  _nodePath.default.join(root, "modules", cleanId, "schema.ts"), _nodePath.default.join(root, "modules", moduleId, "schema.ts"),
+  // node_modules (installed or symlinked)
+  _nodePath.default.join(root, "node_modules", moduleId, "dist", "schema.cjs"), _nodePath.default.join(root, "node_modules", `@arch-cadre/${cleanId}`, "dist", "schema.cjs"), _nodePath.default.join(root, "node_modules", moduleId, "src", "schema.ts"), _nodePath.default.join(root, "node_modules", `@arch-cadre/${cleanId}`, "src", "schema.ts"),
+  // Monorepo packages (searching by various naming conventions)
+  _nodePath.default.resolve(root, "../../packages", cleanId, "src", "schema.ts"), _nodePath.default.resolve(root, "../../packages", `kryo-${cleanId}`, "src", "schema.ts"), _nodePath.default.resolve(root, "../../packages", cleanId, "schema.ts")];
+  for (const p of possible) {
+    try {
+      await _promises.default.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;
 }
 async function pushModuleSchema(moduleId) {
-	const execAsync = (0, node_util.promisify)(node_child_process.exec);
-	console.log(`[Kernel:Lifecycle] Targeted sync for module: ${moduleId}`);
-	const root = process.cwd();
-	const enabledFromDb = await _arch_cadre_core_server.db.select({ id: _arch_cadre_core.systemModulesTable.id }).from(_arch_cadre_core.systemModulesTable).where((0, drizzle_orm.eq)(_arch_cadre_core.systemModulesTable.enabled, true));
-	const activeModuleIds = new Set(enabledFromDb.map((m) => m.id));
-	activeModuleIds.add("@arch-cadre/core");
-	activeModuleIds.add(moduleId);
-	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;
-	}
-	const configPath = node_path.default.join(root, "drizzle.config.ts");
-	const cmd = `"${node_path.default.join(root, "node_modules", ".bin", "drizzle-kit")}" 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",
-				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}`);
-	}
+  const execAsync = (0, _nodeUtil.promisify)(_nodeChild_process.exec);
+  console.log(`[Kernel:Lifecycle] Targeted sync for module: ${moduleId}`);
+  const root = process.cwd();
+  const enabledFromDb = await _server.db.select({
+    id: _core.systemModulesTable.id
+  }).from(_core.systemModulesTable).where((0, _drizzleOrm.eq)(_core.systemModulesTable.enabled, true));
+  const activeModuleIds = new Set(enabledFromDb.map(m => m.id));
+  activeModuleIds.add("@arch-cadre/core");
+  activeModuleIds.add(moduleId);
+  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;
+  }
+  const configPath = _nodePath.default.join(root, "drizzle.config.ts");
+  const drizzleKitBin = _nodePath.default.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) {
-	try {
-		const allModules = await require_manage.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);
-			if (manifest.dependencies?.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) 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 _arch_cadre_core_server.db.update(_arch_cadre_core.systemModulesTable).set({ enabled: true }).where((0, drizzle_orm.eq)(_arch_cadre_core.systemModulesTable.id, moduleId));
-			const instance = await require_manage.getModuleInstance(moduleId);
-			await updateStep(moduleId, "Migrate database...");
-			await sleep(500);
-			try {
-				if (instance?.onMigrate) await instance.onMigrate();
-				else 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?.onEnable) {
-				await updateStep(moduleId, "Running setup...");
-				await sleep(500);
-				await instance.onEnable();
-			}
-			await updateStep(moduleId, "Finishing...");
-			await sleep(500);
-			await _arch_cadre_core_server.db.update(_arch_cadre_core.systemModulesTable).set({
-				installed: true,
-				lastStep: null
-			}).where((0, drizzle_orm.eq)(_arch_cadre_core.systemModulesTable.id, moduleId));
-		} else {
-			const dependents = allModules.filter((m) => {
-				if (!m.enabled || m.id === moduleId) return false;
-				if (m.dependencies?.includes(moduleId)) return true;
-				if (m.extends?.includes(moduleId)) return m.extends.filter((targetId) => {
-					if (targetId === moduleId) return false;
-					return allModules.find((mod) => mod.id === targetId)?.enabled;
-				}).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 require_manage.getModuleInstance(moduleId);
-			if (instance?.onDisable) await instance.onDisable();
-			await _arch_cadre_core_server.db.update(_arch_cadre_core.systemModulesTable).set({
-				enabled: false,
-				installed: false
-			}).where((0, drizzle_orm.eq)(_arch_cadre_core.systemModulesTable.id, moduleId));
-			await updateStep(moduleId, null);
-		}
-	} catch (e) {
-		console.error(`[Kernel] Fatal error for ${moduleId}:`, e);
-		await updateStep(moduleId, `Error: ${e.message}`);
-	}
+  try {
+    const allModules = await (0, _manage.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);
+      if (manifest.dependencies?.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) {
+          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 _server.db.update(_core.systemModulesTable).set({
+        enabled: true
+      }).where((0, _drizzleOrm.eq)(_core.systemModulesTable.id, moduleId));
+      const instance = await (0, _manage.getModuleInstance)(moduleId);
+      await updateStep(moduleId, "Migrate database...");
+      await sleep(500);
+      try {
+        if (instance?.onMigrate) {
+          await instance.onMigrate();
+        } else {
+          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?.onEnable) {
+        await updateStep(moduleId, "Running setup...");
+        await sleep(500);
+        await instance.onEnable();
+      }
+      await updateStep(moduleId, "Finishing...");
+      await sleep(500);
+      await _server.db.update(_core.systemModulesTable).set({
+        installed: true,
+        lastStep: null
+      }).where((0, _drizzleOrm.eq)(_core.systemModulesTable.id, moduleId));
+    } else {
+      const dependents = allModules.filter(m => {
+        if (!m.enabled || m.id === moduleId) return false;
+        if (m.dependencies?.includes(moduleId)) return true;
+        if (m.extends?.includes(moduleId)) {
+          const otherActiveTargets = m.extends.filter(targetId => {
+            if (targetId === moduleId) return false;
+            const target = allModules.find(mod => mod.id === targetId);
+            return 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 (0, _manage.getModuleInstance)(moduleId);
+      if (instance?.onDisable) await instance.onDisable();
+      await _server.db.update(_core.systemModulesTable).set({
+        enabled: false,
+        installed: false
+      }).where((0, _drizzleOrm.eq)(_core.systemModulesTable.id, moduleId));
+      await updateStep(moduleId, null);
+    }
+  } catch (e) {
+    console.error(`[Kernel] Fatal error for ${moduleId}:`, e);
+    await updateStep(moduleId, `Error: ${e.message}`);
+  }
 }
 async function toggleModuleState(moduleId, isEnabled) {
-	const manifest = (await require_manage.getModules()).find((m) => m.id === moduleId);
-	if (!manifest) throw new Error(`Module "${moduleId}" not found`);
-	if (manifest.enabled === isEnabled) return { success: true };
-	performToggle(moduleId, isEnabled);
-	return { success: true };
+  const allModules = await (0, _manage.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
+  };
 }
 async function initOperationalModules() {
-	const allModules = await require_manage.getModules();
-	for (const mod of allModules) if (mod.enabled) try {
-		const instance = await require_manage.getModuleInstance(mod.id);
-		if (instance?.init) await instance.init();
-	} catch (e) {
-		console.error(`[Kernel] Failed to init module ${mod.id}:`, e);
-	}
-}
-
-//#endregion
-exports.initOperationalModules = initOperationalModules;
-exports.pushModuleSchema = pushModuleSchema;
-exports.toggleModuleState = toggleModuleState;
+  const allModules = await (0, _manage.getModules)();
+  for (const mod of allModules) {
+    if (mod.enabled) {
+      try {
+        const instance = await (0, _manage.getModuleInstance)(mod.id);
+        if (instance?.init) {
+          await instance.init();
+        }
+      } catch (e) {
+        console.error(`[Kernel] Failed to init module ${mod.id}:`, e);
+      }
+    }
+  }
+}

package/dist/server/lifecycle.d.ts

@@ -0,0 +1,5 @@
+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>;