@polderlabs/bizar 4.5.2 → 4.7.1

package/cli/commands/util.mjs

@@ -0,0 +1,459 @@
+/**
+ * cli/commands/util.mjs
+ *
+ * Miscellaneous utility commands:
+ *   audit, init, export, test-gate, dev-link, dev-unlink,
+ *   doctor, repair, heads-up, bg, browser-harness-up, providers detect,
+ *   backup, restore
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+// ── Help texts ──────────────────────────────────────────────────────────────────
+
+export function showAuditHelp() {
+  console.log(`
+  bizar audit — Run security audit on agent configuration
+
+  Usage:
+    bizar audit
+  `);
+}
+
+export function showInitHelp() {
+  console.log(`
+  bizar init — Initialize .bizar/ in current project
+
+  Usage:
+    bizar init
+
+  Description:
+    Detects the project stack, creates .bizar/PROJECT.md and
+    .bizar/AGENTS_SELF_IMPROVEMENT.md and installs relevant skills.
+    The per-project knowledge graph (in .bizar/graph/) is provided
+    by the graphify mod — install it from the mod registry for
+    that feature.
+  `);
+}
+
+export function showExportHelp() {
+  console.log(`
+  bizar export — Export agents/rules to another harness
+
+  Usage:
+    bizar export [claude|cursor|opencode]
+
+  Description:
+    Copies installed Bizar agents and rules into another harness format.
+  `);
+}
+
+export function showTestGateHelp() {
+  console.log(`
+  bizar test-gate — Detect & run the project's test suite
+  `);
+}
+
+export function showDevLinkHelp() {
+  console.log(`
+  bizar dev-link / dev-unlink — Manage a symlink from the opencode plugin dir
+  to a local source checkout, so edits propagate to opencode on next session.
+
+  Usage:
+    bizar dev-link [source-dir]    Symlink source-dir (default: ./plugins/bizar)
+                                   to ~/.config/opencode/plugins/bizar
+    bizar dev-link --force         Replace an existing deployed copy
+    bizar dev-unlink               Remove the dev symlink + restore from npm
+    bizar dev-unlink --force       Remove even if not a symlink (destructive)
+
+  Description:
+    By default, opencode loads the Bizar plugin from
+    ~/.config/opencode/plugins/bizar, which is a real directory copied
+    from the npm package. Edits to plugins/bizar/ in the BizarHarness
+    repo don't propagate until you re-run the installer.
+
+    \`bizar dev-link\` replaces that directory with a symlink pointing
+    at your local checkout, so source edits are picked up immediately.
+    \`bizar dev-unlink\` reverses the change by removing the symlink
+    and re-installing the deployed copy from the npm package.
+
+    While the dev link is in place, \`bizar update\` will skip the
+    plugin-copy step (and print a warning) so it doesn't clobber the
+    link. Run \`bizar dev-unlink\` first, or pass --force to overwrite.
+
+  Examples:
+    bizar dev-link
+    bizar dev-link /home/me/projects/bizar/plugins/bizar
+    bizar dev-link --force
+    bizar dev-unlink
+  `);
+}
+
+export function showDoctorHelp() {
+  console.log(`
+  bizar doctor — Check the BizarHarness install for health issues
+
+  Usage:
+    bizar doctor
+
+  Description:
+    Runs a battery of health checks against the local install:
+      • opencode CLI reachable
+      • ~/.config/opencode/opencode.json parses as JSON
+      • the Bizar plugin is registered
+      • plugin path resolves
+      • @polderlabs/bizar-plugin is installed globally
+      • core agent files are installed (odin, quick, thor, tyr)
+      • headroom / semble / skills on PATH (lenient — at least one)
+      • dashboard reachable (skipped if no port file)
+      • provider.minimax block + MiniMax model flags are sane
+
+    Prints ✓/✗ for each check and a final summary. Exits non-zero
+    if any check fails. Use \`bizar doctor\` after a manual config
+    edit or to diagnose "why is opencode misbehaving?" questions.
+
+  Related:
+    bizar update              Update + auto-run doctor on success
+  `);
+}
+
+export function showRepairHelp() {
+  console.log(`
+  bizar repair — Fix common install issues
+
+  Usage:
+    bizar repair                Diagnose + fix stale bin symlinks and mismatched versions
+    bizar repair --dry-run      Show what would change without modifying anything
+    bizar repair --bin-only     Only fix the bin symlink; skip version checks
+  `);
+}
+
+export function showBackupHelp() {
+  console.log(`
+  bizar backup — Backup BizarHarness state
+
+  Usage:
+    bizar backup [label]        Create a new backup (with optional label)
+    bizar backup list           List available backups
+    bizar backup verify <path>  Verify a backup's integrity
+    bizar backup delete <path>  Delete a backup
+
+  Description:
+    Backs up config (~/.config/bizar/, ~/.config/opencode/), memory,
+    usage logs, and optionally project-level state (.bizar/, skills/).
+    Backups are stored under ~/.local/share/bizar/backups/.
+
+  Examples:
+    bizar backup
+    bizar backup "before-upgrade"
+    bizar backup list
+    bizar backup verify ~/.local/share/bizar/backups/bizar-2025-07-05-120000
+  `);
+}
+
+export function showRestoreHelp() {
+  console.log(`
+  bizar restore — Restore BizarHarness from a backup
+
+  Usage:
+    bizar restore <path>                Restore from a backup
+    bizar restore <path> --dry-run      Preview restore without modifying files
+    bizar restore <path> --overwrite    Replace existing files (default: merge)
+    bizar restore <path> --skip         Keep existing files, don't overwrite
+
+  Description:
+    Restores files from a backup directory. Default strategy is 'merge'
+    (newer files from backup overlay existing files). Use --overwrite to
+    replace everything, or --skip to leave existing files untouched.
+
+  Examples:
+    bizar restore ~/.local/share/bizar/backups/bizar-2025-07-05-120000
+    bizar restore ~/.local/share/bizar/backups/bizar-2025-07-05-120000 --dry-run
+    bizar restore ~/.local/share/bizar/backups/bizar-2025-07-05-120000 --overwrite
+  `);
+}
+
+// ── Test gate ──────────────────────────────────────────────────────────────────
+
+export async function runTestGate() {
+  console.log(chalk.bold.hex('#a855f7')('\n  ᚦ TEST GATE ᚦ\n'));
+  const { execSync } = await import('node:child_process');
+  const cwd = process.cwd();
+  const possible = [
+    { cmd: 'npm test', check: 'package.json' },
+    { cmd: 'pytest', check: 'pyproject.toml' },
+    { cmd: 'cargo test', check: 'Cargo.toml' },
+    { cmd: 'go test ./...', check: 'go.mod' },
+  ];
+  for (const suite of possible) {
+    try {
+      if (existsSync(join(cwd, suite.check))) {
+        console.log(`  Running: ${suite.cmd}`);
+        execSync(suite.cmd, { stdio: 'inherit', timeout: 120000, cwd });
+        console.log('\n  ✓ Test gate passed\n');
+        return true;
+      }
+    } catch {
+      console.log(`\n  ✗ Test gate failed: ${suite.cmd}\n`);
+      process.exit(1);
+    }
+  }
+  console.log('  No test suite detected. Install one to use the test gate.\n');
+  return false;
+}
+
+// ── Main dispatcher ────────────────────────────────────────────────────────────
+
+export async function run(name, args, isHelpRequest) {
+  switch (name) {
+    case 'audit':
+      if (isHelpRequest) showAuditHelp();
+      else {
+        const { runAudit } = await import('../audit.mjs');
+        await runAudit();
+      }
+      break;
+
+    case 'init':
+      if (isHelpRequest) showInitHelp();
+      else {
+        const { runInit } = await import('../init.mjs');
+        await runInit(process.cwd());
+      }
+      break;
+
+    case 'export':
+      if (isHelpRequest) showExportHelp();
+      else {
+        const { runExport } = await import('../export.mjs');
+        const targetFlag = args.includes('--target') ? args[args.indexOf('--target') + 1] : null;
+        await runExport(targetFlag);
+      }
+      break;
+
+    case 'test-gate':
+      if (isHelpRequest) showTestGateHelp();
+      else await runTestGate();
+      break;
+
+    case 'dev-link':
+      if (isHelpRequest) showDevLinkHelp();
+      else {
+        const { createDevLink } = await import('../dev-link.mjs');
+        const positional = args.filter((a) => !a.startsWith('-'));
+        const flags = args.filter((a) => a.startsWith('-'));
+        const sourceDir = positional[0] ?? null;
+        const force = flags.includes('--force') || flags.includes('-f');
+        const ok = createDevLink(sourceDir, { force });
+        if (!ok) process.exit(1);
+      }
+      break;
+
+    case 'dev-unlink':
+      if (isHelpRequest) showDevLinkHelp();
+      else {
+        const { removeDevLink } = await import('../dev-link.mjs');
+        const force = args.includes('--force') || args.includes('-f');
+        const ok = await removeDevLink({ force });
+        if (!ok) process.exit(1);
+      }
+      break;
+
+    case 'doctor':
+      if (isHelpRequest) showDoctorHelp();
+      else {
+        const { runDoctor } = await import('../doctor.mjs');
+        const wantJson = args.includes('--json');
+        const result = await runDoctor({ silent: wantJson, json: wantJson });
+        if (wantJson) process.stdout.write(JSON.stringify(result) + '\n');
+        if (result.failed > 0) process.exit(1);
+      }
+      break;
+
+    case 'repair':
+      if (isHelpRequest) showRepairHelp();
+      else {
+        const { runRepair } = await import('../repair.mjs');
+        const dryRun = args.includes('--dry-run');
+        const binOnly = args.includes('--bin-only');
+        const result = await runRepair({ dryRun, binOnly });
+        if (!result.ok) {
+          for (const n of result.notes) console.log(`  ${n}`);
+          process.exit(1);
+        }
+        for (const n of result.notes) console.log(`  ${n}`);
+        if (result.fixed.length > 0) {
+          console.log(chalk.green('\n  Repair complete. Re-run your shell or `hash -r` to pick up the new path.'));
+        }
+      }
+      break;
+
+    case 'backup': {
+      if (isHelpRequest || args.length === 0) {
+        showBackupHelp();
+        break;
+      }
+      const sub = args[0];
+      if (sub === 'list') {
+        const { listBackups } = await import('../../bizar-dash/src/server/backup-store.mjs');
+        const backups = await listBackups();
+        if (backups.length === 0) {
+          console.log('  No backups found.');
+        } else {
+          for (const b of backups) {
+            console.log(`  ${b.path}`);
+            console.log(`    Created: ${b.createdAt}`);
+            console.log(`    Size: ${b.sizeFormatted}`);
+            if (b.manifest?.label) console.log(`    Label: ${b.manifest.label}`);
+            console.log('');
+          }
+        }
+        break;
+      }
+      if (sub === 'verify') {
+        const path = args[1];
+        if (!path) { console.error('  Usage: bizar backup verify <path>'); process.exit(1); }
+        const { verifyBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+        const result = await verifyBackup({ backupPath: path });
+        if (result.ok) {
+          console.log(chalk.green('  ✓ Backup is valid'));
+        } else {
+          console.error(chalk.red('  ✗ Backup has issues:'));
+          for (const issue of result.issues) console.error(`    - ${issue}`);
+          process.exit(1);
+        }
+        break;
+      }
+      if (sub === 'delete') {
+        const path = args[1];
+        if (!path) { console.error('  Usage: bizar backup delete <path>'); process.exit(1); }
+        const { deleteBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+        const result = await deleteBackup({ backupPath: path });
+        if (result.ok) {
+          console.log(chalk.green('  ✓ Backup deleted'));
+        } else {
+          console.error(chalk.red(`  ✗ Delete failed: ${result.error}`));
+          process.exit(1);
+        }
+        break;
+      }
+      // Default: create backup
+      const label = sub || null;
+      const { createBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+      const result = await createBackup({ label });
+      if (result.ok) {
+        console.log(chalk.green('  ✓ Backup created'));
+        console.log(`  Path: ${result.path}`);
+        console.log(`  Size: ${result.sizeBytes > 0 ? `${(result.sizeBytes / 1024).toFixed(1)} KB` : '0 B'}`);
+        console.log(`  Duration: ${result.durationMs}ms`);
+      } else {
+        console.error(chalk.red('  ✗ Backup failed'));
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'restore': {
+      if (isHelpRequest) {
+        showRestoreHelp();
+        break;
+      }
+      const path = args[0];
+      if (!path) { showRestoreHelp(); process.exit(1); }
+      const dryRun = args.includes('--dry-run');
+      const conflictStrategy = args.includes('--overwrite') ? 'overwrite' : args.includes('--skip') ? 'skip' : 'merge';
+      const { restoreBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+      const result = await restoreBackup({ backupPath: path, dryRun, conflictStrategy });
+      if (dryRun) {
+        console.log('  Dry-run mode — no files were modified.');
+      }
+      if (result.restored.length > 0) {
+        console.log(`  Restored: ${result.restored.join(', ')}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`  Skipped: ${result.skipped.join(', ')}`);
+      }
+      if (result.errors.length > 0) {
+        console.error(chalk.red('  Errors:'));
+        for (const e of result.errors) console.error(`    - ${e}`);
+        process.exit(1);
+      }
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ Restore complete`));
+      }
+      break;
+    }
+
+    case 'heads-up':
+      if (isHelpRequest) {
+        console.log('  heads-up <subcommand>   Manage pre-push / pre-release heads-ups (list/check/archive)');
+      } else {
+        const { runHeadsUp } = await import('../heads-up.mjs');
+        await runHeadsUp(args[0], args.slice(1));
+      }
+      break;
+
+    case 'bg':
+      if (isHelpRequest) {
+        console.log('  bg <subcommand>   Manage background agents (list/view/kill/logs)');
+      } else {
+        const { runBg } = await import('../bg.mjs');
+        await runBg(args[0], args.slice(1));
+      }
+      break;
+
+    case 'digest':
+      // v4.8.0 — Weekly digest management
+      if (isHelpRequest) {
+        const { showDigestHelp } = await import('../digest.mjs');
+        showDigestHelp();
+      } else {
+        const { runDigest } = await import('../digest.mjs');
+        await runDigest(args[0], args.slice(1));
+      }
+      break;
+
+    case 'browser-harness-up': {
+      const { execFileSync } = await import('node:child_process');
+      const sub = args[0] || 'start';
+      const __dirname = fileURLToPath(new URL('.', import.meta.url));
+      const scriptPath = join(__dirname, '..', 'browser-harness-up.sh');
+      try {
+        const out = execFileSync('bash', [scriptPath, sub], {
+          encoding: 'utf8',
+          stdio: 'inherit',
+        });
+        if (out) process.stdout.write(out);
+      } catch (err) {
+        console.error(chalk.red(`  ✗ browser-harness-up ${sub} failed (exit ${err.status ?? 1})`));
+        process.exit(err.status || 1);
+      }
+      break;
+    }
+
+    case 'providers':
+      if (args[0] === 'detect') {
+        const { runProvidersDetect } = await import('../providers-detect.mjs');
+        await runProvidersDetect(args.slice(1));
+      }
+      break;
+
+    case 'plan':
+      // Alias for artifact
+      if (isHelpRequest) {
+        const { showHelp } = await import('../artifact-cli.mjs');
+        showHelp();
+      } else {
+        const { runArtifact } = await import('../artifact-cli.mjs');
+        await runArtifact(args, {});
+      }
+      break;
+
+    default:
+      return false;
+  }
+  return true;
+}

package/cli/digest.mjs

@@ -0,0 +1,149 @@
+/**
+ * cli/digest.mjs
+ *
+ * v4.8.0 — `bizar digest` CLI subcommand.
+ *
+ * Usage:
+ *   bizar digest                  Show latest digest
+ *   bizar digest list             List all digests
+ *   bizar digest generate [--days N]  Generate now (default 7 days)
+ *   bizar digest view <path>      View a specific digest
+ *   bizar digest delete <path>    Delete a specific digest
+ */
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'node:fs';
+
+function showDigestHelp() {
+  console.log(`
+  bizar digest — Manage weekly digests
+
+  Usage:
+    bizar digest                     Show the latest digest
+    bizar digest list                List all digests
+    bizar digest generate [--days N] Generate a digest now (default 7 days)
+    bizar digest view <path>         View a specific digest
+    bizar digest delete <path>       Delete a specific digest
+    bizar digest --help              Show this help
+  `);
+}
+
+export async function runDigest(subcommand, args) {
+  const { generateAndSave, listDigests, getDigest, deleteDigest } = await import(
+    '../bizar-dash/src/server/digest-store.mjs'
+  );
+
+  switch (subcommand) {
+    case undefined:
+    case null:
+    case '': {
+      // Show latest digest
+      const digests = await listDigests({ limit: 1 });
+      if (digests.length === 0) {
+        console.log(chalk.yellow('  No digests yet. Run `bizar digest generate` to create one.'));
+        return;
+      }
+      const latest = digests[0];
+      const digest = await getDigest(latest.path);
+      if (!digest) {
+        console.log(chalk.red(`  ✗ Digest not found at ${latest.path}`));
+        return;
+      }
+      console.log(digest.content);
+      break;
+    }
+
+    case 'list': {
+      const digests = await listDigests({ limit: 50 });
+      if (digests.length === 0) {
+        console.log(chalk.yellow('  No digests yet.'));
+        return;
+      }
+      console.log(chalk.bold(`  ${digests.length} digest(s):\n`));
+      for (const d of digests) {
+        const date = new Date(d.createdAt).toLocaleDateString();
+        const size = (d.sizeBytes / 1024).toFixed(1);
+        console.log(`  ${chalk.cyan(d.filename)}`);
+        console.log(`    Path: ${d.path}`);
+        console.log(`    Created: ${date}  (${size} KB)`);
+        console.log();
+      }
+      break;
+    }
+
+    case 'generate': {
+      const daysIdx = args.indexOf('--days');
+      const days = daysIdx >= 0 ? parseInt(args[daysIdx + 1], 10) || 7 : 7;
+      const dryRun = args.includes('--dry-run');
+      const now = new Date();
+      const weekEnd = now.toISOString().slice(0, 10);
+      const weekStart = new Date(now.getTime() - days * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .slice(0, 10);
+
+      console.log(chalk.bold(`  Generating digest for ${weekStart} → ${weekEnd}...`));
+      if (dryRun) console.log(chalk.yellow('  (dry run — will not save)'));
+
+      const result = await generateAndSave({
+        weekStart,
+        weekEnd,
+        projectRoot: process.cwd(),
+        dryRun,
+      });
+
+      if (result.dryRun) {
+        console.log('\n' + result.markdown);
+      } else {
+        console.log(chalk.green(`  ✓ Digest saved:`));
+        for (const p of result.saveResult.paths) {
+          console.log(`    ${p}`);
+        }
+        console.log(chalk.green(`  Sections: ${Object.keys(result.sections).filter(k => Array.isArray(result.sections[k]) ? result.sections[k].length > 0 : result.sections[k] !== null).length}/7 populated`));
+      }
+      break;
+    }
+
+    case 'view': {
+      const path = args[0];
+      if (!path) {
+        console.log(chalk.red('  ✗ Usage: bizar digest view <path>'));
+        process.exit(1);
+      }
+      if (!existsSync(path)) {
+        console.log(chalk.red(`  ✗ File not found: ${path}`));
+        process.exit(1);
+      }
+      const digest = await getDigest(path);
+      if (!digest) {
+        console.log(chalk.red(`  ✗ Could not read digest at ${path}`));
+        process.exit(1);
+      }
+      console.log(digest.content);
+      break;
+    }
+
+    case 'delete': {
+      const path = args[0];
+      if (!path) {
+        console.log(chalk.red('  ✗ Usage: bizar digest delete <path>'));
+        process.exit(1);
+      }
+      const result = await deleteDigest(path);
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ Deleted ${path}`));
+      } else {
+        console.log(chalk.red(`  ✗ Delete failed: ${result.error || 'unknown'}`));
+        process.exit(1);
+      }
+      break;
+    }
+
+    default:
+      if (subcommand === '--help' || subcommand === '-h') {
+        showDigestHelp();
+      } else {
+        console.log(chalk.red(`  ✗ Unknown digest subcommand: ${subcommand}`));
+        showDigestHelp();
+        process.exit(1);
+      }
+  }
+}

package/cli/doctor.mjs

@@ -21,9 +21,8 @@
 import chalk from 'chalk';
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { opencodeConfigDir, opencodeAgentsDir } from './utils.mjs';
+import { opencodeConfigDir, opencodeAgentsDir, which, bizarConfigDir } from './utils.mjs';
 
 // v3.20.11: list every agent the install script is expected to deploy.
 // Adding a new agent to `config/agents/` without adding it here causes
@@ -50,12 +49,6 @@ const REQUIRED_AGENTS = [
 
 // ── helpers ─────────────────────────────────────────────────────────────────
 
-function bizarConfigDir() {
-  return process.env.XDG_CONFIG_HOME
-    ? join(process.env.XDG_CONFIG_HOME, 'bizar')
-    : join(homedir(), '.config', 'bizar');
-}
-
 /**
  * Run a check function and capture its result. The check either
  * returns a string message (pass) or throws an Error (fail).
@@ -73,11 +66,6 @@ async function runCheck(name, fn) {
   }
 }
 
-function which(cmd) {
-  const probe = spawnSync('which', [cmd], { stdio: 'ignore' });
-  return probe.status === 0;
-}
-
 // ── individual checks ───────────────────────────────────────────────────────
 
 async function checkOpencodeReachable() {

package/cli/provision.mjs

@@ -42,9 +42,11 @@ import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync, mkdirSync
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { bizarConfigDir } from './utils.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const HOME = homedir();
 
 // `cli/provision.mjs` lives at `<pkg>/cli/provision.mjs`. The repo root
 // (where `plugins/bizar/`, `bizar-dash/`, `package.json` etc. live) is
@@ -53,19 +55,6 @@ const __dirname = dirname(__filename);
 export const REPO_ROOT = join(__dirname, '..');
 export const PKG_MAIN = '@polderlabs/bizar';
 
-const HOME = homedir();
-
-function bizarConfigDir() {
-  if (process.platform === 'win32') {
-    return process.env.APPDATA
-      ? join(process.env.APPDATA, 'bizar')
-      : join(HOME, '.config', 'bizar');
-  }
-  return process.env.XDG_CONFIG_HOME
-    ? join(process.env.XDG_CONFIG_HOME, 'bizar')
-    : join(HOME, '.config', 'bizar');
-}
-
 export const BIZAR_HOME = bizarConfigDir();
 export const OPENCODE_DIR =
   process.platform === 'win32'

package/cli/service-controller.mjs

@@ -39,6 +39,7 @@ import {
 import { homedir, platform } from 'node:os';
 import { join, dirname, resolve, isAbsolute } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { bizarConfigDir } from './utils.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -47,17 +48,6 @@ const PLATFORM = platform();
 
 // ── Path helpers ──────────────────────────────────────────────────────────────
 
-function bizarConfigDir() {
-  if (PLATFORM === 'win32') {
-    return process.env.APPDATA
-      ? join(process.env.APPDATA, 'bizar')
-      : join(HOME, '.config', 'bizar');
-  }
-  return process.env.XDG_CONFIG_HOME
-    ? join(process.env.XDG_CONFIG_HOME, 'bizar')
-    : join(HOME, '.config', 'bizar');
-}
-
 function userUnitDir() {
   if (PLATFORM === 'win32') return null;
   return process.env.XDG_CONFIG_HOME