@mohammadhprp/system-prompt 0.11.2 → 0.12.1

package/src/installer.js

@@ -1,6 +1,7 @@
 import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import { mkdir, copyFile, writeFile, readdir, stat, readFile, rm } from 'node:fs/promises';
+import { dirname, relative, resolve, isAbsolute } from 'node:path';
+import { mkdir, writeFile, readdir, stat, lstat, readFile, rm } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 
 import { categories } from './catalog.js';
 import { loadMcpConfigs, generateOpenCodeConfig, generateTuiConfig } from './agent-configs.js';
@@ -97,46 +98,134 @@ export async function getPackageVersion() {
 export async function loadLockFile(absTarget) {
   try {
     const content = await readFile(resolve(absTarget, 'system-prompt-lock.json'), 'utf-8');
-    return JSON.parse(content);
-  } catch {
-    return null;
+    const lock = JSON.parse(content);
+    validateLock(lock);
+    return lock;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    if (error instanceof SyntaxError || error.message?.startsWith('Invalid system-prompt lock')) {
+      throw new Error(`${error.message}. Remove or repair system-prompt-lock.json before reinstalling.`);
+    }
+    throw error;
   }
 }
 
-function resolveSource(subpath) {
-  return resolve(packageRoot, subpath);
+function validateLock(lock) {
+  if (!lock || typeof lock !== 'object' || Array.isArray(lock)) {
+    throw new Error('Invalid system-prompt lock: expected an object');
+  }
+  if (!lock.selections || typeof lock.selections !== 'object' || Array.isArray(lock.selections)) {
+    throw new Error('Invalid system-prompt lock: selections must be an object');
+  }
+  for (const [category, ids] of Object.entries(lock.selections)) {
+    const config = categories[category];
+    if (!config || !Array.isArray(ids) || ids.some(id => typeof id !== 'string')) {
+      throw new Error(`Invalid system-prompt lock: invalid ${category} selection`);
+    }
+    const knownIds = new Set(config.items.map(item => item.id));
+    if (ids.some(id => !knownIds.has(id))) {
+      throw new Error(`Invalid system-prompt lock: unknown ${category} item`);
+    }
+  }
+  if (lock.managedFiles !== undefined) {
+    if (!lock.managedFiles || typeof lock.managedFiles !== 'object' || Array.isArray(lock.managedFiles)) {
+      throw new Error('Invalid system-prompt lock: managedFiles must be an object');
+    }
+    for (const [path, checksum] of Object.entries(lock.managedFiles)) {
+      if (path.startsWith('/') || path.split('/').includes('..') || !/^[a-f0-9]{64}$/.test(checksum)) {
+        throw new Error('Invalid system-prompt lock: unsafe managed file entry');
+      }
+    }
+  }
 }
 
-function targetSubdir(sourceDir) {
-  return sourceDir.replace(/^framework\//, '');
+function hash(content) {
+  return createHash('sha256').update(content).digest('hex');
 }
 
-async function copyDir(src, dest) {
-  await mkdir(dest, { recursive: true });
+function isInside(parent, child) {
+  const relativePath = relative(parent, child);
+  return relativePath === '' || (!relativePath.startsWith('../') && relativePath !== '..' && !isAbsolute(relativePath));
+}
+
+async function canWrite(destFile, relativePath, oldLock, force) {
+  if (force) return true;
+  try {
+    const existing = await readFile(destFile);
+    const previousHash = oldLock?.managedFiles?.[relativePath];
+    return Boolean(previousHash && previousHash === hash(existing));
+  } catch (error) {
+    if (error.code === 'ENOENT') return true;
+    throw error;
+  }
+}
+
+async function writeManagedFile(destFile, content, relativePath, options) {
+  await assertSafeDestination(options.targetDir, destFile);
+  if (!options.allowExistingMerge && !(await canWrite(destFile, relativePath, options.oldLock, options.force))) {
+    console.warn(`  ⚠  Preserving existing file: ${relativePath}`);
+    return false;
+  }
+  if (!options.dryRun) await mkdir(dirname(destFile), { recursive: true });
+  if (!options.dryRun) await writeFile(destFile, content);
+  options.managedFiles[relativePath] = hash(content);
+  return true;
+}
+
+async function copyDir(src, dest, relativeDir, options) {
+  if (!options.dryRun) await mkdir(dest, { recursive: true });
   const entries = await readdir(src, { withFileTypes: true });
 
   for (const entry of entries) {
     if (entry.name === '.DS_Store') continue;
     const srcPath = resolve(src, entry.name);
     const destPath = resolve(dest, entry.name);
+    const relativePath = `${relativeDir}/${entry.name}`;
 
     if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
+      await copyDir(srcPath, destPath, relativePath, options);
     } else if (entry.isFile()) {
-      await mkdir(dirname(destPath), { recursive: true });
-      await copyFile(srcPath, destPath);
+      const content = await readFile(srcPath);
+      await writeManagedFile(destPath, content, relativePath, options);
     }
   }
 }
 
-async function isRemoved(category, id) {
-  const catConfig = categories[category];
-  if (!catConfig) return false;
-  const item = catConfig.items.find(i => i.id === id);
-  return item?.removed === true;
+function sourceMissing(error) {
+  return error?.code === 'ENOENT';
+}
+
+function assertSafePath(targetDir, path) {
+  if (!isInside(targetDir, path)) {
+    throw new Error(`Refusing to access path outside installation directory: ${path}`);
+  }
+}
+
+async function assertSafeDestination(targetDir, path) {
+  assertSafePath(targetDir, path);
+  try {
+    if ((await lstat(targetDir)).isSymbolicLink()) {
+      throw new Error(`Refusing to install through symlink target: ${targetDir}`);
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  const relativePath = relative(targetDir, path);
+  let current = targetDir;
+  for (const part of relativePath.split('/').filter(Boolean)) {
+    current = resolve(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) {
+        throw new Error(`Refusing to access symlink inside installation directory: ${current}`);
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') break;
+      throw error;
+    }
+  }
 }
 
-async function copySelectedDirs(targetDir, category, selectedIds) {
+async function copySelectedDirs(targetDir, category, selectedIds, options) {
   const catConfig = categories[category];
   if (!catConfig || !selectedIds?.length) return;
 
@@ -148,81 +237,49 @@ async function copySelectedDirs(targetDir, category, selectedIds) {
 
     const srcPath = resolveSource(`${catConfig.sourceDir}/${id}`);
     const destPath = resolve(destParent, id);
+    await assertSafeDestination(targetDir, destPath);
 
     try {
       await stat(srcPath);
-      await copyDir(srcPath, destPath);
-    } catch {
-      console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}`);
+      await copyDir(srcPath, destPath, `${relativeDir}/${id}`, options);
+    } catch (error) {
+      if (sourceMissing(error)) {
+        console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}`);
+        continue;
+      }
+      throw error;
     }
   }
 }
 
-async function copySelectedFiles(targetDir, category, selectedIds, skipIfExists = false) {
+async function copySelectedFiles(targetDir, category, selectedIds, options) {
   const catConfig = categories[category];
   if (!catConfig || !selectedIds?.length) return;
 
   const relativeDir = targetSubdir(catConfig.sourceDir);
   const destParent = resolve(targetDir, relativeDir);
-  await mkdir(destParent, { recursive: true });
+  if (!options.dryRun) await mkdir(destParent, { recursive: true });
 
   for (const id of selectedIds) {
     if (await isRemoved(category, id)) continue;
 
     const srcFile = resolveSource(`${catConfig.sourceDir}/${id}.md`);
     const destFile = resolve(destParent, `${id}.md`);
+    await assertSafeDestination(targetDir, destFile);
     try {
-      await stat(srcFile);
-      if (skipIfExists) {
-        try {
-          await stat(destFile);
-          continue;
-        } catch {
-          // dest doesn't exist — proceed to copy
-        }
-      }
-      await copyFile(srcFile, destFile);
-    } catch {
-      console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}.md`);
-    }
-  }
-}
-
-function parseEnv(content) {
-  const vars = new Map();
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eqIndex = trimmed.indexOf('=');
-    if (eqIndex === -1) {
-      vars.set(trimmed, '');
-    } else {
-      const key = trimmed.slice(0, eqIndex).trim();
-      const value = trimmed.slice(eqIndex + 1).trim();
-      if (key) vars.set(key, value);
-    }
-  }
-  return vars;
-}
-
-async function collectMcpEnvExamples(mcpIds) {
-  const combined = new Map();
-  for (const id of mcpIds) {
-    try {
-      const examplePath = resolveSource(`framework/mcps/${id}/configs/.env.example`);
-      const content = await readFile(examplePath, 'utf-8');
-      const parsed = parseEnv(content);
-      for (const [key, value] of parsed) {
-        if (!combined.has(key)) combined.set(key, value);
+      const content = await readFile(srcFile);
+      await writeManagedFile(destFile, content, `${relativeDir}/${id}.md`, options);
+    } catch (error) {
+      if (sourceMissing(error)) {
+        console.warn(`  ⚠  Source not found: ${catConfig.sourceDir}/${id}.md`);
+        continue;
       }
-    } catch {
-      // Silently skip MCPs without .env.example
+      throw error;
     }
   }
-  return combined;
 }
 
-async function deleteSelectedItems(absTarget, category, ids) {
+async function deleteSelectedItems(absTarget, category, ids, oldLock, force, dryRun) {
   const catConfig = categories[category];
   if (!catConfig || !ids?.length) return;
 
@@ -230,139 +287,265 @@ async function deleteSelectedItems(absTarget, category, ids) {
   if (!FILE_BASED.has(category) && category !== 'skills' && category !== 'styles') return;
 
   const relativeDir = targetSubdir(catConfig.sourceDir);
-  const destParent = resolve(absTarget, relativeDir);
-
   for (const id of ids) {
-    const destPath = FILE_BASED.has(category)
-      ? resolve(destParent, `${id}.md`)
-      : resolve(destParent, id);
-    try {
-      await rm(destPath, { recursive: true, force: true });
-    } catch {
-      // File may not exist — ignore
+    const relativePath = FILE_BASED.has(category)
+      ? `${relativeDir}/${id}.md`
+      : `${relativeDir}/${id}`;
+    const destPath = resolve(absTarget, relativePath);
+    await assertSafeDestination(absTarget, destPath);
+    if (!force && oldLock) {
+      const managedEntries = Object.entries(oldLock.managedFiles || {})
+        .filter(([path]) => path === relativePath || path.startsWith(`${relativePath}/`));
+      if (managedEntries.length === 0) {
+        console.warn(`  ⚠  Preserving unmanaged item: ${relativePath}`);
+        continue;
+      }
+      let modified = false;
+      for (const [path, checksum] of managedEntries) {
+        await assertSafeDestination(absTarget, resolve(absTarget, path));
+        try {
+          if (hash(await readFile(resolve(absTarget, path))) !== checksum) modified = true;
+        } catch (error) {
+          if (!sourceMissing(error)) throw error;
+        }
+      }
+      if (modified) {
+        console.warn(`  ⚠  Preserving modified item: ${relativePath}`);
+        continue;
+      }
+      if (!FILE_BASED.has(category)) {
+        if (!dryRun) {
+          for (const [path] of managedEntries) await rm(resolve(absTarget, path), { force: true });
+        }
+        continue;
+      }
     }
+    if (!dryRun) await rm(destPath, { recursive: true, force: true });
   }
 }
 
-async function writeMergedEnv(absTarget, examples) {
-  if (examples.size === 0) return;
-
-  const envPath = resolve(absTarget, '.env');
-  const existing = new Map();
-
+async function mergeJsonFile(destFile, generated, relativePath, options, previousGenerated = generated) {
+  let existing = {};
   try {
-    const existingContent = await readFile(envPath, 'utf-8');
-    const parsed = parseEnv(existingContent);
-    for (const [key, value] of parsed) existing.set(key, value);
-  } catch {
-    // File doesn't exist yet
+    existing = JSON.parse(await readFile(destFile, 'utf-8'));
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      if (error instanceof SyntaxError) throw new Error(`Cannot merge invalid JSON file: ${relativePath}`);
+      throw error;
+    }
   }
-
-  const merged = new Map(existing);
-  for (const [key, value] of examples) {
-    if (!merged.has(key)) merged.set(key, value);
+  const merged = { ...existing, ...generated };
+  if (Array.isArray(existing.instructions) && Array.isArray(generated.instructions)) {
+    const previous = new Set(previousGenerated.instructions || []);
+    merged.instructions = [...new Set([
+      ...existing.instructions.filter(item => !previous.has(item)),
+      ...generated.instructions,
+    ])];
   }
-
-  if (merged.size === 0) return;
-
-  const lines = [];
-  for (const [key, value] of merged) {
-    lines.push(`${key}=${value}`);
+  if (Array.isArray(existing.plugin)) {
+    const previous = new Set(previousGenerated.plugin || []);
+    const plugins = [...new Set([
+      ...existing.plugin.filter(item => !previous.has(item)),
+      ...(generated.plugin || []),
+    ])];
+    if (plugins.length) merged.plugin = plugins;
+    else delete merged.plugin;
+  }
+  for (const key of ['mcp', 'references']) {
+    if (existing[key] && typeof existing[key] === 'object') {
+      const previous = previousGenerated[key] || {};
+      const preserved = Object.fromEntries(Object.entries(existing[key]).filter(([name]) => !(name in previous)));
+      const values = { ...preserved, ...(generated[key] || {}) };
+      if (Object.keys(values).length) merged[key] = values;
+      else delete merged[key];
+    }
   }
-  lines.push('');
+  return writeManagedFile(destFile, Buffer.from(JSON.stringify(merged, null, 4)), relativePath, {
+    ...options,
+    allowExistingMerge: !options.oldLock,
+  });
+}
 
-  await writeFile(envPath, lines.join('\n'));
+async function mergeGitignore(destFile, options) {
+  let existing = '';
+  try {
+    existing = await readFile(destFile, 'utf-8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  const lines = new Set(existing.split('\n').filter(Boolean));
+  for (const line of OPENCODE_GITIGNORE.split('\n').filter(Boolean)) lines.add(line);
+  return writeManagedFile(destFile, Buffer.from(`${[...lines].join('\n')}\n`), '.gitignore', {
+    ...options,
+    allowExistingMerge: !options.oldLock,
+  });
 }
 
-function generateAgentsMd({ selections }) {
-  return AGENTS_MD;
+export function validateSelections(selections) {
+  if (!selections || typeof selections !== 'object' || Array.isArray(selections)) {
+    throw new Error('Selections must be an object');
+  }
+  for (const [category, ids] of Object.entries(selections)) {
+    const config = categories[category];
+    if (!config || !Array.isArray(ids)) throw new Error(`Unknown or invalid category: ${category}`);
+    const knownIds = new Set(config.items.map(item => item.id));
+    if (ids.some(id => !knownIds.has(id))) throw new Error(`Unknown ${category} item selected`);
+  }
+  return selections;
 }
 
-export async function install({ targetDir, agentType, selections, includeAgentsMd = true, writeAgentsMd, oldSelections }) {
+export async function install({ targetDir, agentType, selections, includeAgentsMd = true, writeAgentsMd, oldSelections, oldLock, force = false, dryRun = false }) {
+  validateSelections(selections);
+  if (oldLock) validateLock(oldLock);
   writeAgentsMd = writeAgentsMd ?? includeAgentsMd;
   const absTarget = resolve(process.cwd(), targetDir);
-  await mkdir(absTarget, { recursive: true });
+  if (!dryRun) await mkdir(absTarget, { recursive: true });
+  const options = {
+    targetDir: absTarget,
+    oldLock,
+    force,
+    dryRun,
+    managedFiles: { ...(oldLock?.managedFiles || {}) },
+  };
 
-  // Delete items that are no longer selected
+  // Delete items that are no longer selected.
   if (oldSelections) {
     for (const cat of Object.keys(oldSelections)) {
       const oldIds = new Set(oldSelections[cat] || []);
       const newIds = new Set(selections[cat] || []);
       const removedIds = [...oldIds].filter(id => !newIds.has(id));
-      if (removedIds.length > 0) {
-        await deleteSelectedItems(absTarget, cat, removedIds);
-      }
+      await deleteSelectedItems(absTarget, cat, removedIds, oldLock, force, dryRun);
     }
   }
 
   const tasks = [];
-
-  if (selections.skills?.length) {
-    tasks.push(copySelectedDirs(absTarget, 'skills', selections.skills));
-  }
-  if (selections.agents?.length) {
-    tasks.push(copySelectedFiles(absTarget, 'agents', selections.agents));
-  }
-  if (selections.commands?.length) {
-    tasks.push(copySelectedFiles(absTarget, 'commands', selections.commands));
-  }
-  if (selections.styles?.length) {
-    tasks.push(copySelectedDirs(absTarget, 'styles', selections.styles));
-  }
-  if (selections.modes?.length) {
-    tasks.push(copySelectedFiles(absTarget, 'modes', selections.modes));
-  }
-  if (selections.memory?.length) {
-    tasks.push(copySelectedFiles(absTarget, 'memory', selections.memory, true));
+  for (const category of ['skills', 'styles']) {
+    if (selections[category]?.length) tasks.push(copySelectedDirs(absTarget, category, selections[category], options));
   }
-  if (selections.standards?.length) {
-    tasks.push(copySelectedFiles(absTarget, 'standards', selections.standards));
+  for (const category of ['agents', 'commands', 'modes', 'memory', 'standards', 'templates']) {
+    if (selections[category]?.length) tasks.push(copySelectedFiles(absTarget, category, selections[category], options));
   }
-  if (selections.templates?.length) {
-    tasks.push(copySelectedFiles(absTarget, 'templates', selections.templates));
-  }
-
   await Promise.all(tasks);
 
   if (writeAgentsMd) {
-    const agentsContent = generateAgentsMd({ selections });
-    await writeFile(resolve(absTarget, 'AGENTS.md'), agentsContent);
+    await writeManagedFile(resolve(absTarget, 'AGENTS.md'), Buffer.from(AGENTS_MD), 'AGENTS.md', options);
   }
 
   if (agentType === 'opencode') {
     let mcpEntries = {};
-    if (selections.mcps?.length) {
-      mcpEntries = await loadMcpConfigs(selections.mcps);
-    }
-    const configJson = generateOpenCodeConfig({
-      selections,
-      mcpEntries,
-      includeAgentsMd: includeAgentsMd,
-    });
-    if (configJson) {
-      await writeFile(resolve(absTarget, 'opencode.json'), configJson);
+    if (selections.mcps?.length) mcpEntries = await loadMcpConfigs(selections.mcps);
+    let previousOpenCodeConfig;
+    let previousTuiConfig;
+    if (oldLock) {
+      let previousMcpEntries = {};
+      if (oldLock.selections.mcps?.length) previousMcpEntries = await loadMcpConfigs(oldLock.selections.mcps);
+      previousOpenCodeConfig = JSON.parse(generateOpenCodeConfig({
+        selections: oldLock.selections,
+        mcpEntries: previousMcpEntries,
+        includeAgentsMd: oldLock.includeAgentsMd ?? true,
+      }));
+      previousTuiConfig = JSON.parse(generateTuiConfig({ selections: oldLock.selections }));
     }
-    await writeFile(resolve(absTarget, 'tui.json'), generateTuiConfig({ selections }));
-    await writeFile(resolve(absTarget, '.gitignore'), OPENCODE_GITIGNORE);
+    const configJson = generateOpenCodeConfig({ selections, mcpEntries, includeAgentsMd });
+    await mergeJsonFile(resolve(absTarget, 'opencode.json'), JSON.parse(configJson), 'opencode.json', options, previousOpenCodeConfig);
+    await mergeJsonFile(resolve(absTarget, 'tui.json'), JSON.parse(generateTuiConfig({ selections })), 'tui.json', options, previousTuiConfig);
+    await mergeGitignore(resolve(absTarget, '.gitignore'), options);
   }
 
   if (selections.mcps?.length) {
     const envExamples = await collectMcpEnvExamples(selections.mcps);
-    await writeMergedEnv(absTarget, envExamples);
+    await writeMergedEnv(absTarget, envExamples, options);
   }
 
+  if (dryRun) return absTarget;
   const version = await getPackageVersion();
   const lockData = {
     version,
     agentType,
     targetDir,
     installedAt: new Date().toISOString(),
-    selections: Object.fromEntries(
-      Object.entries(selections).map(([k, v]) => [k, [...v]])
-    ),
+    selections: Object.fromEntries(Object.entries(selections).map(([k, v]) => [k, [...v]])),
     includeAgentsMd,
+    managedFiles: options.managedFiles,
   };
   await writeFile(resolve(absTarget, 'system-prompt-lock.json'), JSON.stringify(lockData, null, 2));
-
   return absTarget;
 }
+
+function resolveSource(subpath) {
+  return resolve(packageRoot, subpath);
+}
+
+function targetSubdir(sourceDir) {
+  return sourceDir.replace(/^framework\//, '');
+}
+
+async function isRemoved(category, id) {
+  const catConfig = categories[category];
+  if (!catConfig) return false;
+  const item = catConfig.items.find(i => i.id === id);
+  return item?.removed === true;
+}
+
+function parseEnv(content) {
+  const vars = new Map();
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex === -1) {
+      vars.set(trimmed, '');
+    } else {
+      const key = trimmed.slice(0, eqIndex).trim();
+      const value = trimmed.slice(eqIndex + 1).trim();
+      if (key) vars.set(key, value);
+    }
+  }
+  return vars;
+}
+
+async function collectMcpEnvExamples(mcpIds) {
+  const combined = new Map();
+  for (const id of mcpIds) {
+    try {
+      const examplePath = resolveSource(`framework/mcps/${id}/configs/.env.example`);
+      const content = await readFile(examplePath, 'utf-8');
+      const parsed = parseEnv(content);
+      for (const [key, value] of parsed) {
+        if (!combined.has(key)) combined.set(key, value);
+      }
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      // MCPs may not provide an environment example.
+    }
+  }
+  return combined;
+}
+
+async function writeMergedEnv(absTarget, examples, options) {
+  if (examples.size === 0) return;
+
+  const envPath = resolve(absTarget, '.env');
+  await assertSafeDestination(options.targetDir, envPath);
+  const existing = new Map();
+  let existingContent = '';
+
+  try {
+    existingContent = await readFile(envPath, 'utf-8');
+    const parsed = parseEnv(existingContent);
+    for (const [key, value] of parsed) existing.set(key, value);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+
+  const additions = [];
+  for (const [key, value] of examples) {
+    if (!existing.has(key)) additions.push(`${key}=${value}`);
+  }
+
+  if (additions.length === 0) return;
+  const separator = existingContent && !existingContent.endsWith('\n') ? '\n' : '';
+  const content = Buffer.from(`${existingContent}${separator}${additions.join('\n')}\n`);
+  if (!options.dryRun) await writeFile(envPath, content);
+  options.managedFiles['.env'] = hash(content);
+}