@madh-io/alfred-ai 0.3.0 → 0.3.1

package/bundle/index.js

@@ -4554,6 +4554,9 @@ var init_dist7 = __esm({
 });
 
 // ../core/dist/alfred.js
+import fs4 from "node:fs";
+import path4 from "node:path";
+import yaml2 from "js-yaml";
 var Alfred;
 var init_alfred = __esm({
   "../core/dist/alfred.js"() {
@@ -4588,8 +4591,10 @@ var init_alfred = __esm({
         const reminderRepo = new ReminderRepository(db);
         this.logger.info("Storage initialized");
         const ruleEngine = new RuleEngine();
+        const rules = this.loadSecurityRules();
+        ruleEngine.loadRules(rules);
         const securityManager = new SecurityManager(ruleEngine, auditRepo, this.logger.child({ component: "security" }));
-        this.logger.info("Security engine initialized");
+        this.logger.info({ ruleCount: rules.length }, "Security engine initialized");
         const llmProvider = createLLMProvider(this.config.llm);
         await llmProvider.initialize();
         this.logger.info({ provider: this.config.llm.provider, model: this.config.llm.model }, "LLM provider initialized");
@@ -4708,6 +4713,34 @@ var init_alfred = __esm({
           this.logger.warn({ platform }, "Adapter disconnected");
         });
       }
+      loadSecurityRules() {
+        const rulesPath = path4.resolve(this.config.security.rulesPath);
+        const rules = [];
+        if (!fs4.existsSync(rulesPath)) {
+          this.logger.warn({ rulesPath }, "Security rules directory not found, using default deny");
+          return rules;
+        }
+        const stat = fs4.statSync(rulesPath);
+        if (!stat.isDirectory()) {
+          this.logger.warn({ rulesPath }, "Security rules path is not a directory");
+          return rules;
+        }
+        const files = fs4.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+        for (const file of files) {
+          try {
+            const filePath = path4.join(rulesPath, file);
+            const content = fs4.readFileSync(filePath, "utf-8");
+            const parsed = yaml2.load(content);
+            if (parsed?.rules && Array.isArray(parsed.rules)) {
+              rules.push(...parsed.rules);
+              this.logger.info({ file, count: parsed.rules.length }, "Loaded security rules");
+            }
+          } catch (err) {
+            this.logger.error({ err, file }, "Failed to load security rules file");
+          }
+        }
+        return rules;
+      }
     };
   }
 });
@@ -4790,9 +4823,9 @@ __export(setup_exports, {
 });
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import fs4 from "node:fs";
-import path4 from "node:path";
-import yaml2 from "js-yaml";
+import fs5 from "node:fs";
+import path5 from "node:path";
+import yaml3 from "js-yaml";
 function green(s) {
   return `${GREEN}${s}${RESET}`;
 }
