@feng0531/dsh-vcs 0.3.62 → 0.3.67

package/text-content.mjs

@@ -0,0 +1,42 @@
+/** Pure bounded byte decoding shared by working and committed previews. */
+export const MAX_TEXT = 2 * 1024 * 1024;
+
+export function decode(buffer) {
+  if (buffer.length > MAX_TEXT) {
+    return {text: '', notice: 'File exceeds the 2 MiB preview limit.'};
+  }
+  let text, encoding = 'UTF-8';
+  if (buffer[0] === 0xff && buffer[1] === 0xfe) {
+    if (buffer.length % 2) return {text: '', binary: true, notice: 'Invalid UTF-16 file.'};
+    text = buffer.subarray(2).toString('utf16le');
+    encoding = 'UTF-16LE';
+  } else if (buffer[0] === 0xfe && buffer[1] === 0xff) {
+    const bytes = Buffer.from(buffer.subarray(2));
+    if (bytes.length % 2) return {text: '', binary: true, notice: 'Invalid UTF-16 file.'};
+    bytes.swap16();
+    text = bytes.toString('utf16le');
+    encoding = 'UTF-16BE';
+  } else {
+    if (buffer.includes(0)) {
+      return {text: '', binary: true, notice: 'Binary file; text preview unavailable.'};
+    }
+    if (buffer.some(byte => byte < 32 && ![9, 10, 12, 13].includes(byte))) {
+      return {text: '', binary: true, notice: 'Binary control bytes; text preview unavailable.'};
+    }
+    try {
+      text = new TextDecoder('utf-8', {fatal: true}).decode(buffer);
+    } catch {
+      // A UTF-8 BOM is authoritative; malformed UTF-8 must not become GBK.
+      if (buffer.subarray(0, 3).equals(Buffer.from([0xef, 0xbb, 0xbf]))) {
+        return {text: '', binary: true, notice: 'Invalid UTF-8 file.'};
+      }
+      try {
+        text = new TextDecoder('gbk', {fatal: true}).decode(buffer);
+        encoding = 'GBK';
+      } catch {
+        return {text: '', binary: true, notice: 'Unsupported encoding or binary file; preview unavailable.'};
+      }
+    }
+  }
+  return {text, encoding};
+}

package/vcs.mjs

@@ -1,5 +1,6 @@
+import {parseSvnIdentity} from './src/svn-identity.mjs';
 import {prepareRaster} from './image-preview.mjs';
-import { spawn } from 'node:child_process';
+import {git, svn, TIMEOUT} from './local-command.mjs';
 import {parseHistory,parseFollowHistory,HISTORY_FORMAT,historyPage,historySearchArgs,parseBlame,parseReferences,REFS_FORMAT} from './git-history.mjs';
 import * as fs from 'node:fs/promises';
 import {constants as fileFlags} from 'node:fs';
@@ -7,60 +8,17 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { XMLParser, XMLValidator } from 'fast-xml-parser';
 
-const MAX_TEXT = 2 * 1024 * 1024;
-const MAX_OUTPUT = 16 * 1024 * 1024;
-const TIMEOUT = 15000;
+import {decode, MAX_TEXT} from './text-content.mjs';
+import {inside, confined} from './repository-path.mjs';
 const xml = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '', parseTagValue: false, parseAttributeValue: false, trimValues: false, processEntities: true, isArray: name => ['entry', 'target', 'property'].includes(name) });
 
