@arch-cadre/panel 0.0.1

package/dist/actions/actions.cjs

@@ -0,0 +1,18 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logoutAction = logoutAction;
+var _server = require("@arch-cadre/core/server");
+var _server2 = require("@arch-cadre/intl/server");
+var _cache = require("next/cache");
+async function logoutAction() {
+  await (0, _server.signOut)();
+  const {
+    t
+  } = await (0, _server2.getTranslation)();
+  t("Pos");
+  (0, _cache.revalidatePath)("/", "layout");
+}

package/dist/actions/actions.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Modern Logout Action delegating to Core Auth
+ */
+export declare function logoutAction(): Promise<void>;

package/dist/actions/actions.mjs

@@ -0,0 +1,10 @@
+"use server";
+import { signOut as signOutAction } from "@arch-cadre/core/server";
+import { getTranslation } from "@arch-cadre/intl/server";
+import { revalidatePath } from "next/cache";
+export async function logoutAction() {
+  await signOutAction();
+  const { t } = await getTranslation();
+  t("Pos");
+  revalidatePath("/", "layout");
+}

package/dist/actions/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _actions = require("./actions.cjs");
+Object.keys(_actions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _actions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _actions[key];
+    }
+  });
+});
+var _settings = require("./settings.cjs");
+Object.keys(_settings).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _settings[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _settings[key];
+    }
+  });
+});

package/dist/actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./actions";
+export * from "./settings";

package/dist/actions/index.mjs

@@ -0,0 +1,2 @@
+export * from "./actions.mjs";
+export * from "./settings.mjs";

package/dist/actions/manager.cjs