@@ -4822,20 +4855,20 @@ function loadExistingConfig(projectRoot) {
   let shellEnabled = false;
   let writeInGroups = false;
   let rateLimit = 30;
-  const configPath = path4.join(projectRoot, "config", "default.yml");
-  if (fs4.existsSync(configPath)) {
+  const configPath = path5.join(projectRoot, "config", "default.yml");
+  if (fs5.existsSync(configPath)) {
     try {
-      const parsed = yaml2.load(fs4.readFileSync(configPath, "utf-8"));
+      const parsed = yaml3.load(fs5.readFileSync(configPath, "utf-8"));
       if (parsed && typeof parsed === "object") {
         Object.assign(config, parsed);
       }
     } catch {
     }
   }
-  const envPath = path4.join(projectRoot, ".env");
-  if (fs4.existsSync(envPath)) {
+  const envPath = path5.join(projectRoot, ".env");
+  if (fs5.existsSync(envPath)) {
     try {
-      const lines = fs4.readFileSync(envPath, "utf-8").split("\n");
+      const lines = fs5.readFileSync(envPath, "utf-8").split("\n");
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#"))
@@ -4848,10 +4881,10 @@ function loadExistingConfig(projectRoot) {
     } catch {
     }
   }
-  const rulesPath = path4.join(projectRoot, "config", "rules", "default-rules.yml");
-  if (fs4.existsSync(rulesPath)) {
+  const rulesPath = path5.join(projectRoot, "config", "rules", "default-rules.yml");
+  if (fs5.existsSync(rulesPath)) {
     try {
-      const rulesContent = yaml2.load(fs4.readFileSync(rulesPath, "utf-8"));
+      const rulesContent = yaml3.load(fs5.readFileSync(rulesPath, "utf-8"));
       if (rulesContent?.rules) {
         shellEnabled = rulesContent.rules.some((r) => r.id === "allow-owner-admin" && r.effect === "allow");
         const writeDmRule = rulesContent.rules.find((r) => r.id === "allow-write-for-dm" || r.id === "allow-write-all");
@@ -5209,12 +5242,12 @@ ${bold("Writing configuration files...")}`);
       envLines.push("# ALFRED_OWNER_USER_ID=");
     }
     envLines.push("");
-    const envPath = path4.join(projectRoot, ".env");
-    fs4.writeFileSync(envPath, envLines.join("\n"), "utf-8");
+    const envPath = path5.join(projectRoot, ".env");
+    fs5.writeFileSync(envPath, envLines.join("\n"), "utf-8");
     console.log(`  ${green("+")} ${dim(".env")} written`);
-    const configDir = path4.join(projectRoot, "config");
-    if (!fs4.existsSync(configDir)) {
-      fs4.mkdirSync(configDir, { recursive: true });
+    const configDir = path5.join(projectRoot, "config");
+    if (!fs5.existsSync(configDir)) {
+      fs5.mkdirSync(configDir, { recursive: true });
     }
     const config = {
       name: botName,
@@ -5278,13 +5311,13 @@ ${bold("Writing configuration files...")}`);
     if (ownerUserId) {
       config.security.ownerUserId = ownerUserId;
     }
-    const yamlStr = "# Alfred \u2014 Configuration\n# Generated by `alfred setup`\n# Edit manually or re-run `alfred setup` to reconfigure.\n\n" + yaml2.dump(config, { lineWidth: 120, noRefs: true, sortKeys: false });
-    const configPath = path4.join(configDir, "default.yml");
-    fs4.writeFileSync(configPath, yamlStr, "utf-8");
+    const yamlStr = "# Alfred \u2014 Configuration\n# Generated by `alfred setup`\n# Edit manually or re-run `alfred setup` to reconfigure.\n\n" + yaml3.dump(config, { lineWidth: 120, noRefs: true, sortKeys: false });
+    const configPath = path5.join(configDir, "default.yml");
+    fs5.writeFileSync(configPath, yamlStr, "utf-8");
     console.log(`  ${green("+")} ${dim("config/default.yml")} written`);
-    const rulesDir = path4.join(configDir, "rules");
-    if (!fs4.existsSync(rulesDir)) {
-      fs4.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path5.join(configDir, "rules");
+    if (!fs5.existsSync(rulesDir)) {
+      fs5.mkdirSync(rulesDir, { recursive: true });
     }
     const ownerAdminRule = enableShell && ownerUserId ? `
   # Allow admin actions (shell, etc.) for the owner only
@@ -5365,12 +5398,12 @@ ${ownerAdminRule}
     actions: ["*"]
     riskLevels: [read, write, destructive, admin]
 `;
-    const rulesPath = path4.join(rulesDir, "default-rules.yml");
-    fs4.writeFileSync(rulesPath, rulesYaml, "utf-8");
+    const rulesPath = path5.join(rulesDir, "default-rules.yml");
+    fs5.writeFileSync(rulesPath, rulesYaml, "utf-8");
     console.log(`  ${green("+")} ${dim("config/rules/default-rules.yml")} written`);
-    const dataDir = path4.join(projectRoot, "data");
-    if (!fs4.existsSync(dataDir)) {
-      fs4.mkdirSync(dataDir, { recursive: true });
+    const dataDir = path5.join(projectRoot, "data");
+    if (!fs5.existsSync(dataDir)) {
+      fs5.mkdirSync(dataDir, { recursive: true });
       console.log(`  ${green("+")} ${dim("data/")} directory created`);
     }
     console.log("");
@@ -5643,9 +5676,9 @@ var rules_exports = {};
 __export(rules_exports, {
   rulesCommand: () => rulesCommand
 });
-import fs5 from "node:fs";
-import path5 from "node:path";
-import yaml3 from "js-yaml";
+import fs6 from "node:fs";
+import path6 from "node:path";
+import yaml4 from "js-yaml";
 async function rulesCommand() {
   const configLoader = new ConfigLoader();
   let config;
@@ -5655,18 +5688,18 @@ async function rulesCommand() {
     console.error("Failed to load configuration:", error.message);
     process.exit(1);
   }
-  const rulesPath = path5.resolve(config.security.rulesPath);
-  if (!fs5.existsSync(rulesPath)) {
+  const rulesPath = path6.resolve(config.security.rulesPath);
+  if (!fs6.existsSync(rulesPath)) {
     console.log(`Rules directory not found: ${rulesPath}`);
     console.log("No security rules loaded.");
     return;
   }
-  const stat = fs5.statSync(rulesPath);
+  const stat = fs6.statSync(rulesPath);
   if (!stat.isDirectory()) {
     console.error(`Rules path is not a directory: ${rulesPath}`);
     process.exit(1);
   }
-  const files = fs5.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  const files = fs6.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
   if (files.length === 0) {
     console.log(`No YAML rule files found in: ${rulesPath}`);
     return;
@@ -5675,10 +5708,10 @@ async function rulesCommand() {
   const allRules = [];
   const errors = [];
   for (const file of files) {
-    const filePath = path5.join(rulesPath, file);
+    const filePath = path6.join(rulesPath, file);
     try {
-      const raw = fs5.readFileSync(filePath, "utf-8");
-      const parsed = yaml3.load(raw);
+      const raw = fs6.readFileSync(filePath, "utf-8");
+      const parsed = yaml4.load(raw);
       const rules = ruleLoader.loadFromObject(parsed);
       allRules.push(...rules);
     } catch (error) {
@@ -5729,9 +5762,9 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import fs6 from "node:fs";
-import path6 from "node:path";
-import yaml4 from "js-yaml";
+import fs7 from "node:fs";
+import path7 from "node:path";
+import yaml5 from "js-yaml";
 async function statusCommand() {
   const configLoader = new ConfigLoader();
   let config;
@@ -5787,23 +5820,23 @@ async function statusCommand() {
   }
   console.log("");
   console.log("Storage:");
-  const dbPath = path6.resolve(config.storage.path);
-  const dbExists = fs6.existsSync(dbPath);
+  const dbPath = path7.resolve(config.storage.path);
+  const dbExists = fs7.existsSync(dbPath);
   console.log(`  Database: ${dbPath}`);
   console.log(`  Status:   ${dbExists ? "exists" : "not yet created"}`);
   console.log("");
-  const rulesPath = path6.resolve(config.security.rulesPath);
+  const rulesPath = path7.resolve(config.security.rulesPath);
   let ruleCount = 0;
   let ruleFileCount = 0;
-  if (fs6.existsSync(rulesPath) && fs6.statSync(rulesPath).isDirectory()) {
-    const files = fs6.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  if (fs7.existsSync(rulesPath) && fs7.statSync(rulesPath).isDirectory()) {
+    const files = fs7.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     ruleFileCount = files.length;
     const ruleLoader = new RuleLoader();
     for (const file of files) {
-      const filePath = path6.join(rulesPath, file);
+      const filePath = path7.join(rulesPath, file);
       try {
-        const raw = fs6.readFileSync(filePath, "utf-8");
-        const parsed = yaml4.load(raw);
+        const raw = fs7.readFileSync(filePath, "utf-8");
+        const parsed = yaml5.load(raw);
         const rules = ruleLoader.loadFromObject(parsed);
         ruleCount += rules.length;
       } catch {
@@ -5836,8 +5869,8 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import fs7 from "node:fs";
-import path7 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 async function logsCommand(tail) {
   const configLoader = new ConfigLoader();
   let config;
@@ -5847,8 +5880,8 @@ async function logsCommand(tail) {
     console.error("Failed to load configuration:", error.message);
     process.exit(1);
   }
-  const dbPath = path7.resolve(config.storage.path);
-  if (!fs7.existsSync(dbPath)) {
+  const dbPath = path8.resolve(config.storage.path);
+  if (!fs8.existsSync(dbPath)) {
     console.log(`Database not found at: ${dbPath}`);
     console.log("No audit log entries. Alfred has not been run yet, or the database path is incorrect.");
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madh-io/alfred-ai",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Alfred — Personal AI Assistant across Telegram, Discord, WhatsApp, Matrix & Signal",
   "type": "module",
   "bin": {