blun-king-cli 9.0.0 → 9.1.0

package/bin/king.js

@@ -1,4 +1,280 @@
 #!/usr/bin/env node
 'use strict';
 
-require('./blun');
+// This public entry must stay self-contained. Package-local modules are loaded
+// only after the update owner proves that the package root is not being replaced.
+const { createHash } = require('node:crypto');
+const fs = require('node:fs');
+const net = require('node:net');
+const os = require('node:os');
+const path = require('node:path');
+
+const LEASE_PROTOCOL_VERSION = 'BLUN_UPDATE_LEASE_V3';
+const LEASE_PROBE_TIMEOUT_MS = 500;
+const MAX_POSIX_SOCKET_PATH_BYTES = 96;
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function deriveLeaseEndpoint(role) {
+  const realpath = fs.realpathSync.native || fs.realpathSync;
+  let identity = realpath(PACKAGE_ROOT);
+  if (!fs.statSync(identity).isDirectory()) throw new Error('INVALID_PACKAGE_ROOT');
+  identity = identity.replaceAll('\\', '/');
+  if (process.platform === 'win32') identity = identity.toLowerCase();
+  const digest = createHash('sha256')
+    .update(`blun-update-v3\0${role}\0${identity}`)
+    .digest('hex');
+  const magic = `${LEASE_PROTOCOL_VERSION} ${digest}\n`;
+  if (process.platform === 'win32') {
+    return {
+      magic,
+      path: `\\\\.\\pipe\\blun-update-v3-${digest.slice(0, 32)}`,
+      platform: 'win32',
+    };
+  }
+
+  const uid = typeof process.getuid === 'function' ? process.getuid() : undefined;
+  const directoryName = `blun-update-${uid ?? digest.slice(0, 12)}`;
+  let directory = path.posix.join(os.tmpdir().replaceAll('\\', '/'), directoryName);
+  let socketPath = path.posix.join(directory, `lease-${digest.slice(0, 24)}.sock`);
+  if (Buffer.byteLength(socketPath, 'utf8') > MAX_POSIX_SOCKET_PATH_BYTES) {
+    directory = path.posix.join('/tmp', directoryName);
+    socketPath = path.posix.join(directory, `lease-${digest.slice(0, 24)}.sock`);
+  }
+  if (Buffer.byteLength(socketPath, 'utf8') > MAX_POSIX_SOCKET_PATH_BYTES) {
+    throw new Error('UPDATE_LEASE_SOCKET_PATH_TOO_LONG');
+  }
+  return { directory, magic, path: socketPath, platform: process.platform };
+}
+
+function ensurePrivateSocketDirectory(endpoint) {
+  if (endpoint.platform === 'win32') return;
+  fs.mkdirSync(endpoint.directory, { recursive: true, mode: 0o700 });
+  const stat = fs.lstatSync(endpoint.directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error('INVALID_UPDATE_LEASE_DIRECTORY');
+  }
+  if (typeof process.getuid === 'function'
+    && Number.isInteger(stat.uid)
+    && stat.uid !== process.getuid()) {
+    throw new Error('INVALID_UPDATE_LEASE_DIRECTORY_OWNER');
+  }
+  fs.chmodSync(endpoint.directory, 0o700);
+}
+
+function closeServer(server) {
+  return new Promise((resolve) => {
+    if (!server.listening) {
+      resolve();
+      return;
+    }
+    try {
+      server.close(() => resolve());
+    } catch {
+      resolve();
+    }
+  });
+}
+
+function listenForLease(endpoint) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer((socket) => {
+      socket.on('error', () => {});
+      socket.end(endpoint.magic);
+    });
+    const onError = (error) => {
+      server.removeListener('error', onError);
+      reject(error);
+    };
+    server.once('error', onError);
+    server.listen({ path: endpoint.path, exclusive: true }, () => {
+      server.removeListener('error', onError);
+      resolve(server);
+    });
+  });
+}
+
+function probeLease(endpoint) {
+  return new Promise((resolve) => {
+    let received = '';
+    let settled = false;
+    let socket;
+    const finish = (state) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket?.destroy();
+      } catch {}
+      // oxlint-disable-next-line promise/no-multiple-resolved -- settled is the idempotence guard.
+      resolve(state);
+    };
+    const timer = setTimeout(() => finish('foreign'), LEASE_PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+      socket = net.createConnection({ path: endpoint.path });
+      socket.setEncoding('utf8');
+      socket.on('data', (chunk) => {
+        received += String(chunk);
+        if (Buffer.byteLength(received, 'utf8') > Buffer.byteLength(endpoint.magic, 'utf8')) {
+          finish('foreign');
+        }
+      });
+      socket.once('end', () => finish(received === endpoint.magic ? 'owner' : 'foreign'));
+      socket.once('error', (error) => {
+        finish(error?.code === 'ECONNREFUSED' || error?.code === 'ENOENT'
+          ? 'stale'
+          : 'foreign');
+      });
+      socket.once('close', () => {
+        if (!settled) finish(received === endpoint.magic ? 'owner' : 'foreign');
+      });
+    } catch (error) {
+      finish(error?.code === 'ECONNREFUSED' || error?.code === 'ENOENT'
+        ? 'stale'
+        : 'foreign');
+    }
+  });
+}
+
+function observeSocket(endpoint) {
+  if (endpoint.platform === 'win32') return { state: 'not_applicable' };
+  try {
+    const stat = fs.lstatSync(endpoint.path);
+    if (!stat.isSocket() || stat.isSymbolicLink()) return { state: 'unsafe' };
+    return { dev: stat.dev, ino: stat.ino, state: 'socket' };
+  } catch (error) {
+    return error?.code === 'ENOENT' ? { state: 'missing' } : { state: 'unsafe' };
+  }
+}
+
+function removeObservedSocket(endpoint, observed) {
+  if (endpoint.platform === 'win32') return false;
+  try {
+    const stat = fs.lstatSync(endpoint.path);
+    if (observed.state !== 'socket'
+      || !stat.isSocket()
+      || stat.isSymbolicLink()
+      || stat.dev !== observed.dev
+      || stat.ino !== observed.ino) {
+      return false;
+    }
+    fs.unlinkSync(endpoint.path);
+    return true;
+  } catch (error) {
+    return error?.code === 'ENOENT' && observed.state === 'missing';
+  }
+}
+
+function recordSocket(endpoint) {
+  if (endpoint.platform === 'win32') return undefined;
+  const stat = fs.lstatSync(endpoint.path);
+  if (!stat.isSocket() || stat.isSymbolicLink()) throw new Error('INVALID_UPDATE_LEASE_SOCKET');
+  fs.chmodSync(endpoint.path, 0o600);
+  return { dev: stat.dev, ino: stat.ino };
+}
+
+function removeOwnedSocket(endpoint, identity) {
+  if (endpoint.platform === 'win32' || !identity) return;
+  try {
+    const stat = fs.lstatSync(endpoint.path);
+    if (stat.isSocket()
+      && !stat.isSymbolicLink()
+      && stat.dev === identity.dev
+      && stat.ino === identity.ino) {
+      fs.unlinkSync(endpoint.path);
+    }
+  } catch {}
+}
+
+async function acquireNoticeLease() {
+  let endpoint;
+  try {
+    endpoint = deriveLeaseEndpoint('notice');
+    ensurePrivateSocketDirectory(endpoint);
+  } catch {
+    return { acquired: false, reason: 'unavailable' };
+  }
+
+  let server;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      server = await listenForLease(endpoint);
+      break;
+    } catch (error) {
+      if (error?.code !== 'EADDRINUSE') return { acquired: false, reason: 'unavailable' };
+      const observed = observeSocket(endpoint);
+      const state = await probeLease(endpoint);
+      if (state === 'owner') return { acquired: false, reason: 'busy' };
+      if (state !== 'stale' || attempt > 0) return { acquired: false, reason: 'unavailable' };
+      if (endpoint.platform === 'win32') continue;
+      if (!removeObservedSocket(endpoint, observed)) {
+        return { acquired: false, reason: 'unavailable' };
+      }
+    }
+  }
+  if (!server) return { acquired: false, reason: 'unavailable' };
+
+  let identity;
+  try {
+    identity = recordSocket(endpoint);
+  } catch {
+    await closeServer(server);
+    return { acquired: false, reason: 'unavailable' };
+  }
+
+  let owned = true;
+  let released = false;
+  server.on('error', () => { owned = false; });
+  server.on('close', () => { owned = false; });
+  return {
+    acquired: true,
+    lease: Object.freeze({
+      assertOwned() {
+        if (!owned || !server.listening) throw new Error('UPDATE_LEASE_LOST');
+      },
+      async release() {
+        if (released) return;
+        released = true;
+        owned = false;
+        await closeServer(server);
+        removeOwnedSocket(endpoint, identity);
+      },
+    }),
+  };
+}
+
+async function installLeaseIsClear() {
+  try {
+    const endpoint = deriveLeaseEndpoint('install');
+    ensurePrivateSocketDirectory(endpoint);
+    return await probeLease(endpoint) === 'stale';
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const result = await acquireNoticeLease();
+  if (!result.acquired) return;
+  try {
+    if (!await installLeaseIsClear()) return;
+    result.lease.assertOwned();
+    const { runLauncher } = require('./launcher-runtime');
+    result.lease.assertOwned();
+    const filename = path.basename(__filename).toLowerCase();
+    await runLauncher({
+      mode: filename.startsWith('king') ? 'king' : 'blun',
+      noticeLease: result.lease,
+    });
+  } finally {
+    await result.lease.release();
+  }
+}
+
+// oxlint-disable-next-line unicorn/prefer-top-level-await -- Public npm bins are CommonJS.
+void main().catch((error) => {
+  // oxlint-disable-next-line no-console -- Fatal launcher errors belong on stderr.
+  console.error('BLUN Start fehlgeschlagen: '
+    + (error && error.message ? error.message : String(error)));
+  process.exitCode = 1;
+});

package/bin/launcher-mode.js

@@ -5,7 +5,14 @@ const LAUNCHER_MODES = Object.freeze({
   KING: 'king',
 });
 
-const NPM_PACKAGE_UPDATE_COMMAND = 'npm install -g blun-king-cli@latest';
+const LAUNCHER_HELP_TEXT = [
+  '',
+  'Launchers:',
+  '  blun  Starts the CLI without automatically attaching Telegram.',
+  '  king  Starts the same CLI and automatically attaches the configured Telegram channel.',
+  '  Both use the same version, account, model, and commands.',
+  '',
+].join('\n');
 
 function launcherModeFromArgv(argv) {
   const entry = argv[1] || '';
@@ -14,10 +21,11 @@ function launcherModeFromArgv(argv) {
   return command === LAUNCHER_MODES.KING ? LAUNCHER_MODES.KING : LAUNCHER_MODES.BLUN;
 }
 
-function createLauncherEnvironment(sourceEnv, mode) {
+function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion) {
   return {
     ...sourceEnv,
     BLUN_NO_AUTO_UPDATE: '1',
+    BLUN_PUBLIC_PACKAGE_VERSION: publicPackageVersion,
     BLUN_TELEGRAM_ATTACH: mode === LAUNCHER_MODES.KING ? 'on' : 'off',
     BLUN_TELEGRAM_HEADLESS: 'off',
   };
@@ -29,10 +37,14 @@ function isNpmPackageUpdateRequest(args) {
   return command === 'update' || command === 'upgrade';
 }
 
+function launcherHelpText() {
+  return LAUNCHER_HELP_TEXT;
+}
+
 module.exports = {
   LAUNCHER_MODES,
-  NPM_PACKAGE_UPDATE_COMMAND,
   createLauncherEnvironment,
   isNpmPackageUpdateRequest,
+  launcherHelpText,
   launcherModeFromArgv,
 };

package/bin/launcher-runtime.js

@@ -0,0 +1,293 @@
+'use strict';
+/*
+ * BLUN CLI Launcher (npm) — Erststart richtet alles ein:
+ *   1. King richtet das Telegram-Plugin im BLUN_HOME ein
+ * Danach: TUI starten. Anmeldung und Modellkatalog kommen ueber BLUN OAuth.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { spawn } = require('node:child_process');
+const {
+  LAUNCHER_MODES,
+  createLauncherEnvironment,
+  isNpmPackageUpdateRequest,
+  launcherHelpText,
+  launcherModeFromArgv,
+} = require('./launcher-mode');
+const { installManagedTelegramPlugin } = require('./plugin-bootstrap');
+const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
+const { tryAcquireUpdateLease } = require('./update-lease');
+const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
+const {
+  ensurePrivateDirectory,
+  securePrivateFile,
+  securePrivateTree,
+  writePrivateFile,
+} = require('./private-paths');
+
+const PKG = path.resolve(__dirname, '..');
+const ARGS = process.argv.slice(2);
+const CORE_LOAD_TIMEOUT_MS = 30_000;
+
+function normalizeWindowsPath(value) {
+  return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
+}
+
+function resolveLauncherPrivatePaths(options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const configuredHome = String(env.BLUN_HOME || '').trim();
+  if (platform !== 'win32') {
+    const userHome = (options.homedir || os.homedir)();
+    return {
+      blunHome: configuredHome ? path.resolve(configuredHome) : path.join(userHome, '.blun'),
+      userHome,
+    };
+  }
+
+  const fsImpl = options.fsImpl || fs;
+  const userInfo = (options.userInfo || os.userInfo)();
+  const reportedHome = String(userInfo?.homedir || '').trim();
+  if (!path.win32.isAbsolute(reportedHome) || reportedHome.startsWith('\\\\')) {
+    throw new Error('Das lokale Windows-Benutzerprofil konnte nicht sicher bestimmt werden.');
+  }
+  const resolvedHome = path.win32.resolve(reportedHome);
+  const stat = fsImpl.lstatSync(resolvedHome);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error('Das lokale Windows-Benutzerprofil ist kein vertrauenswuerdiges Verzeichnis.');
+  }
+  const realpath = fsImpl.realpathSync.native || fsImpl.realpathSync;
+  const userHome = path.win32.normalize(realpath(resolvedHome));
+  const volumeRoot = path.win32.parse(userHome).root;
+  if (!/^[A-Za-z]:\\$/u.test(volumeRoot)
+    || normalizeWindowsPath(userHome) !== normalizeWindowsPath(resolvedHome)) {
+    throw new Error('Das lokale Windows-Benutzerprofil ist kein kanonischer lokaler Pfad.');
+  }
+
+  const blunHome = path.win32.join(userHome, '.blun');
+  if (configuredHome
+    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
+    throw new Error(`BLUN_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
+  }
+  return { blunHome, userHome };
+}
+
+function readPackageVersion() {
+  const { version } = JSON.parse(fs.readFileSync(path.join(PKG, 'package.json'), 'utf8'));
+  if (typeof version !== 'string' || version.length === 0) {
+    throw new Error('Ungueltige Paketversion in package.json');
+  }
+  return version;
+}
+
+function spawnProtectedCore(args, env, cwd) {
+  const child = spawn(
+    process.execPath,
+    [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
+    {
+      cwd,
+      detached: true,
+      env,
+      stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+      windowsHide: true,
+    },
+  );
+  let loadedSettled = false;
+  let completedSettled = false;
+  let resolveLoaded;
+  let resolveCompleted;
+  const loadTimer = setTimeout(() => {
+    try {
+      child.kill();
+    } catch {}
+  }, CORE_LOAD_TIMEOUT_MS);
+  const loaded = new Promise((resolve) => { resolveLoaded = resolve; });
+  const completed = new Promise((resolve) => { resolveCompleted = resolve; });
+  const settleLoaded = (value) => {
+    if (loadedSettled) return;
+    loadedSettled = true;
+    clearTimeout(loadTimer);
+    resolveLoaded(value);
+  };
+  const settleCompleted = (result) => {
+    if (completedSettled) return;
+    completedSettled = true;
+    for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
+    settleLoaded(false);
+    resolveCompleted(result);
+  };
+  const signalHandlers = new Map();
+  for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM']) {
+    const handler = () => {
+      try {
+        child.kill(signal);
+      } catch {}
+    };
+    signalHandlers.set(signal, handler);
+    process.once(signal, handler);
+  }
+  child.on('message', (message) => {
+    if (message?.type !== CORE_LOADED_MESSAGE) return;
+    settleLoaded(true);
+    try {
+      child.disconnect();
+    } catch {}
+  });
+  child.once('error', (error) => settleCompleted({ error }));
+  child.once('exit', (code, signal) => settleCompleted({ code, signal }));
+  return { child, completed, loaded };
+}
+
+async function superviseProtectedCore(args, env, cwd, releaseNotice) {
+  const core = spawnProtectedCore(args, env, cwd);
+  const loaded = await core.loaded;
+  await releaseNotice();
+  const result = await core.completed;
+  if (result.error) throw result.error;
+  return exitCodeForChild(result, loaded);
+}
+
+function exitCodeForChild(result, loaded) {
+  if (!loaded && result.code === 75) return 0;
+  if (Number.isInteger(result.code)) return result.code;
+  if (result.signal === 'SIGINT') return 130;
+  if (result.signal === 'SIGTERM') return 143;
+  return 1;
+}
+
+async function runLauncher(options = {}) {
+  const callerCwd = process.cwd();
+  const mode = options.mode || launcherModeFromArgv(process.argv);
+  const explicitUpdateRequest = isNpmPackageUpdateRequest(ARGS);
+  const noticeResult = options.noticeLease
+    ? { acquired: true, lease: options.noticeLease }
+    : await tryAcquireUpdateLease({ packageRoot: PKG, role: 'notice' });
+  if (!noticeResult.acquired) {
+    if (explicitUpdateRequest) {
+      process.stderr.write('Das Update konnte nicht verifiziert werden.\n');
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const noticeLease = noticeResult.lease;
+  let noticeReleased = false;
+  const releaseNotice = async () => {
+    if (noticeReleased) return;
+    noticeReleased = true;
+    await noticeLease.release();
+  };
+
+  try {
+    const installProbe = await tryAcquireUpdateLease({ packageRoot: PKG, role: 'install' });
+    if (!installProbe.acquired) {
+      if (explicitUpdateRequest) {
+        process.stderr.write('Das Update konnte nicht verifiziert werden.\n');
+        process.exitCode = 1;
+      }
+      return;
+    }
+    await installProbe.lease.release();
+
+    if (ARGS.some((arg) => arg === '--version' || arg === '-V')) {
+      process.stdout.write(`${readPackageVersion()}\n`);
+      return;
+    }
+
+    if (explicitUpdateRequest) {
+      const privatePaths = resolveLauncherPrivatePaths();
+      const result = await runExplicitUpdate({
+        currentVersion: readPackageVersion(),
+        env: process.env,
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        blunDir: privatePaths.blunHome,
+        packageRoot: PKG,
+        noticeLease,
+        request: ARGS[0],
+      });
+      if (result.kind === 'failed') process.exitCode = result.exitCode || 1;
+      return;
+    }
+
+    if (ARGS.some((arg) => arg === '--help' || arg === '-h')) {
+      process.stdout.write(launcherHelpText());
+      const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
+      const informationalEnv = { ...process.env };
+      delete informationalEnv.BLUN_HOME;
+      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
+      process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
+      return;
+    }
+
+    const privatePaths = resolveLauncherPrivatePaths();
+    const blunDir = privatePaths.blunHome;
+    ensurePrivateDirectory(blunDir);
+
+    // --- 1. Oeffentlicher npm-Update-Dialog. -------------------------------
+    const updateResult = await runUpdateNotice({
+      currentVersion: readPackageVersion(),
+      argv: ARGS,
+      env: process.env,
+      stdin: process.stdin,
+      stdout: process.stdout,
+      stderr: process.stderr,
+      blunDir,
+      packageRoot: PKG,
+      noticeLease,
+    });
+    if (updateResult.kind === 'installed' || updateResult.kind === 'update_in_progress') return;
+
+  // --- 2. Bestehende Konfiguration absichern -------------------------------
+  // Ein frischer Start bleibt absichtlich ohne statischen Anbieter. /login
+  // provisioniert King ueber den BLUN-OAuth-Server.
+    const cfgFile = path.join(blunDir, 'config.toml');
+    if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
+
+  // --- 3. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
+    if (mode === LAUNCHER_MODES.KING) {
+      installManagedTelegramPlugin({ packageRoot: PKG, blunDir });
+      const channelsDir = path.join(blunDir, 'channels');
+      const channelDir = path.join(channelsDir, 'telegram');
+      ensurePrivateDirectory(channelsDir);
+      ensurePrivateDirectory(channelDir);
+      const envFile = path.join(channelDir, '.env');
+      if (!fs.existsSync(envFile)) {
+        writePrivateFile(envFile, 'BLUN_TELEGRAM_BOT_TOKEN=HIER_DEIN_BOT_TOKEN_EINFUEGEN\n');
+      } else {
+        securePrivateFile(envFile);
+      }
+    }
+
+  // --- 3b. Built-in-Skills installieren (fehlende ergaenzen, nie
+  //         vorhandene ueberschreiben — User-Anpassungen bleiben) -----------
+    const skillsSrc = path.join(PKG, 'skills');
+    const skillsDst = path.join(blunDir, 'skills');
+    if (fs.existsSync(skillsSrc)) {
+      if (fs.existsSync(skillsDst)) securePrivateTree(skillsDst);
+      else ensurePrivateDirectory(skillsDst);
+      for (const entry of fs.readdirSync(skillsSrc)) {
+        const dst = path.join(skillsDst, entry);
+        if (!fs.existsSync(dst)) {
+          fs.cpSync(path.join(skillsSrc, entry), dst, { recursive: true });
+        }
+      }
+    }
+
+    // --- 4. Start -----------------------------------------------------------
+    const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
+    env.BLUN_HOME = blunDir;
+    env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
+    process.exitCode = await superviseProtectedCore(
+      ['--yolo', ...ARGS],
+      env,
+      callerCwd,
+      releaseNotice,
+    );
+  } finally {
+    await releaseNotice();
+  }
+}
+
+module.exports = { resolveLauncherPrivatePaths, runLauncher };

package/bin/plugin-bootstrap.js

@@ -4,7 +4,11 @@ const { randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { ensurePrivateDirectory, writePrivateFile } = require('./private-paths');
+const {
+  ensurePrivateDirectory,
+  securePrivateFile,
+  writePrivateFile,
+} = require('./private-paths');
 
 function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -81,10 +85,10 @@ function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().t
   const pluginRoot = path.join(managedDir, 'telegram');
   const installedFile = path.join(pluginsDir, 'installed.json');
 
+  ensurePrivateDirectory(pluginsDir);
+  if (fs.existsSync(installedFile)) securePrivateFile(installedFile);
   const installed = readInstalledPlugins(installedFile);
   const updatedInstalled = updatedInstalledPlugins(installed, pluginRoot, now);
-
-  ensurePrivateDirectory(pluginsDir);
   ensurePrivateDirectory(managedDir);
   const nonce = `${process.pid}-${randomUUID()}`;
   const stagingRoot = path.join(managedDir, `.telegram-${nonce}.tmp`);
@@ -92,8 +96,11 @@ function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().t
   let hadPreviousPlugin = false;
   let installedNewPlugin = false;
   try {
+    if (fs.existsSync(pluginRoot)) {
+      ensurePrivateDirectory(pluginRoot);
+      hadPreviousPlugin = true;
+    }
     fs.cpSync(sourceRoot, stagingRoot, { recursive: true, force: true });
-    hadPreviousPlugin = fs.existsSync(pluginRoot);
     if (hadPreviousPlugin) fs.renameSync(pluginRoot, backupRoot);
     try {
       fs.renameSync(stagingRoot, pluginRoot);