@@ -0,0 +1,138 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkDiskWriteAccess = checkDiskWriteAccess;
+exports.getModuleDocumentation = getModuleDocumentation;
+exports.getModuleStatusAction = getModuleStatusAction;
+exports.getModulesAction = getModulesAction;
+exports.toggleModuleAction = toggleModuleAction;
+exports.uploadModuleAction = uploadModuleAction;
+var _promises = _interopRequireWildcard(require("node:fs/promises"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _server = require("@arch-cadre/core/server");
+var _server2 = require("@arch-cadre/modules/server");
+var _admZip = _interopRequireDefault(require("adm-zip"));
+var _cache = require("next/cache");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+async function toggleModuleAction(moduleId, isEnabled) {
+  try {
+    console.log(`[Module:ModuleManager] Toggle request for ${moduleId} -> ${isEnabled}`);
+    const result = await (0, _server2.toggleModuleState)(moduleId, isEnabled);
+    await _server.eventBus.publish("system:module:toggle", {
+      moduleId,
+      isEnabled
+    });
+    (0, _cache.revalidatePath)("/admin/modules");
+    (0, _cache.revalidatePath)("/module/module-manager");
+    return result;
+  } catch (error) {
+    console.error(`[Module:ModuleManager] Error toggling module ${moduleId}:`, error);
+    throw error;
+  }
+}
+async function uploadModuleAction(formData) {
+  try {
+    const file = formData.get("file");
+    if (!file) throw new Error("No file provided");
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const zip = new _admZip.default(buffer);
+    const zipEntries = zip.getEntries();
+    const manifestEntry = zipEntries.find(e => e.entryName.endsWith("manifest.json"));
+    if (!manifestEntry) throw new Error("ZIP must contain manifest.json");
+    const moduleRootInZip = manifestEntry.entryName.replace("manifest.json", "");
+    const manifestRaw = JSON.parse(manifestEntry.getData().toString("utf8"));
+    const manifest = _server2.ModuleManifestSchema.parse(manifestRaw);
+    const modulesDir = await (0, _server.getModulesDir)();
+    const targetDir = _nodePath.default.join(modulesDir, manifest.id);
+    try {
+      await _promises.default.access(targetDir);
+      throw new Error(`Module with ID "${manifest.id}" already exists.`);
+    } catch (e) {
+      if (e.message.includes("already exists")) throw e;
+    }
+    await _promises.default.mkdir(targetDir, {
+      recursive: true
+    });
+    for (const entry of zipEntries) {
+      if (entry.entryName.startsWith(moduleRootInZip) && !entry.isDirectory) {
+        const relativePath = entry.entryName.slice(moduleRootInZip.length);
+        const fullPath = _nodePath.default.join(targetDir, relativePath);
+        await _promises.default.mkdir(_nodePath.default.dirname(fullPath), {
+          recursive: true
+        });
+        await _promises.default.writeFile(fullPath, entry.getData());
+      }
+    }
+    await _server.db.insert(_server.systemModulesTable).values({
+      id: manifest.id,
+      enabled: false,
+      installed: false,
+      system: manifest.system ?? false
+    }).onConflictDoNothing();
+    console.log(`[Module:ModuleManager] Module "${manifest.id}" uploaded and extracted.`);
+    await _server.eventBus.publish("system:module:upload", {
+      moduleId: manifest.id,
+      manifest
+    });
+    (0, _cache.revalidatePath)("/admin/modules");
+    (0, _cache.revalidatePath)("/module/module-manager");
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error(`[Module:ModuleManager] Upload error:`, error);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+async function checkDiskWriteAccess() {
+  const modulesDir = await (0, _server.getModulesDir)();
+  try {
+    await _promises.default.access(modulesDir, _promises.constants.W_OK);
+    return {
+      canWrite: true
+    };
+  } catch (error) {
+    console.error("[Module:ModuleManager] No write access to modules directory:", error);
+    return {
+      canWrite: false
+    };
+  }
+}
+async function getModuleStatusAction(moduleId) {
+  (0, _cache.unstable_noStore)();
+  return await (0, _server2.getModuleStatus)(moduleId);
+}
+async function getModulesAction() {
+  (0, _cache.unstable_noStore)();
+  return await (0, _server2.getModules)();
+}
+async function getModuleDocumentation(moduleId) {
+  const modulesDir = await (0, _server.getModulesDir)();
+  const docsDir = _nodePath.default.join(modulesDir, moduleId, "docs");
+  try {
+    const exists = await _promises.default.access(docsDir).then(() => true).catch(() => false);
+    if (!exists) return null;
+    const files = await _promises.default.readdir(docsDir);
+    const mdFiles = files.filter(f => f.endsWith(".md"));
+    if (mdFiles.length === 0) return null;
+    const docs = await Promise.all(mdFiles.map(async file => {
+      const content = await _promises.default.readFile(_nodePath.default.join(docsDir, file), "utf-8");
+      return {
+        filename: file,
+        title: file.replace(".md", "").split("-").map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(" "),
+        content
+      };
+    }));
+    return docs;
+  } catch (_error) {
+    return null;
+  }
+}

package/dist/actions/manager.d.ts

@@ -0,0 +1,14 @@
+export declare function toggleModuleAction(moduleId: string, isEnabled: boolean): Promise<any>;
+export declare function uploadModuleAction(formData: FormData): Promise<{
+    success: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+}>;
+export declare function checkDiskWriteAccess(): Promise<{
+    canWrite: boolean;
+}>;
+export declare function getModuleStatusAction(moduleId: string): Promise<any>;
+export declare function getModulesAction(): Promise<any>;
+export declare function getModuleDocumentation(moduleId: string): Promise<any>;

package/dist/actions/manager.mjs

@@ -0,0 +1,135 @@
+"use server";
+import fs, { constants } from "node:fs/promises";
+import path from "node:path";
+import {
+  db,
+  eventBus,
+  getModulesDir,
+  systemModulesTable
+} from "@arch-cadre/core/server";
+import {
+  getModuleStatus,
+  getModules,
+  ModuleManifestSchema,
+  toggleModuleState
+} from "@arch-cadre/modules/server";
+import AdmZip from "adm-zip";
+import { revalidatePath, unstable_noStore } from "next/cache";
+export async function toggleModuleAction(moduleId, isEnabled) {
+  try {
+    console.log(
+      `[Module:ModuleManager] Toggle request for ${moduleId} -> ${isEnabled}`
+    );
+    const result = await toggleModuleState(moduleId, isEnabled);
+    await eventBus.publish("system:module:toggle", { moduleId, isEnabled });
+    revalidatePath("/admin/modules");
+    revalidatePath("/module/module-manager");
+    return result;
+  } catch (error) {
+    console.error(
+      `[Module:ModuleManager] Error toggling module ${moduleId}:`,
+      error
+    );
+    throw error;
+  }
+}
+export async function uploadModuleAction(formData) {
+  try {
+    const file = formData.get("file");
+    if (!file) throw new Error("No file provided");
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const zip = new AdmZip(buffer);
+    const zipEntries = zip.getEntries();
+    const manifestEntry = zipEntries.find(
+      (e) => e.entryName.endsWith("manifest.json")
+    );
+    if (!manifestEntry) throw new Error("ZIP must contain manifest.json");
+    const moduleRootInZip = manifestEntry.entryName.replace(
+      "manifest.json",
+      ""
+    );
+    const manifestRaw = JSON.parse(manifestEntry.getData().toString("utf8"));
+    const manifest = ModuleManifestSchema.parse(manifestRaw);
+    const modulesDir = await getModulesDir();
+    const targetDir = path.join(modulesDir, manifest.id);
+    try {
+      await fs.access(targetDir);
+      throw new Error(`Module with ID "${manifest.id}" already exists.`);
+    } catch (e) {
+      if (e.message.includes("already exists")) throw e;
+    }
+    await fs.mkdir(targetDir, { recursive: true });
+    for (const entry of zipEntries) {
+      if (entry.entryName.startsWith(moduleRootInZip) && !entry.isDirectory) {
+        const relativePath = entry.entryName.slice(moduleRootInZip.length);
+        const fullPath = path.join(targetDir, relativePath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, entry.getData());
+      }
+    }
+    await db.insert(systemModulesTable).values({
+      id: manifest.id,
+      enabled: false,
+      installed: false,
+      system: manifest.system ?? false
+    }).onConflictDoNothing();
+    console.log(
+      `[Module:ModuleManager] Module "${manifest.id}" uploaded and extracted.`
+    );
+    await eventBus.publish("system:module:upload", {
+      moduleId: manifest.id,
+      manifest
+    });
+    revalidatePath("/admin/modules");
+    revalidatePath("/module/module-manager");
+    return { success: true };
+  } catch (error) {
+    console.error(`[Module:ModuleManager] Upload error:`, error);
+    return { success: false, error: error.message };
+  }
+}
+export async function checkDiskWriteAccess() {
+  const modulesDir = await getModulesDir();
+  try {
+    await fs.access(modulesDir, constants.W_OK);
+    return { canWrite: true };
+  } catch (error) {
+    console.error(
+      "[Module:ModuleManager] No write access to modules directory:",
+      error
+    );
+    return { canWrite: false };
+  }
+}
+export async function getModuleStatusAction(moduleId) {
+  unstable_noStore();
+  return await getModuleStatus(moduleId);
+}
+export async function getModulesAction() {
+  unstable_noStore();
+  return await getModules();
+}
+export async function getModuleDocumentation(moduleId) {
+  const modulesDir = await getModulesDir();
+  const docsDir = path.join(modulesDir, moduleId, "docs");
+  try {
+    const exists = await fs.access(docsDir).then(() => true).catch(() => false);
+    if (!exists) return null;
+    const files = await fs.readdir(docsDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    if (mdFiles.length === 0) return null;
+    const docs = await Promise.all(
+      mdFiles.map(async (file) => {
+        const content = await fs.readFile(path.join(docsDir, file), "utf-8");
+        return {
+          filename: file,
+          title: file.replace(".md", "").split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" "),
+          content
+        };
+      })
+    );
+    return docs;
+  } catch (_error) {
+    return null;
+  }
+}

package/dist/actions/profile.cjs

@@ -0,0 +1,169 @@
+"use strict";
+"use server";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateEmailAction = updateEmailAction;
+exports.updatePasswordAction = updatePasswordAction;
+exports.updateProfileAction = updateProfileAction;
+var _server = require("@arch-cadre/core/server");
+var _server2 = require("@arch-cadre/intl/server");
+var _cache = require("next/cache");
+var _navigation = require("next/navigation");
+async function updatePasswordAction(_prev, formData) {
+  const {
+    t
+  } = await (0, _server2.getTranslation)();
+  const {
+    session,
+    user
+  } = await (0, _server.getCurrentSession)();
+  if (session === null || user === null) {
+    return {
+      success: false,
+      message: t("Not authenticated")
+    };
+  }
+  if (user.registered2FA && !session.two_factor_verified) {
+    return {
+      success: false,
+      message: t("Forbidden")
+    };
+  }
+  const password = formData.get("password");
+  const newPassword = formData.get("new_password");
+  if (typeof password !== "string" || typeof newPassword !== "string") {
+    return {
+      success: false,
+      message: t("Invalid or missing fields")
+    };
+  }
+  if (!(0, _server.verifyPasswordStrength)(newPassword)) {
+    return {
+      success: false,
+      message: t("Weak password")
+    };
+  }
+  const passwordHash = await (0, _server.getUserPasswordHash)(user.id);
+  if (!passwordHash) return {
+    success: false,
+    message: t("Internal error")
+  };
+  const validPassword = await (0, _server.verifyPasswordHash)(passwordHash, password);
+  if (!validPassword) {
+    return {
+      success: false,
+      message: t("Incorrect password")
+    };
+  }
+  await (0, _server.invalidateUserSessions)(user.id);
+  await (0, _server.updateUserPassword)(user.id, newPassword);
+  const sessionToken = await (0, _server.generateSessionToken)();
+  const sessionFlags = {
+    twoFactorVerified: session.two_factor_verified ?? false
+  };
+  const newSession = await (0, _server.createSession)(sessionToken, user.id, sessionFlags);
+  await (0, _server.setSessionTokenCookie)(sessionToken, newSession.expiresAt);
+  await _server.eventBus.publish("activity.create", {
+    action: "profile.updated.password",
+    description: `User ${user?.name} updated their password`,
+    userId: user?.id,
+    metadata: {}
+  }, "profile");
+  return {
+    success: true,
+    message: t("Updated password")
+  };
+}
+async function updateEmailAction(_prev, formData) {
+  const {
+    t
+  } = await (0, _server2.getTranslation)();
+  const {
+    session,
+    user
+  } = await (0, _server.getCurrentSession)();
+  if (session === null || user === null) return {
+    success: false,
+    message: t("Not authenticated")
+  };
+  if (user.registered2FA && !session.two_factor_verified) return {
+    success: false,
+    message: t("Forbidden")
+  };
+  const email = formData.get("email");
+  if (typeof email !== "string" || email === "") {
+    return {
+      success: false,
+      message: t("Please enter your email")
+    };
+  }
+  if (!(0, _server.verifyEmailInput)(email)) {
+    return {
+      success: false,
+      message: t("Please enter a valid email")
+    };
+  }
+  const emailAvailable = await (0, _server.checkEmailAvailability)(email);
+  if (!emailAvailable) {
+    return {
+      success: false,
+      message: t("This email is already used")
+    };
+  }
+  const verificationRequest = await (0, _server.createEmailVerificationRequest)(user.id, email);
+  await (0, _server.sendVerificationEmail)(verificationRequest.email, verificationRequest.code);
+  await (0, _server.setEmailVerificationRequestCookie)(verificationRequest);
+  await _server.eventBus.publish("activity.create", {
+    action: "profile.updated.email",
+    description: `User ${user?.name} updated their email`,
+    userId: user?.id,
+    metadata: {
+      email
+    }
+  }, "profile");
+  return (0, _navigation.redirect)("/verify-email");
+}
+async function updateProfileAction(name, image) {
+  const {
+    session,
+    user
+  } = await (0, _server.getCurrentSession)();
+  const {
+    t
+  } = await (0, _server2.getTranslation)();
+  if (session === null || user === null) return {
+    error: t("Not authenticated")
+  };
+  if (!name || name.trim().length === 0) return {
+    error: t("Name is required")
+  };
+  if (name.trim().length > 100) return {
+    error: t("Name is too long")
+  };
+  if (image instanceof File) {
+    const uploaded = await _server.filesystemService.upload(image, "vercel-blob");
+    if ("error" in uploaded) {
+      return {
+        error: uploaded.error
+      };
+    }
+    await (0, _server.updateUserAwatar)(user.id, uploaded.url);
+  }
+  await (0, _server.updateUserName)(user.id, name.trim());
+  (0, _cache.revalidatePath)("/profile");
+  await _server.eventBus.publish("activity.create", {
+    action: "profile.updated",
+    description: `User ${user?.name} updated their profile`,
+    userId: user?.id,
+    metadata: {
+      name,
+      imageUrl: image instanceof File ? image.name : null
+    }
+  }, "profile");
+  return {
+    success: true,
+    message: t("Profile updated successfully")
+  };
+}

package/dist/actions/profile.d.ts

@@ -0,0 +1,8 @@
+import type { ActionResult } from "../types";
+export declare function updatePasswordAction(_prev: ActionResult, formData: FormData): Promise<ActionResult>;
+export declare function updateEmailAction(_prev: ActionResult, formData: FormData): Promise<ActionResult>;
+export declare function updateProfileAction(name: string, image?: File): Promise<{
+    error?: string;
+    success?: boolean;
+    message?: string;
+}>;

package/dist/actions/profile.mjs

@@ -0,0 +1,135 @@
+"use server";
+import {
+  checkEmailAvailability,
+  createEmailVerificationRequest,
+  createSession,
+  eventBus,
+  filesystemService,
+  generateSessionToken,
+  getCurrentSession,
+  getUserPasswordHash,
+  invalidateUserSessions,
+  sendVerificationEmail,
+  setEmailVerificationRequestCookie,
+  setSessionTokenCookie,
+  updateUserAwatar,
+  updateUserName,
+  updateUserPassword,
+  verifyEmailInput,
+  verifyPasswordHash,
+  verifyPasswordStrength
+} from "@arch-cadre/core/server";
+import { getTranslation } from "@arch-cadre/intl/server";
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+export async function updatePasswordAction(_prev, formData) {
+  const { t } = await getTranslation();
+  const { session, user } = await getCurrentSession();
+  if (session === null || user === null) {
+    return { success: false, message: t("Not authenticated") };
+  }
+  if (user.registered2FA && !session.two_factor_verified) {
+    return { success: false, message: t("Forbidden") };
+  }
+  const password = formData.get("password");
+  const newPassword = formData.get("new_password");
+  if (typeof password !== "string" || typeof newPassword !== "string") {
+    return { success: false, message: t("Invalid or missing fields") };
+  }
+  if (!verifyPasswordStrength(newPassword)) {
+    return { success: false, message: t("Weak password") };
+  }
+  const passwordHash = await getUserPasswordHash(user.id);
+  if (!passwordHash) return { success: false, message: t("Internal error") };
+  const validPassword = await verifyPasswordHash(passwordHash, password);
+  if (!validPassword) {
+    return { success: false, message: t("Incorrect password") };
+  }
+  await invalidateUserSessions(user.id);
+  await updateUserPassword(user.id, newPassword);
+  const sessionToken = await generateSessionToken();
+  const sessionFlags = {
+    twoFactorVerified: session.two_factor_verified ?? false
+  };
+  const newSession = await createSession(sessionToken, user.id, sessionFlags);
+  await setSessionTokenCookie(sessionToken, newSession.expiresAt);
+  await eventBus.publish(
+    "activity.create",
+    {
+      action: "profile.updated.password",
+      description: `User ${user?.name} updated their password`,
+      userId: user?.id,
+      metadata: {}
+    },
+    "profile"
+  );
+  return { success: true, message: t("Updated password") };
+}
+export async function updateEmailAction(_prev, formData) {
+  const { t } = await getTranslation();
+  const { session, user } = await getCurrentSession();
+  if (session === null || user === null)
+    return { success: false, message: t("Not authenticated") };
+  if (user.registered2FA && !session.two_factor_verified)
+    return { success: false, message: t("Forbidden") };
+  const email = formData.get("email");
+  if (typeof email !== "string" || email === "") {
+    return { success: false, message: t("Please enter your email") };
+  }
+  if (!verifyEmailInput(email)) {
+    return { success: false, message: t("Please enter a valid email") };
+  }
+  const emailAvailable = await checkEmailAvailability(email);
+  if (!emailAvailable) {
+    return { success: false, message: t("This email is already used") };
+  }
+  const verificationRequest = await createEmailVerificationRequest(
+    user.id,
+    email
+  );
+  await sendVerificationEmail(
+    verificationRequest.email,
+    verificationRequest.code
+  );
+  await setEmailVerificationRequestCookie(verificationRequest);
+  await eventBus.publish(
+    "activity.create",
+    {
+      action: "profile.updated.email",
+      description: `User ${user?.name} updated their email`,
+      userId: user?.id,
+      metadata: { email }
+    },
+    "profile"
+  );
+  return redirect("/verify-email");
+}
+export async function updateProfileAction(name, image) {
+  const { session, user } = await getCurrentSession();
+  const { t } = await getTranslation();
+  if (session === null || user === null)
+    return { error: t("Not authenticated") };
+  if (!name || name.trim().length === 0)
+    return { error: t("Name is required") };
+  if (name.trim().length > 100) return { error: t("Name is too long") };
+  if (image instanceof File) {
+    const uploaded = await filesystemService.upload(image, "vercel-blob");
+    if ("error" in uploaded) {
+      return { error: uploaded.error };
+    }
+    await updateUserAwatar(user.id, uploaded.url);
+  }
+  await updateUserName(user.id, name.trim());
+  revalidatePath("/profile");
+  await eventBus.publish(
+    "activity.create",
+    {
+      action: "profile.updated",
+      description: `User ${user?.name} updated their profile`,
+      userId: user?.id,
+      metadata: { name, imageUrl: image instanceof File ? image.name : null }
+    },
+    "profile"
+  );
+  return { success: true, message: t("Profile updated successfully") };
+}