@tensor.chat/companion 0.4.1 → 0.4.3

package/src/tools/outside.js

@@ -24,17 +24,32 @@ const WHOLE_PATH = /^(?:[A-Za-z]:[\\/]|\\\\|\.\.(?:[\\/]|$)|\/)/;
 
 // The command as this machine reads it: PowerShell's $env:NAME, cmd's %NAME%, the
 // POSIX $NAME and ${NAME}, and ~ for the home folder. A name it does not know stays.
-function expand(command, { env, home, platform }) {
+// A variable that holds a list of folders (PATH and its kind) stays as written too: a
+// list names no one place, and most commands only add to it - put in, every folder on
+// the list read as named, and a test run was asked about ten folders. Its entries go to
+// `lists`, under the name the command wrote.
+function expand(command, { env, home, platform }, lists = []) {
   const keys = Object.keys(env);
+  const sep = platform === 'win32' ? ';' : ':';
+  const absolute = platform === 'win32' ? path.win32.isAbsolute : path.posix.isAbsolute;
   const get = (name) => {
     const key = platform === 'win32' ? keys.find((k) => k.toLowerCase() === name.toLowerCase()) : (name in env ? name : null);
     if (key != null && env[key] != null) return String(env[key]);
     return /^(home|userprofile)$/i.test(name) ? home : null;
   };
+  const put = (m, name) => {
+    const value = get(name);
+    if (value == null) return m;
+    // A list holds at least two paths of this system ("C:\x" is no list where ":" separates)
+    const entries = value.split(sep).filter(Boolean);
+    if (entries.filter(absolute).length < 2) return value;
+    if (!lists.some((l) => l.name === name)) lists.push({ name, entries });
+    return m;
+  };
   return String(command == null ? '' : command)
-    .replace(/\$\{env:([A-Za-z_][\w()]*)\}|\$env:([A-Za-z_]\w*)/gi, (m, a, b) => get(a || b) ?? m)
-    .replace(/%([A-Za-z_][\w()]*)%/g, (m, n) => get(n) ?? m)
-    .replace(/\$\{([A-Za-z_]\w*)\}|\$([A-Za-z_]\w*)/g, (m, a, b) => get(a || b) ?? m)
+    .replace(/\$\{env:([A-Za-z_][\w()]*)\}|\$env:([A-Za-z_]\w*)/gi, (m, a, b) => put(m, a || b))
+    .replace(/%([A-Za-z_][\w()]*)%/g, (m, n) => put(m, n))
+    .replace(/\$\{([A-Za-z_]\w*)\}|\$([A-Za-z_]\w*)/g, (m, a, b) => put(m, a || b))
     .replace(/(^|[\s"'=(])~(?=[\\/]|$|[\s"')])/g, (m, pre) => pre + home);
 }
 
@@ -78,22 +93,36 @@ function folderOf(word, cwd) {
 
 function outsideFolders(roots, command, { cwd, env = process.env, home = os.homedir(), platform = process.platform } = {}) {
   const shared = roots.okRoots().map((r) => r.real);
+  const outside = (folder) => !shared.some((r) => isInside(realExisting(folder) || folder, r));
+  const same = (a, b) => isInside(a, b) && isInside(b, a);
   const found = [];
-  for (const word of words(expand(command, { env, home, platform }), platform)) {
+  const lists = [];
+  for (const word of words(expand(command, { env, home, platform }, lists), platform)) {
     const folder = folderOf(word, cwd || home);
-    if (!folder) continue;
-    const real = realExisting(folder) || folder;
-    if (shared.some((r) => isInside(real, r))) continue;
-    if (!found.some((f) => isInside(folder, f) && isInside(f, folder))) found.push(folder);
+    if (!folder || !outside(folder)) continue;
+    if (!found.some((f) => same(folder, f))) found.push(folder);
   }
   // A folder inside another one found is covered by it
-  const folders = found
-    .filter((f) => !found.some((g) => g !== f && isInside(f, g) && !isInside(g, f)))
-    .slice(0, MAX_FOLDERS)
-    // A whole drive, the home folder or what holds it is too much to share in one click
-    .map((f) => ({ path: f, broad: path.parse(f).root === f || isInside(home, f) }));
+  const named = found.filter((f) => !found.some((g) => g !== f && isInside(f, g) && !isInside(g, f)));
+  // A list's folders come after the named ones and cover none of them: whatever the
+  // server makes of the list, a folder the command names is asked for by itself
+  const listed = [];
+  for (const { name, entries } of lists) {
+    for (const entry of entries) {
+      const st = path.isAbsolute(entry) ? statOf(entry) : null;
+      if (!st || !st.isDirectory() || !outside(entry)) continue;
+      if (![...named, ...listed.map((l) => l.path)].some((f) => same(entry, f))) listed.push({ path: entry, from: name });
+    }
+  }
+  // A whole drive, the home folder or what holds it is too much to share in one click
+  const broad = (f) => path.parse(f).root === f || isInside(home, f);
+  const folders = [
+    ...named.map((f) => ({ path: f, broad: broad(f) })),
+    ...listed.map((l) => ({ path: l.path, broad: broad(l.path), from: l.from })),
+  ].slice(0, MAX_FOLDERS);
+  const said = (f) => (f.from ? `${f.path} (from ${f.from})` : f.path);
   const text = folders.length
-    ? `(outside the shared folders: ${folders.map((f) => f.path).join(', ')})`
+    ? `(outside the shared folders: ${folders.map(said).join(', ')})`
     : '(nothing outside the shared folders)';
   return { ok: true, text, folders };
 }