mixdog 0.7.1

package/scripts/uninstall.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+'use strict';
+
+// mixdog uninstall restore helper.
+//
+// Restores the two user-owned surfaces mixdog may have modified at install
+// time — the global ~/.claude/CLAUDE.md and the autoMemoryEnabled /
+// awaySummaryEnabled keys in ~/.claude/settings.json — from the snapshot the
+// install flow captured under the backup root. It deletes NOTHING on its own;
+// data/plugin/backup removal is printed as manual steps for the user to run.
+//
+// Restore contract (produced in parallel by the install/seed flow):
+//   backupRoot = MIXDOG_USER_DATA_BACKUP_ROOT || ~/.claude/backups/mixdog-user-data
+//   <backupRoot>/install-restore/claude-md-original.md
+//       — the user's pre-mixdog ~/.claude/CLAUDE.md (absent => none existed)
+//   <backupRoot>/install-restore/claude-settings-original.json
+//       — { autoMemoryEnabled: <bool|null>, awaySummaryEnabled: <bool|null>,
+//           capturedAt: <ISO> }; null means the key did not exist pre-install.
+//
+// Node-only (no bun-specific APIs). Honors --dry-run.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const { removeManagedBlock } = require(
+  path.join(__dirname, '..', 'lib', 'claude-md-writer.cjs'),
+);
+
+const DRY_RUN = process.argv.slice(2).includes('--dry-run');
+
+const HOME = os.homedir();
+const CLAUDE_MD_PATH = path.join(HOME, '.claude', 'CLAUDE.md');
+const SETTINGS_PATH = path.join(HOME, '.claude', 'settings.json');
+const SETTINGS_KEYS = ['autoMemoryEnabled', 'awaySummaryEnabled'];
+
+function backupRoot() {
+  const env = process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
+  if (env && env.trim()) return env;
+  return path.join(HOME, '.claude', 'backups', 'mixdog-user-data');
+}
+
+const RESTORE_DIR = path.join(backupRoot(), 'install-restore');
+const CLAUDE_MD_SNAPSHOT = path.join(RESTORE_DIR, 'claude-md-original.md');
+const SETTINGS_SNAPSHOT = path.join(RESTORE_DIR, 'claude-settings-original.json');
+
+function log(msg) {
+  process.stdout.write(`${msg}\n`);
+}
+
+function tag() {
+  return DRY_RUN ? '[dry-run] would ' : '';
+}
+
+function readFileOrNull(p) {
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+// (a) Restore ~/.claude/CLAUDE.md.
+function restoreClaudeMd() {
+  log('\n[1/2] CLAUDE.md');
+  const snapshot = readFileOrNull(CLAUDE_MD_SNAPSHOT);
+
+  if (snapshot !== null) {
+    if (DRY_RUN) {
+      log(`  ${tag()}restore ${CLAUDE_MD_PATH} from ${CLAUDE_MD_SNAPSHOT}`);
+    } else {
+      fs.mkdirSync(path.dirname(CLAUDE_MD_PATH), { recursive: true });
+      fs.writeFileSync(CLAUDE_MD_PATH, snapshot, 'utf8');
+      log(`  restored ${CLAUDE_MD_PATH} from pre-install snapshot`);
+    }
+    return;
+  }
+
+  // No snapshot: the user either had no pre-mixdog CLAUDE.md or never used
+  // CLAUDE.md mode. Strip only the marker-delimited managed block, leaving
+  // any user content verbatim.
+  if (readFileOrNull(CLAUDE_MD_PATH) === null) {
+    log('  nothing to restore (no snapshot, no CLAUDE.md present)');
+    return;
+  }
+  if (DRY_RUN) {
+    log(`  ${tag()}strip the mixdog managed block from ${CLAUDE_MD_PATH}`);
+    return;
+  }
+  const wrote = removeManagedBlock(CLAUDE_MD_PATH);
+  log(
+    wrote
+      ? `  stripped the mixdog managed block from ${CLAUDE_MD_PATH}`
+      : `  nothing to restore (no managed block in ${CLAUDE_MD_PATH})`,
+  );
+}
+
+// (b) Restore autoMemoryEnabled / awaySummaryEnabled in settings.json.
+function restoreSettings() {
+  log('\n[2/2] settings.json');
+  const snapshotRaw = readFileOrNull(SETTINGS_SNAPSHOT);
+  if (snapshotRaw === null) {
+    log('  nothing to restore (no settings snapshot)');
+    return;
+  }
+
+  let snapshot;
+  try {
+    snapshot = JSON.parse(snapshotRaw);
+  } catch (err) {
+    log(`  skipped: snapshot is not valid JSON (${err.message})`);
+    return;
+  }
+
+  const settingsRaw = readFileOrNull(SETTINGS_PATH);
+  let settings = {};
+  if (settingsRaw !== null) {
+    try {
+      settings = JSON.parse(settingsRaw);
+    } catch (err) {
+      log(`  skipped: ${SETTINGS_PATH} is not valid JSON (${err.message})`);
+      return;
+    }
+    // Valid JSON can still be the wrong shape (null, array, string, number).
+    // The restore path below assumes a plain object (`key in settings`,
+    // `settings[key] = want`); a non-object would crash or write garbage, so
+    // bail out and touch nothing — mirrors the installer's object guard.
+    if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+      log(`  skipped: ${SETTINGS_PATH} is not a JSON object; not modifying it`);
+      return;
+    }
+  }
+
+  const changes = [];
+  for (const key of SETTINGS_KEYS) {
+    if (!(key in snapshot)) continue;
+    const want = snapshot[key];
+    if (want === null) {
+      if (key in settings) {
+        changes.push(`delete ${key}`);
+        delete settings[key];
+      }
+    } else if (settings[key] !== want) {
+      changes.push(`set ${key}=${want}`);
+      settings[key] = want;
+    }
+  }
+
+  if (changes.length === 0) {
+    log('  nothing to restore (settings already match snapshot)');
+    return;
+  }
+
+  if (DRY_RUN) {
+    log(`  ${tag()}update ${SETTINGS_PATH}: ${changes.join(', ')}`);
+    return;
+  }
+  fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
+  fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+  log(`  updated ${SETTINGS_PATH}: ${changes.join(', ')}`);
+}
+
+// (c) Print remaining manual steps — this script deletes nothing.
+function printManualSteps() {
+  const dataDir = path.join(HOME, '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
+  log('\nManual steps (not performed by this script):');
+  log('  1. Remove the plugin from Claude Code:');
+  log('       /plugin uninstall mixdog@trib-plugin');
+  log('  2. Delete the plugin data directory (memory, schedules, logs, config):');
+  log(`       ${dataDir}`);
+  log('  3. Delete the user-data backups directory if you no longer need it:');
+  log(`       ${backupRoot()}`);
+  log('  See UNINSTALL.md for secrets/credential cleanup.');
+}
+
+function main() {
+  log(
+    DRY_RUN
+      ? 'mixdog uninstall restore (dry run — no files will be modified)'
+      : 'mixdog uninstall restore',
+  );
+  log(`  backup root: ${backupRoot()}`);
+
+  restoreClaudeMd();
+  restoreSettings();
+  printManualSteps();
+
+  log(DRY_RUN ? '\nDry run complete. Nothing was modified.' : '\nRestore complete.');
+}
+
+try {
+  main();
+} catch (err) {
+  process.stderr.write(`[uninstall] failed: ${err && err.stack ? err.stack : err}\n`);
+  process.exit(1);
+}

package/scripts/webhook-selfheal-smoke.mjs

@@ -0,0 +1,29 @@
+// Self-bootstrap an isolated CLAUDE_PLUGIN_DATA before importing webhook.mjs,
+// which transitively reaches src/shared/config.mjs → plugin-paths, which THROWS
+// when neither CLAUDE_PLUGIN_DATA nor CLAUDE_PLUGIN_ROOT is set. Static imports
+// hoist above this guard, so the webhook import MUST be dynamic and come after.
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+if (!process.env.CLAUDE_PLUGIN_DATA) {
+  process.env.CLAUDE_PLUGIN_DATA = join(tmpdir(), `mixdog-webhook-selfheal-smoke-${process.pid}`);
+}
+
+const { decidePortReclaimAction } = await import('../src/channels/lib/webhook.mjs');
+
+const cases = [
+  [{ ownerPid: 999, ownerAlive: false, ownerIsNgrok: false }, 'reclaim', 'dead-pid'],
+  [{ ownerPid: 4242, ownerAlive: true, ownerIsNgrok: false }, 'bump', 'live-non-ngrok'],
+  [{ ownerPid: 777, ownerAlive: true, ownerIsNgrok: true }, 'reclaim', 'ngrok-owner'],
+  [{ ownerPid: null, ownerAlive: false, ownerIsNgrok: false }, 'reclaim', 'unknown-owner'],
+];
+
+let failed = 0;
+for (const [input, expected, label] of cases) {
+  const got = decidePortReclaimAction(input);
+  const pass = got === expected;
+  process.stdout.write(`${label}: ${pass ? 'PASS' : 'FAIL'} (expected ${expected}, got ${got})\n`);
+  if (!pass) failed++;
+}
+
+process.exit(failed ? 1 : 0);

package/scripts/write-overwrite-guard-smoke.mjs

@@ -0,0 +1,56 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
+const DATA_DIR = join(tmpdir(), `mixdog-write-guard-smoke-${process.pid}`);
+process.env.CLAUDE_PLUGIN_DATA = DATA_DIR;
+
+const { executeBuiltinTool } = await import(pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/builtin.mjs')).href);
+
+const dir = await mkdtemp(join(tmpdir(), 'mixdog-write-guard-'));
+
+function assertError(label, out, prefix) {
+  if (!String(out).startsWith(prefix)) throw new Error(`${label}: expected ${prefix}, got ${out}`);
+}
+function assertOk(label, out) {
+  if (/^Error/.test(String(out))) throw new Error(`${label}: ${out}`);
+}
+async function expectFile(rel, expected) {
+  const { readFile } = await import('node:fs/promises');
+  const got = await readFile(join(dir, rel), 'utf8');
+  if (got !== expected) throw new Error(`${rel}: got ${JSON.stringify(got)}, expected ${JSON.stringify(expected)}`);
+}
+
+try {
+  await writeFile(join(dir, 'partial.txt'), 'line1\nline2\nline3\n', 'utf8');
+  assertOk('partial read', await executeBuiltinTool('read', {
+    path: 'partial.txt',
+    offset: 2,
+    limit: 1,
+  }, dir, { readStateScope: 'partial-write' }));
+  const blocked = await executeBuiltinTool('write', {
+    path: 'partial.txt',
+    content: 'clobber\n',
+  }, dir, { readStateScope: 'partial-write' });
+  assertError('partial then overwrite', blocked, 'Error [code 10]');
+  await expectFile('partial.txt', 'line1\nline2\nline3\n');
+
+  await writeFile(join(dir, 'grep-target.txt'), 'findme\nrest\n', 'utf8');
+  assertOk('grep single file', await executeBuiltinTool('grep', {
+    pattern: 'findme',
+    path: 'grep-target.txt',
+  }, dir, { readStateScope: 'grep-write' }));
+  assertOk('grep then overwrite', await executeBuiltinTool('write', {
+    path: 'grep-target.txt',
+    content: 'replaced\n',
+  }, dir, { readStateScope: 'grep-write' }));
+  await expectFile('grep-target.txt', 'replaced\n');
+
+  console.log('write-overwrite-guard smoke passed');
+} finally {
+  await rm(dir, { recursive: true, force: true });
+  await rm(DATA_DIR, { recursive: true, force: true });
+}