pacs-core 0.1.0

package/src/cli.js

@@ -0,0 +1,384 @@
+/**
+ * PACS Core — CLI Tool
+ * Command-line interface for PACS operations
+ *
+ * Usage:
+ *   node src/cli.js <command> [args]
+ */
+
+const { readFileSync } = require('fs');
+
+// --- Argument parsing (no external libs) ---
+
+const argv = process.argv.slice(2);
+
+function flag(name) {
+  const idx = argv.findIndex((a) => a === `--${name}` || a === `-${name[0]}`);
+  if (idx === -1) return null;
+  return argv[idx + 1] !== undefined && !argv[idx + 1].startsWith('-')
+    ? argv.splice(idx + 1, 1)[0]
+    : true;
+}
+
+function boolFlag(name) {
+  return argv.includes(`--${name}`) || argv.includes(`-${name[0]}`);
+}
+
+function positional(index) {
+  return argv[index];
+}
+
+function cmd(first, second) {
+  return argv[0] === first && (second === undefined || argv[1] === second);
+}
+
+// --- Output helpers ---
+
+function info(msg) {
+  console.log(msg);
+}
+
+function error(msg) {
+  console.error(`[ERROR] ${msg}`);
+  process.exit(1);
+}
+
+function success(msg) {
+  console.log(msg);
+}
+
+// --- Lazy-loaded modules (CJS) ---
+
+function getAgentRegistry() {
+  return require('./agent-registry.js').default;
+}
+
+function getMemoryStore() {
+  return require('./memory-store.js');
+}
+
+function getLearnMode() {
+  return require('./learn-mode.js').default;
+}
+
+function getBridgeStatus() {
+  try {
+    return require('./openclaw-bridge.cjs').status;
+  } catch {
+    return () => ({ initialized: false, mode: 'unknown', enabled: false, openClawConnected: false });
+  }
+}
+
+// --- Commands ---
+
+function showHelp() {
+  console.log(`
+PACS — Personal AI Control System
+==================================
+
+Usage: pacs <command> [options]
+
+Commands:
+  pacs --help
+    Show this help text.
+
+  pacs init
+    Initialize PACS storage directory.
+
+  pacs status
+    Show PACS status (bridge, mode, agents count, memory facts).
+
+  pacs agents list
+    List all registered agents.
+
+  pacs agents add <name> [--text "..."] [--md ./file.md]
+    Register a new agent. Use --text or --md for description.
+
+  pacs agents remove <name>
+    Remove an agent by name.
+
+  pacs agents get <name>
+    Show details for a specific agent.
+
+  pacs memory list
+    List all memory facts.
+
+  pacs memory search <query>
+    Search memory facts for a query string.
+
+  pacs memory add "<fact>"
+    Add a new memory fact.
+
+  pacs memory forget "<fact>"
+    Remove a memory fact by content match.
+
+  pacs learn-mode get
+    Show the current learn mode (safe | explicit | auto).
+
+  pacs learn-mode set <mode>
+    Set learn mode to safe, explicit, or auto.
+
+  pacs messages <agent>
+    Show message history for an agent.
+
+Examples:
+  pacs agents add finbot --text "Finance agent"
+  pacs memory add "Lech prefers German in the morning"
+  pacs memory search "preferences"
+  pacs learn-mode set explicit
+`);
+}
+
+// -- init --
+
+function handleInit() {
+  const ms = getMemoryStore();
+  ms.ensureStorageDir();
+  info('PACS initialisiert. Storage: ~/.openclaw/pacs/');
+  info('Hinweis: PACS_ENCRYPTION_KEY muss in der Umgebung gesetzt sein.');
+  success('✓ Init abgeschlossen.');
+}
+
+// -- status --
+
+function handleStatus() {
+  const bridge = getBridgeStatus()();
+  let agentCount = '?';
+  let factCount = '?';
+
+  try {
+    const registry = getAgentRegistry();
+    agentCount = registry.listAgents().length;
+  } catch {
+    agentCount = 'Fehler (falscher Key?)';
+  }
+
+  try {
+    const ms = getMemoryStore();
+    const memory = ms.readMemory() || {};
+    factCount = memory.facts ? memory.facts.length : 0;
+  } catch {
+    factCount = 'Fehler (falscher Key?)';
+  }
+
+  info('=== PACS Status ===');
+  info(`Bridge initialisiert : ${bridge.initialized ? 'ja' : 'nein'}`);
+  info(`Bridge Mode          : ${bridge.mode}`);
+  info(`Bridge aktiviert     : ${bridge.enabled ? 'ja' : 'nein'}`);
+  info(`OpenClaw verbunden    : ${bridge.openClawConnected ? 'ja' : 'nein'}`);
+  info(`Agenten registriert  : ${agentCount}`);
+  info(`Memory Facts         : ${factCount}`);
+  success('✓ Status abgerufen.');
+}
+
+// -- agents --
+
+function handleAgents() {
+  const registry = getAgentRegistry();
+  const sub = positional(1);
+
+  if (cmd('list') || sub === 'list') {
+    const agents = registry.listAgents();
+    if (agents.length === 0) {
+      info('Keine Agenten registriert.');
+      return;
+    }
+    info(`=== Agenten (${agents.length}) ===`);
+    for (const a of agents) {
+      info(`  ${String(a.name).padEnd(20)} ${String(a.domain).padEnd(15)} ${a.status}`);
+    }
+    return;
+  }
+
+  if (sub === 'add') {
+    const name = positional(2);
+    if (!name) error('Usage: pacs agents add <name> [--text "..."] [--md ./file.md]');
+
+    let description = flag('text') || '';
+    const mdFile = flag('md');
+    if (mdFile) {
+      try {
+        description = readFileSync(mdFile, 'utf8').slice(0, 500);
+      } catch {
+        error(`Datei nicht gefunden: ${mdFile}`);
+      }
+    }
+
+    const agent = registry.registerAgent(name, { description });
+    success(`✓ Agent "${agent.name}" registriert (ID: ${agent.id})`);
+    return;
+  }
+
+  if (sub === 'remove') {
+    const name = positional(2);
+    if (!name) error('Usage: pacs agents remove <name>');
+    const removed = registry.removeAgent(name);
+    if (removed) {
+      success(`✓ Agent "${name}" entfernt.`);
+    } else {
+      error(`Agent "${name}" nicht gefunden.`);
+    }
+    return;
+  }
+
+  if (sub === 'get') {
+    const name = positional(2);
+    if (!name) error('Usage: pacs agents get <name>');
+    const agent = registry.getAgent(name);
+    if (!agent) error(`Agent "${name}" nicht gefunden.`);
+    info(`=== Agent: ${agent.name} ===`);
+    info(`  ID          : ${agent.id}`);
+    info(`  Domain      : ${agent.domain}`);
+    info(`  Status      : ${agent.status}`);
+    info(`  Capabilities: ${(agent.capabilities || []).join(', ') || '(none)'}`);
+    info(`  Created     : ${agent.createdAt}`);
+    info(`  Last Active : ${agent.lastActive}`);
+    info(`  Description : ${agent.description}`);
+    return;
+  }
+
+  error(`Unknown agents subcommand: ${sub}. Use: list, add, remove, get`);
+}
+
+// -- memory --
+
+function handleMemory() {
+  const ms = getMemoryStore();
+  const sub = positional(1);
+
+  if (sub === 'list') {
+    const mem = ms.readMemory() || { facts: [] };
+    const facts = mem.facts || [];
+    if (facts.length === 0) {
+      info('Keine Memory Facts gespeichert.');
+      return;
+    }
+    info(`=== Memory (${facts.length}) ===`);
+    for (const fact of facts) {
+      info(`  • ${fact}`);
+    }
+    return;
+  }
+
+  if (sub === 'search') {
+    const query = argv.slice(2).join(' ').replace(/^(search|list)\s*/i, '');
+    if (!query) error('Usage: pacs memory search <query>');
+    const results = ms.searchFacts(query);
+    if (results.length === 0) {
+      info(`Keine Ergebnisse für "${query}".`);
+      return;
+    }
+    info(`=== Suchergebnisse für "${query}" (${results.length}) ===`);
+    for (const r of results) info(`  • ${r}`);
+    return;
+  }
+
+  if (sub === 'add') {
+    const fact = argv.slice(2).join(' ').replace(/^(add)\s*/i, '');
+    if (!fact) error('Usage: pacs memory add "<fact>"');
+    ms.addFact(fact);
+    success(`✓ Fact gespeichert: "${fact}"`);
+    return;
+  }
+
+  if (sub === 'forget') {
+    const fact = argv.slice(2).join(' ').replace(/^(forget)\s*/i, '');
+    if (!fact) error('Usage: pacs memory forget "<fact>"');
+    ms.removeFact(fact);
+    success(`✓ Fact entfernt.`);
+    return;
+  }
+
+  error(`Unknown memory subcommand: ${sub}. Use: list, search, add, forget`);
+}
+
+// -- learn-mode --
+
+function handleLearnMode() {
+  const lm = getLearnMode();
+  const sub = positional(1);
+
+  if (sub === 'get' || !sub) {
+    success(`Learn-Mode: ${lm.getMode()}`);
+    return;
+  }
+
+  if (sub === 'set') {
+    const newMode = positional(2);
+    if (!newMode) error('Usage: pacs learn-mode set <safe|explicit|auto>');
+    const valid = ['safe', 'explicit', 'auto'];
+    if (!valid.includes(newMode.toLowerCase())) {
+      error(`Ungültiger Modus: ${newMode}. Gültig: ${valid.join(', ')}`);
+    }
+    lm.setMode(newMode.toLowerCase());
+    success(`✓ Learn-Mode gesetzt auf: ${newMode.toLowerCase()}`);
+    return;
+  }
+
+  error(`Unknown learn-mode subcommand: ${sub}. Use: get, set`);
+}
+
+// -- messages --
+
+function handleMessages() {
+  const registry = getAgentRegistry();
+  const agentName = positional(1);
+  if (!agentName) error('Usage: pacs messages <agent>');
+  const agent = registry.getAgent(agentName);
+  if (!agent) error(`Agent "${agentName}" nicht gefunden.`);
+
+  const messages = agent.metadata && agent.metadata.messages ? agent.metadata.messages : [];
+  if (messages.length === 0) {
+    info(`Keine Nachrichten für Agent "${agentName}".`);
+    return;
+  }
+  info(`=== Nachrichten für ${agentName} (${messages.length}) ===`);
+  for (const m of messages) {
+    info(`  [${m.role}] ${m.text}`);
+  }
+}
+
+// --- Main router ---
+
+function main() {
+  const first = argv[0];
+
+  if (!first || first === '--help' || first === '-h' || first === 'help') {
+    showHelp();
+    return;
+  }
+
+  if (cmd('init')) {
+    handleInit();
+    return;
+  }
+
+  if (cmd('status')) {
+    handleStatus();
+    return;
+  }
+
+  if (cmd('agents')) {
+    handleAgents();
+    return;
+  }
+
+  if (cmd('memory')) {
+    handleMemory();
+    return;
+  }
+
+  if (cmd('learn-mode')) {
+    handleLearnMode();
+    return;
+  }
+
+  if (cmd('messages')) {
+    handleMessages();
+    return;
+  }
+
+  error(`Unknown command: ${first}. Run "pacs --help" for usage.`);
+}
+
+main();