-function run(command, args, cwd, max = MAX_OUTPUT, { signal, timeoutMs = TIMEOUT } = {}) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) { reject(Object.assign(new Error('Discovery cancelled'), { code: 'ABORT_ERR' })); return; }
-    // Inherited Git overrides must not redirect reads to a different repository.
-    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.toUpperCase().startsWith('GIT_')));
-    Object.assign(env, { GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0', GIT_NO_REPLACE_OBJECTS: '1', GIT_NO_LAZY_FETCH: '1', GIT_ALLOW_PROTOCOL: '', LC_ALL: process.platform === 'linux' ? 'C.UTF-8' : 'en_US.UTF-8' });
-    const child = spawn(command, args, { cwd, shell: false, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'], env });
-    const out = [], err = []; let size = 0, error, done = false;
-    const stop = e => { error ??= e; child.kill(); };
-    const abort = () => stop(Object.assign(new Error('Discovery cancelled'), { code: 'ABORT_ERR' }));
-    signal?.addEventListener('abort', abort, { once: true });
-    const timer = setTimeout(() => stop(Object.assign(new Error(command + ' timed out'), { code: 'TIMEOUT' })), timeoutMs);
-    child.stdout.on('data', b => { size += b.length; if (size > max) stop(Object.assign(new Error('Output exceeds size limit'), { code: 'TOO_LARGE' })); else out.push(b); });
-    child.stderr.on('data', b => { size += b.length; if (size > max) stop(Object.assign(new Error('Output exceeds size limit'), { code: 'TOO_LARGE' })); else err.push(b); });
-    const finish = e => { if (done) return; done = true; clearTimeout(timer); signal?.removeEventListener('abort', abort); if (e) reject(e); else resolve(Buffer.concat(out)); };
-    child.on('error', finish);
-    child.on('close', code => finish(error || (code !== 0 ? Object.assign(new Error(command + ': ' + Buffer.concat(err).toString('utf8').trim()), { code: 'VCS_COMMAND', exitCode: code }) : null)));
-  });
-}
-const git = (root, args, max, options) => run('git', ['--no-pager', '--literal-pathspecs', '-c', 'core.fsmonitor=false', ...args], root, max, options);
-const svn = (root, args, max, options) => run('svn', ['--non-interactive', ...args], root, max, options);
+
 function parseXML(buffer) {
   const text = buffer.toString('utf8');
   if (/<!DOCTYPE|<!ENTITY/i.test(text) || XMLValidator.validate(text) !== true) throw new Error('Invalid VCS XML');
   return xml.parse(text);
 }
-function inside(root, candidate) { const rel = path.relative(root, candidate); return rel === '' || (!path.isAbsolute(rel) && rel !== '..' && !rel.startsWith('..' + path.sep)); }
-async function confined(root, relative) {
-  if (typeof relative !== 'string' || relative.includes('\0') || path.isAbsolute(relative) || /^[a-z]:/i.test(relative)) throw new Error('Invalid repository path');
-  const target = path.resolve(root, relative);
-  if (!inside(root, target)) throw new Error('Path escapes repository');
-  // Inspect each existing component, including dangling links whose realpath fails.
-  let component = root;
-  for (const part of path.relative(root, target).split(path.sep).filter(Boolean)) {
-    component = path.join(component, part);
-    try {
-      if ((await fs.lstat(component)).isSymbolicLink()) {
-        const destination = path.resolve(path.dirname(component), await fs.readlink(component));
-        if (!inside(root, destination)) throw new Error('Symlink escapes repository');
-      }
-    } catch (e) { if (!['ENOENT', 'ENOTDIR'].includes(e.code)) throw e; }
-  }
-  let current = target;
-  for (;;) {
-    try { const real = await fs.realpath(current); if (!inside(root, real)) throw new Error('Symlink escapes repository'); break; }
-    catch (e) { if (!['ENOENT', 'ENOTDIR'].includes(e.code)) throw e; const parent = path.dirname(current); if (parent === current) throw e; current = parent; }
-  }
-  return target;
-}
+
 
 /** Detect the nearest enclosing Git or SVN working copy; never initializes one. */
 export async function detectRepository(cwd) {
@@ -222,6 +180,11 @@ async function checkedRepo(repo, signal) {
   if (!found || found.type !== repo.type || path.resolve(found.root) !== path.resolve(repo.root)) throw new Error('Repository root changed or is invalid');
   return found;
 }
+export async function getSvnIdentity(repo,{signal}={}){
+ repo=await checkedRepo(repo,signal);if(repo.type!=='svn')throw Error('SVN working copy required');
+ const result=parseSvnIdentity((await svn(repo.root,['info','--xml','--', '.'],MAX_TEXT,{signal})).toString('utf8'));
+ if(await fs.realpath(result.wcRoot)!==repo.root)throw Error('SVN working copy root changed');signal?.throwIfAborted();return result;
+}
 export async function listHistory(repo, {snapshot,offset=0,limit=50,search,signal} = {}) {
   const query=historySearchArgs(search);
   if(!Number.isInteger(offset)||offset<0||offset>10000||!Number.isInteger(limit)||limit<1||limit>100) throw new Error('Invalid history pagination');
@@ -479,24 +442,8 @@ async function changes(repo, mode) {
 }
 /** Changes have opaque IDs, status words, and repo-relative paths. */
 export async function listChanges(repo, mode = 'all') { repo = await checkedRepo(repo); modeFor(repo, mode); return changes(repo, mode); }
-export function decode(buffer) {
-  if (buffer.length > MAX_TEXT) return { text: '', notice: 'File exceeds the 2 MiB preview limit.' };
-  let text, encoding = 'UTF-8';
-  if (buffer[0] === 0xff && buffer[1] === 0xfe) { if (buffer.length % 2) return { text: '', binary: true, notice: 'Invalid UTF-16 file.' }; text = buffer.subarray(2).toString('utf16le'); encoding = 'UTF-16LE'; }
-  else if (buffer[0] === 0xfe && buffer[1] === 0xff) { const b = Buffer.from(buffer.subarray(2)); if (b.length % 2) return { text: '', binary: true, notice: 'Invalid UTF-16 file.' }; b.swap16(); text = b.toString('utf16le'); encoding = 'UTF-16BE'; }
-  else {
-    if (buffer.includes(0)) return { text: '', binary: true, notice: 'Binary file; text preview unavailable.' };
-    if (buffer.some(byte => byte < 32 && ![9,10,12,13].includes(byte))) return { text: '', binary: true, notice: 'Binary control bytes; text preview unavailable.' };
-    try { text = new TextDecoder('utf-8', { fatal: true }).decode(buffer); }
-    catch {
-      // A UTF-8 BOM is authoritative; do not reinterpret malformed UTF-8 as GBK.
-      if (buffer.subarray(0,3).equals(Buffer.from([0xef,0xbb,0xbf]))) return {text:'',binary:true,notice:'Invalid UTF-8 file.'};
-      try { text = new TextDecoder('gbk', {fatal:true}).decode(buffer); encoding = 'GBK'; }
-      catch { return {text:'',binary:true,notice:'Unsupported encoding or binary file; preview unavailable.'}; }
-    }
-  }
-  return { text, encoding };
-}
+// Keep the public adapter decoding export compatible with existing consumers.
+export {decode} from './text-content.mjs';
 async function content(fn) { try { return decode(await fn()); } catch (e) { if (e.code === 'TOO_LARGE') return { text: '', notice: 'File exceeds the 2 MiB preview limit.' }; throw e; } }
 async function working(root, relative, svnLink = false) {
   const target = await confined(root, relative);