lean-browser-use 0.0.0-stage → 0.1.0

package/src/uninstall.mjs

@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configDir, loadManifest, manifestPath, safePath, noSymlinks } from './paths.mjs';
+import { readSettings, ownedHook } from './install.mjs';
+import { exists, sha256, atomicWrite, refusal } from './util.mjs';
+
+export function uninstall(options = {}) {
+  const cfg = noSymlinks(configDir(options));
+  const manifest = loadManifest(cfg);
+  const settings = readSettings(cfg);
+  const removals = [], edited = [];
+  for (const item of manifest.files) {
+    const file = safePath(cfg, item.path);
+    if (!exists(file)) continue;
+    if (!fs.lstatSync(file).isFile()) throw refusal('Refused non-file manifest entry.');
+    (sha256(fs.readFileSync(file)) === item.sha256 ? removals : edited).push(item);
+  }
+  let settingsChanged = false;
+  for (const [event, entries] of Object.entries(settings.hooks || {})) {
+    const kept = [];
+    for (const entry of entries) {
+      const hooks = entry.hooks.filter(hook => !ownedHook(hook));
+      if (hooks.length !== entry.hooks.length) settingsChanged = true;
+      if (hooks.length || !entry.hooks.length) kept.push({ ...entry, hooks });
+    }
+    settings.hooks[event] = kept;
+  }
+  const removalSet = new Set(removals.map(f => f.path));
+  const directories = [];
+  for (const dir of [...manifest.directories].sort((a, b) => b.length - a.length)) {
+    const full = safePath(cfg, dir);
+    if (!exists(full)) continue;
+    if (!fs.lstatSync(full).isDirectory()) throw refusal('Refused non-directory manifest entry.');
+    const emptyAfter = fs.readdirSync(full).every(name => {
+      const child = `${dir}/${name}`;
+      return removalSet.has(child) || directories.includes(child) || child === 'lean-browser-use/manifest.json';
+    });
+    if (emptyAfter) directories.push(dir);
+  }
+  for (const item of removals) console.log(`Remove ${item.path}`);
+  for (const item of edited) console.log(`Keep edited ${item.path}`);
+  if (settingsChanged) console.log('Remove owned hook entries from settings.json.');
+  for (const dir of directories) console.log(`Remove empty directory ${dir}`);
+  const removeConfig = manifest.configDirectoryCreated && fs.readdirSync(cfg).every(name => directories.includes(name));
+  console.log('Remove lean-browser-use/manifest.json last.');
+  if (removeConfig) console.log('Remove empty config directory.');
+  if (manifest.manualHooks) console.log('Manual step: remove any hook entries pasted elsewhere by hand.');
+  if (manifest.backupWritten) console.log('Saved settings backup remains at settings.json.lean-browser-use.bak.');
+  if (options.dry) return edited.length ? 3 : 0;
+  for (const item of removals) {
+    const file = safePath(cfg, item.path);
+    // Recheck both the object and its bytes immediately before unlinking.
+    if (!fs.lstatSync(file).isFile() || sha256(fs.readFileSync(file)) !== item.sha256) throw refusal('File changed during uninstall; preserved.');
+    fs.unlinkSync(file);
+  }
+  if (settingsChanged) atomicWrite(noSymlinks(path.join(cfg, 'settings.json')), `${JSON.stringify(settings, null, 2)}\n`);
+  const removeEmpty = dir => {
+    const full = safePath(cfg, dir);
+    if (exists(full) && fs.lstatSync(full).isDirectory() && fs.readdirSync(full).length === 0) fs.rmdirSync(full);
+  };
+  for (const dir of directories) if (dir !== 'lean-browser-use') removeEmpty(dir);
+  const file = noSymlinks(manifestPath(cfg));
+  if (!fs.lstatSync(file).isFile()) throw refusal('Manifest changed during uninstall.');
+  fs.unlinkSync(file);
+  if (directories.includes('lean-browser-use')) removeEmpty('lean-browser-use');
+  if (removeConfig && fs.readdirSync(noSymlinks(cfg)).length === 0) fs.rmdirSync(noSymlinks(cfg));
+  return edited.length ? 3 : 0;
+}

package/src/util.mjs

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { randomBytes, createHash } from 'node:crypto';
+
+export const sha256 = value => createHash('sha256').update(value).digest('hex');
+export const readJSON = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+export const exists = file => { try { fs.lstatSync(file); return true; } catch (e) { if (e.code === 'ENOENT') return false; throw e; } };
+export function atomicWrite(file, data, mode = 0o600) {
+  const tmp = `${file}.${randomBytes(8).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(tmp, data, { mode, flag: 'wx' });
+    fs.renameSync(tmp, file);
+  } finally { if (exists(tmp)) fs.unlinkSync(tmp); }
+}
+export function walk(dir) {
+  if (!exists(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+    .flatMap(e => e.isDirectory() ? walk(path.join(dir, e.name)) : e.isFile() ? [path.join(dir, e.name)] : []);
+}
+export function refusal(message) { const error = new Error(message); error.exitCode = 2; return error; }
+export const shellQuote = text => `'${String(text).replaceAll("'", "'\\''")}'`;
+
+// Regular files also work in sandboxes that restrict child-process pipe handles.
+export function captured(command, args = [], options = {}) {
+  const dir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'lbu-process-'));
+  const input = path.join(dir, 'stdin'), output = path.join(dir, 'stdout'), errors = path.join(dir, 'stderr');
+  fs.writeFileSync(input, options.input ?? '');
+  const fds = [fs.openSync(input, 'r'), fs.openSync(output, 'w'), fs.openSync(errors, 'w')];
+  try {
+    const result = spawnSync(command, args, { ...options, input: undefined, stdio: fds });
+    return { ...result, stdout: fs.readFileSync(output, 'utf8'), stderr: fs.readFileSync(errors, 'utf8') };
+  } finally { for (const fd of fds) fs.closeSync(fd); fs.rmSync(dir, { recursive: true, force: true }); }
+}