package/src/crypto.js

@@ -0,0 +1,118 @@
+/**
+ * PACS Core — Cryptography Module
+ * AES-256-GCM encryption/decryption using Node.js built-in crypto
+ * Key is read from PACS_ENCRYPTION_KEY environment variable only.
+ */
+
+const crypto = require('crypto');
+
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+const SALT_LENGTH = 32;
+const KEY_LENGTH = 32;
+const PBKDF2_ITERATIONS = 100000;
+
+/**
+ * Get encryption key from environment variable.
+ * Derives a proper 256-bit key from the env value using PBKDF2.
+ * @param {string} [password] - Optional password override (for testing)
+ * @returns {Buffer} 32-byte encryption key
+ */
+function getKey(password) {
+  const envKey = password || process.env.PACS_ENCRYPTION_KEY;
+
+  if (!envKey) {
+    throw new Error(
+      'PACS_ENCRYPTION_KEY environment variable is not set. ' +
+      'Please set it before using encrypted storage.\n' +
+      'Example: export PACS_ENCRYPTION_KEY="your-secure-random-key-here"'
+    );
+  }
+
+  // Use PBKDF2 to derive a proper 256-bit key from the env value
+  // Salt is fixed for deterministic derivation (salt is stored with ciphertext)
+  const salt = Buffer.from('pacs-core-salt-v1', 'utf8');
+  return crypto.pbkdf2Sync(envKey, salt, PBKDF2_ITERATIONS, KEY_LENGTH, 'sha512');
+}
+
+/**
+ * Encrypt plaintext using AES-256-GCM.
+ * @param {string} plaintext - The text to encrypt
+ * @param {string} [password] - Optional password override
+ * @returns {string} Base64-encoded string: iv:authTag:ciphertext
+ */
+function encrypt(plaintext, password) {
+  if (!plaintext) {
+    throw new Error('Plaintext is required for encryption');
+  }
+
+  const key = getKey(password);
+  const iv = crypto.randomBytes(IV_LENGTH);
+
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH,
+  });
+
+  let ciphertext = cipher.update(plaintext, 'utf8', 'base64');
+  ciphertext += cipher.final('base64');
+
+  const authTag = cipher.getAuthTag();
+
+  // Format: iv:authTag:ciphertext (all base64)
+  return [
+    iv.toString('base64'),
+    authTag.toString('base64'),
+    ciphertext,
+  ].join(':');
+}
+
+/**
+ * Decrypt ciphertext using AES-256-GCM.
+ * @param {string} encryptedData - Base64-encoded string: iv:authTag:ciphertext
+ * @param {string} [password] - Optional password override
+ * @returns {string} Decrypted plaintext
+ */
+function decrypt(encryptedData, password) {
+  if (!encryptedData) {
+    throw new Error('Encrypted data is required for decryption');
+  }
+
+  const parts = encryptedData.split(':');
+  if (parts.length !== 3) {
+    throw new Error('Invalid encrypted data format. Expected iv:authTag:ciphertext');
+  }
+
+  const [ivBase64, authTagBase64, ciphertext] = parts;
+  const key = getKey(password);
+
+  const iv = Buffer.from(ivBase64, 'base64');
+  const authTag = Buffer.from(authTagBase64, 'base64');
+
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH,
+  });
+
+  decipher.setAuthTag(authTag);
+
+  let plaintext = decipher.update(ciphertext, 'base64', 'utf8');
+  plaintext += decipher.final('utf8');
+
+  return plaintext;
+}
+
+/**
+ * Generate a secure random key suitable for PACS_ENCRYPTION_KEY.
+ * @returns {string} 64-character hex string (256 bits)
+ */
+function generateKey() {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+module.exports = {
+  encrypt,
+  decrypt,
+  generateKey,
+  getKey,
+  ALGORITHM,
+};

package/src/index.js

@@ -0,0 +1,74 @@
+/**
+ * PACS Core — Main Entry Point
+ * Personal AI Control System
+ */
+
+const crypto = require('./crypto');
+const memoryStore = require('./memory-store');
+const triggerParser = require('./trigger-parser');
+
+// Default export object
+const pacs = {
+  // Crypto utilities
+  crypto: {
+    encrypt: crypto.encrypt,
+    decrypt: crypto.decrypt,
+    generateKey: crypto.generateKey,
+  },
+
+  // Memory store
+  memory: {
+    read: memoryStore.readMemory,
+    write: memoryStore.writeMemory,
+    addFact: memoryStore.addFact,
+    removeFact: memoryStore.removeFact,
+    search: memoryStore.searchFacts,
+  },
+
+  // Routing store
+  routing: {
+    read: memoryStore.readRouting,
+    write: memoryStore.writeRouting,
+    addHint: memoryStore.addRoutingHint,
+  },
+
+  // Core rules
+  rules: {
+    read: memoryStore.readCoreRules,
+    write: memoryStore.writeCoreRules,
+    addRule: memoryStore.addRule,
+  },
+
+  // Trigger parsing
+  triggers: {
+    parse: triggerParser.parse,
+    find: triggerParser.findTrigger,
+    contains: triggerParser.containsTrigger,
+    detectLearnMode: triggerParser.detectLearnMode,
+    getHelp: triggerParser.getHelpText,
+    getAll: triggerParser.getAllTriggers,
+  },
+
+  // Storage info
+  getStorageDir: memoryStore.getStorageDir,
+  FILES: memoryStore.FILES,
+};
+
+module.exports = pacs;
+module.exports.AgentRegistry = require('./agent-registry.js').default;
+module.exports.InterAgentBus = require('./inter-agent-bus.js').default;
+module.exports.AgentCreator = require('./agent-creator.js').default;
+module.exports.RoutingEngine = require('./routing-engine.js').default;
+module.exports.LearningLoop = require('./learning-loop.js').default;
+module.exports.LearnMode = require('./learn-mode.js').default;
+
+// ES Module re-exports (for ESM consumers)
+module.exports.AgentRegistryESM = () => import('./agent-registry.js');
+module.exports.InterAgentBusESM = () => import('./inter-agent-bus.js');
+module.exports.AgentCreatorESM = () => import('./agent-creator.js');
+module.exports.RoutingEngineESM = () => import('./routing-engine.js');
+module.exports.LearningLoopESM = () => import('./learning-loop.js');
+module.exports.LearnModeESM = () => import('./learn-mode.js');
+
+// OpenClaw Bridge
+module.exports.OpenClawBridge = require('./openclaw-bridge.cjs');