@jamaynor/hal-config 1.0.1

package/test/test.js

@@ -0,0 +1,586 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+import { makeTmpDir, writeJson, cleanup } from '../test-utils.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Fresh dynamic import for each test to get a clean module-level cache
+async function freshImport() {
+  const modPath = path.resolve(__dirname, '../lib/config.js');
+  const url = `file:///${modPath.replace(/\\/g, '/')}?t=${Date.now()}`;
+  return import(url);
+}
+
+function readConfig(dir) {
+  return JSON.parse(fs.readFileSync(
+    path.join(dir, 'hal-system-config.json'), 'utf8'));
+}
+
+const SAMPLE_CONFIG = {
+  version: '2.0',
+  repoOrg: 'jamaynor',
+  'system-emails': [
+    'me@gmail.com',
+    'work@company.com',
+  ],
+  'hal-obsidian-vaults': [
+    { name: 'ja-vault', path: '/vaults/ja', label: 'Jeremy', primary: true,
+      'projects-folder': '1-Projects',
+      'daily-notes-folder': 'areas/daily-notes',
+      'email-folder': 'areas/email',
+      'meetings-folder': 'areas/meetings',
+      'people-folder': 'areas/people',
+    },
+    { name: 'lmb-vault', path: '/vaults/lmb', label: 'LMB',
+      'projects-folder': '1-Projects' },
+  ],
+  'hal-communication-accounts': [
+    { label: 'me@gmail.com', provider: 'google', email: 'me@gmail.com',
+      scopes: ['email', 'calendar'] },
+    { label: 'work@company.com', provider: 'ms365', email: 'work@company.com',
+      scopes: ['email'] },
+  ],
+  'hal-timezone': 'America/Chicago',
+  'hal-work-hours': { start: '09:00', end: '17:00' },
+  skills: {
+    'secret-manager-bws': {
+      enabled: true, homeAgent: null,
+      'environment-variable-prefix': 'HAL_BWS_',
+      install: { repo: 'openclaw-skill-secret-manager-bws',
+        package: 'openclaw-skill-secret-manager-bws',
+        binary: 'secrets-bws', version: 'main' },
+      runtime: {},
+    },
+    'project-manager': {
+      enabled: true, homeAgent: 'cto',
+      'environment-variable-prefix': 'HAL_PROJ_MGR_',
+      install: { repo: 'openclaw-skill-project-manager',
+        package: 'openclaw-skill-project-manager',
+        binary: ['project', 'project-mgmt'], version: 'latest' },
+      runtime: { workspace: '/data/agents/hal' },
+    },
+    'plan-your-day': {
+      enabled: true, homeAgent: null,
+      'environment-variable-prefix': 'HAL_PLAN_DAY_',
+      install: { repo: 'openclaw-skill-plan-your-day',
+        package: 'openclaw-skill-plan-your-day',
+        binary: 'plan-day', version: 'main' },
+      runtime: {},
+    },
+    'disabled-skill': {
+      enabled: false, homeAgent: null,
+      install: { binary: 'disabled-bin' },
+      runtime: {},
+    },
+  },
+  halManagedEntries: [],
+};
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('hal-shared-config', () => {
+  let tmpDir;
+  let hal;
+  let originalAdminRoot;
+
+  beforeEach(async () => {
+    tmpDir = makeTmpDir('hsc-test-');
+    writeJson(path.join(tmpDir, 'hal-system-config.json'), SAMPLE_CONFIG);
+    originalAdminRoot = process.env.HAL_SKILL_ADMIN_ROOT;
+    process.env.HAL_SKILL_ADMIN_ROOT = tmpDir;
+
+    // Skill independent config file (deterministic under HAL_SKILL_ADMIN_ROOT)
+    writeJson(
+      path.join(tmpDir, 'email-triage', 'config', 'email-triage.json'),
+      { gog_client_id: 'test-gog-client-id' }
+    );
+    hal = await freshImport();
+  });
+
+  afterEach(() => {
+    if (originalAdminRoot === undefined) delete process.env.HAL_SKILL_ADMIN_ROOT;
+    else process.env.HAL_SKILL_ADMIN_ROOT = originalAdminRoot;
+    cleanup(tmpDir);
+  });
+
+  // --------------------------------------------------------------------------
+  // Loading
+  // --------------------------------------------------------------------------
+
+  describe('load()', () => {
+    it('reads hal-system-config.json from given dir', () => {
+      const cfg = hal.load(tmpDir);
+      assert.equal(cfg.version, '2.0');
+      assert.equal(cfg.repoOrg, 'jamaynor');
+    });
+
+    it('returns empty object when file is missing', () => {
+      const emptyDir = makeTmpDir('hsc-test-');
+      const cfg = hal.load(emptyDir);
+      assert.deepStrictEqual(cfg, {});
+      cleanup(emptyDir);
+    });
+
+    it('throws on corrupt JSON', () => {
+      fs.writeFileSync(path.join(tmpDir, 'hal-system-config.json'), '{bad', 'utf8');
+      assert.throws(() => hal.load(tmpDir), { name: 'SyntaxError' });
+    });
+
+    it('auto-loads on first accessor call', () => {
+      // Set env so auto-load finds our tmp dir
+      const orig = process.env.HAL_SYSTEM_CONFIG;
+      process.env.HAL_SYSTEM_CONFIG = tmpDir;
+      try {
+        const v = hal.vaults();
+        assert.equal(v.length, 2);
+      } finally {
+        if (orig === undefined) delete process.env.HAL_SYSTEM_CONFIG;
+        else process.env.HAL_SYSTEM_CONFIG = orig;
+      }
+    });
+  });
+
+  describe('reload()', () => {
+    it('re-reads from disk after external change', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.timezone(), 'America/Chicago');
+
+      const cfg = readConfig(tmpDir);
+      cfg['hal-timezone'] = 'US/Eastern';
+      writeJson(path.join(tmpDir, 'hal-system-config.json'), cfg);
+
+      hal.reload();
+      assert.equal(hal.timezone(), 'US/Eastern');
+    });
+  });
+
+  describe('raw() and configDir()', () => {
+    it('returns full config and resolved dir', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.raw().repoOrg, 'jamaynor');
+      assert.equal(hal.configDir(), tmpDir);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Shared data accessors
+  // --------------------------------------------------------------------------
+
+  describe('vaults()', () => {
+    it('returns vault array', () => {
+      hal.load(tmpDir);
+      const v = hal.vaults();
+      assert.equal(v.length, 2);
+      assert.equal(v[0].name, 'ja-vault');
+      assert.equal(v[1].label, 'LMB');
+    });
+
+    it('returns empty array when key missing', () => {
+      writeJson(path.join(tmpDir, 'hal-system-config.json'), { version: '1.1' });
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.vaults(), []);
+    });
+  });
+
+  describe('vaultFolders() and vaultDirectoryPaths()', () => {
+    it('returns configured folder subpaths with defaults', () => {
+      hal.load(tmpDir);
+      const f = hal.vaultFolders('ja-vault');
+      assert.equal(f.projectsFolder, '1-Projects');
+      assert.equal(f.dailyNotesFolder, 'areas/daily-notes');
+      assert.equal(f.emailFolder, 'areas/email');
+      assert.equal(f.meetingsFolder, 'areas/meetings');
+      assert.equal(f.peopleFolder, 'areas/people');
+
+      const f2 = hal.vaultFolders('lmb-vault');
+      assert.equal(f2.projectsFolder, '1-Projects');
+      // defaults
+      assert.equal(f2.dailyNotesFolder, 'areas/daily-notes');
+      assert.equal(f2.emailFolder, 'areas/email');
+    });
+
+    it('returns resolved full directory paths for a vault', () => {
+      hal.load(tmpDir);
+      const p = hal.vaultDirectoryPaths('ja-vault');
+      assert.equal(p.vaultPath, '/vaults/ja');
+      assert.equal(p.projectsPath, '/vaults/ja/1-Projects');
+      assert.equal(p.dailyNotesPath, '/vaults/ja/areas/daily-notes');
+      assert.equal(p.peoplePath, '/vaults/ja/areas/people');
+    });
+  });
+
+  describe('accounts()', () => {
+    it('returns all accounts', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.accounts().length, 2);
+    });
+
+    it('filters by provider', () => {
+      hal.load(tmpDir);
+      const google = hal.accounts('google');
+      assert.equal(google.length, 1);
+      assert.equal(google[0].label, 'me@gmail.com');
+    });
+
+    it('returns empty for unknown provider', () => {
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.accounts('imap'), []);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Settings (getSetting)
+  // --------------------------------------------------------------------------
+
+  describe('getSetting()', () => {
+    it('returns a top-level global setting by key', () => {
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.getSetting('system-emails'), ['me@gmail.com', 'work@company.com']);
+    });
+
+    it('returns a skill-scoped setting from the skill config file', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.getSetting('email-triage', 'gog_client_id'), 'test-gog-client-id');
+    });
+
+    it('normalizes skill scope prefixes (hal-*)', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.getSetting('hal-email-triage', 'gog_client_id'), 'test-gog-client-id');
+    });
+
+    it('exposes PascalCase alias GetSetting', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.GetSetting('hal-email-triage', 'gog_client_id'), 'test-gog-client-id');
+    });
+  });
+
+  describe('timezone()', () => {
+    it('returns timezone string', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.timezone(), 'America/Chicago');
+    });
+
+    it('returns null when missing', () => {
+      writeJson(path.join(tmpDir, 'hal-system-config.json'), {});
+      hal.load(tmpDir);
+      assert.equal(hal.timezone(), null);
+    });
+  });
+
+  describe('workHours()', () => {
+    it('returns work hours object', () => {
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.workHours(), { start: '09:00', end: '17:00' });
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Skill accessors
+  // --------------------------------------------------------------------------
+
+  describe('skill()', () => {
+    it('returns skill config block', () => {
+      hal.load(tmpDir);
+      const pm = hal.skill('project-manager');
+      assert.equal(pm.enabled, true);
+    });
+
+    it('returns null for unknown skill', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.skill('nonexistent'), null);
+    });
+  });
+
+  describe('isEnabled()', () => {
+    it('returns true for enabled skill', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.isEnabled('project-manager'), true);
+    });
+
+    it('returns false for disabled skill', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.isEnabled('disabled-skill'), false);
+    });
+
+    it('returns false for unknown skill', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.isEnabled('nonexistent'), false);
+    });
+  });
+
+  describe('skillWorkspace()', () => {
+    it('returns workspace path from runtime', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.skillWorkspace('project-manager'), '/data/agents/hal');
+    });
+
+    it('returns null when runtime has no workspace', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.skillWorkspace('secret-manager-bws'), null);
+    });
+
+    it('returns null for unknown skill', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.skillWorkspace('nonexistent'), null);
+    });
+  });
+
+  describe('skillBinaries()', () => {
+    it('returns array for single binary', () => {
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.skillBinaries('secret-manager-bws'), ['secrets-bws']);
+    });
+
+    it('returns array for multiple binaries', () => {
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.skillBinaries('project-manager'),
+        ['project', 'project-mgmt']);
+    });
+
+    it('returns empty array for unknown skill', () => {
+      hal.load(tmpDir);
+      assert.deepStrictEqual(hal.skillBinaries('nonexistent'), []);
+    });
+  });
+
+  describe('homeAgent()', () => {
+    it('returns homeAgent string when set', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.homeAgent('project-manager'), 'cto');
+    });
+
+    it('returns null when homeAgent is null', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.homeAgent('plan-your-day'), null);
+    });
+
+    it('returns null for unknown skill', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.homeAgent('nonexistent'), null);
+    });
+  });
+
+  describe('skillConfigPath()', () => {
+    it('returns canonical path under HAL_SKILL_ADMIN_ROOT', () => {
+      hal.load(tmpDir);
+      const p = hal.skillConfigPath('project-manager');
+      assert.equal(p, path.join(tmpDir, 'project-manager', 'config', 'project-manager.json'));
+    });
+  });
+
+  describe('skillConfigDir()', () => {
+    it('returns the directory containing the skill config file', () => {
+      hal.load(tmpDir);
+      const d = hal.skillConfigDir('project-manager');
+      assert.equal(d, path.join(tmpDir, 'project-manager', 'config'));
+    });
+  });
+
+  describe('deterministic filesystem locations', () => {
+    it('returns OpenClaw shared workspace root', () => {
+      assert.equal(hal.openclawSharedWorkspaceRoot(), '/data/openclaw/workspace');
+    });
+
+    it('returns OpenClaw config file path', () => {
+      assert.equal(hal.openclawConfigFilePath(), '/data/openclaw/openclaw.json');
+    });
+
+    it('returns HAL system config dir/file (default)', () => {
+      const orig = process.env.HAL_SYSTEM_CONFIG;
+      delete process.env.HAL_SYSTEM_CONFIG;
+      try {
+        assert.equal(hal.halSystemConfigDir(), '/data/openclaw/hal');
+        assert.equal(hal.halSystemConfigFilePath(), path.join('/data/openclaw/hal', 'hal-system-config.json'));
+      } finally {
+        if (orig === undefined) delete process.env.HAL_SYSTEM_CONFIG;
+        else process.env.HAL_SYSTEM_CONFIG = orig;
+      }
+    });
+
+    it('returns HAL system config dir/file (env override)', () => {
+      const orig = process.env.HAL_SYSTEM_CONFIG;
+      process.env.HAL_SYSTEM_CONFIG = '/tmp/halcfg';
+      try {
+        assert.equal(hal.halSystemConfigDir(), '/tmp/halcfg');
+        assert.equal(hal.halSystemConfigFilePath(), path.join('/tmp/halcfg', 'hal-system-config.json'));
+      } finally {
+        if (orig === undefined) delete process.env.HAL_SYSTEM_CONFIG;
+        else process.env.HAL_SYSTEM_CONFIG = orig;
+      }
+    });
+
+    it('returns per-skill admin/config/log dirs under HAL_SKILL_ADMIN_ROOT', () => {
+      hal.load(tmpDir);
+      assert.equal(hal.halSkillAdminRoot('email-triage'), path.join(tmpDir, 'email-triage'));
+      assert.equal(hal.halSkillConfigDir('email-triage'), path.join(tmpDir, 'email-triage', 'config'));
+      assert.equal(hal.halSkillLogDir('email-triage'), path.join(tmpDir, 'email-triage', 'log'));
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // halSkillConfig (independent per-skill config files)
+  // --------------------------------------------------------------------------
+
+  describe('halSkillConfig', () => {
+    it('read() returns {} when skill config file is missing', () => {
+      hal.load(tmpDir);
+      const cfg = hal.halSkillConfig.read('missing-skill');
+      assert.deepStrictEqual(cfg, {});
+    });
+
+    it('write() writes the full skill config file (atomic)', () => {
+      hal.load(tmpDir);
+      hal.halSkillConfig.write('email-triage', { a: 1, b: 'x' });
+
+      const fp = path.join(tmpDir, 'email-triage', 'config', 'email-triage.json');
+      const onDisk = JSON.parse(fs.readFileSync(fp, 'utf8'));
+      assert.deepStrictEqual(onDisk, { a: 1, b: 'x' });
+    });
+
+    it('setSetting() creates/updates a single key', () => {
+      hal.load(tmpDir);
+      hal.halSkillConfig.setSetting('email-triage', 'gog_client_id', 'new-id');
+      assert.equal(hal.halSkillConfig.getSetting('hal-email-triage', 'gog_client_id'), 'new-id');
+    });
+
+    it('merge() deep-merges plain objects and replaces arrays', () => {
+      hal.load(tmpDir);
+      hal.halSkillConfig.write('email-triage', { nested: { a: 1 }, arr: [1, 2] });
+      const merged = hal.halSkillConfig.merge('email-triage', { nested: { b: 2 }, arr: [9] });
+      assert.deepStrictEqual(merged, { nested: { a: 1, b: 2 }, arr: [9] });
+    });
+  });
+
+  // isInstalled and isInstalledAsync are not tested here because they
+  // probe actual binaries on PATH — tested via integration only.
+
+  // --------------------------------------------------------------------------
+  // Registration
+  // --------------------------------------------------------------------------
+
+  describe('register()', () => {
+    it('writes runtime data to skill block and flushes', () => {
+      hal.load(tmpDir);
+      hal.register('plan-your-day', { workspace: '/data/agents/hal' });
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk.skills['plan-your-day'].runtime.workspace,
+        '/data/agents/hal');
+    });
+
+    it('merges with existing runtime data', () => {
+      hal.load(tmpDir);
+      hal.register('project-manager', { configFile: '/data/agents/hal/config/pm.json' });
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk.skills['project-manager'].runtime.workspace,
+        '/data/agents/hal');
+      assert.equal(ondisk.skills['project-manager'].runtime.configFile,
+        '/data/agents/hal/config/pm.json');
+    });
+
+    it('creates skill entry if not present', () => {
+      hal.load(tmpDir);
+      hal.register('new-skill', { workspace: '/tmp/new' });
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk.skills['new-skill'].runtime.workspace, '/tmp/new');
+    });
+  });
+
+  describe('writeAccounts()', () => {
+    it('appends new accounts', () => {
+      hal.load(tmpDir);
+      hal.writeAccounts([
+        { label: 'imap@example.com', provider: 'imap', email: 'imap@example.com' },
+      ]);
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk['hal-communication-accounts'].length, 3);
+    });
+
+    it('replaces existing account by label', () => {
+      hal.load(tmpDir);
+      hal.writeAccounts([
+        { label: 'me@gmail.com', provider: 'google', email: 'me@gmail.com',
+          scopes: ['email'] },
+      ]);
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk['hal-communication-accounts'].length, 2);
+      const google = ondisk['hal-communication-accounts']
+        .find(a => a.label === 'me@gmail.com');
+      assert.deepStrictEqual(google.scopes, ['email']);
+    });
+
+    it('does not remove unmentioned accounts', () => {
+      hal.load(tmpDir);
+      hal.writeAccounts([
+        { label: 'new@example.com', provider: 'imap', email: 'new@example.com' },
+      ]);
+
+      const ondisk = readConfig(tmpDir);
+      const labels = ondisk['hal-communication-accounts'].map(a => a.label);
+      assert.ok(labels.includes('me@gmail.com'));
+      assert.ok(labels.includes('work@company.com'));
+      assert.ok(labels.includes('new@example.com'));
+    });
+  });
+
+  describe('writeSkillConfig()', () => {
+    it('merges into skill block', () => {
+      hal.load(tmpDir);
+      hal.writeSkillConfig('plan-your-day', {
+        recentDays: 3,
+        primaryVault: 'Jeremy',
+      });
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk.skills['plan-your-day'].recentDays, 3);
+      assert.equal(ondisk.skills['plan-your-day'].primaryVault, 'Jeremy');
+      // existing keys preserved
+      assert.equal(ondisk.skills['plan-your-day'].enabled, true);
+    });
+  });
+
+  describe('writeSharedSettings()', () => {
+    it('writes top-level keys', () => {
+      hal.load(tmpDir);
+      hal.writeSharedSettings({
+        'hal-timezone': 'US/Pacific',
+        'hal-daily-note-filename': 'custom.md',
+      });
+
+      const ondisk = readConfig(tmpDir);
+      assert.equal(ondisk['hal-timezone'], 'US/Pacific');
+      assert.equal(ondisk['hal-daily-note-filename'], 'custom.md');
+      // skills untouched
+      assert.ok(ondisk.skills['project-manager']);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // index.js re-export
+  // --------------------------------------------------------------------------
+
+  describe('index.js', () => {
+    it('re-exports lib/config', async () => {
+      const idx = await import('../index.js');
+      assert.equal(typeof idx.load, 'function');
+      assert.equal(typeof idx.vaults, 'function');
+    });
+
+    it('default export has all functions', async () => {
+      const idx = await import('../index.js');
+      assert.equal(typeof idx.default.load, 'function');
+      assert.equal(typeof idx.default.vaults, 'function');
+    });
+  });
+});