@rayrun/cli 0.3.0 → 0.5.0

package/src/sanitizeTerminalError.js

@@ -0,0 +1,16 @@
+import { stripVTControlCharacters } from 'node:util';
+
+/** Keeps untrusted API diagnostics and filesystem paths from controlling the caller's terminal. */
+export const sanitizeTerminalError = (value) =>
+  stripVTControlCharacters(String(value))
+    .replaceAll(/\r\n?/gu, '\n')
+    .split('\n')
+    .map((line) =>
+      line
+        .replaceAll(/\p{Cc}+/gu, ' ')
+        .replaceAll(
+          /\p{Bidi_Control}/gu,
+          (character) => `\\u{${character.codePointAt(0).toString(16).toUpperCase()}}`,
+        ),
+    )
+    .join('\n');

package/src/skills.js

@@ -0,0 +1,122 @@
+import { lstat, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const MAX_FILES = 512;
+const MAX_BYTES = 16 * 1_024 * 1_024;
+
+const safeRelativePath = (value) => {
+  const normalized = value.normalize('NFC').split(path.sep).join('/');
+  if (
+    normalized === '' ||
+    normalized.startsWith('/') ||
+    normalized.includes('\\') ||
+    normalized.split('/').some((segment) => ['', '.', '..'].includes(segment))
+  ) {
+    throw new Error(`Unsafe skill file path: ${JSON.stringify(value)}.`);
+  }
+  return normalized;
+};
+
+export const readSkillDirectory = async (directory) => {
+  const root = path.resolve(directory);
+  const files = [];
+  let byteCount = 0;
+
+  const visit = async (current) => {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries.toSorted((left, right) => left.name.localeCompare(right.name))) {
+      const target = path.join(current, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Skill directories cannot contain symbolic links: ${target}`);
+      }
+      if (entry.isDirectory()) {
+        await visit(target);
+        continue;
+      }
+      if (!entry.isFile()) {
+        throw new Error(`Skill directories cannot contain special files: ${target}`);
+      }
+      if (files.length >= MAX_FILES) throw new Error('A skill can contain at most 512 files.');
+      const content = await readFile(target);
+      byteCount += content.byteLength;
+      if (byteCount > MAX_BYTES) throw new Error('A skill can contain at most 16 MiB.');
+      files.push({
+        contentBase64: content.toString('base64'),
+        path: safeRelativePath(path.relative(root, target)),
+      });
+    }
+  };
+
+  const metadata = await lstat(root);
+  if (!metadata.isDirectory()) throw new Error(`${directory} is not a directory.`);
+  await visit(root);
+  return files;
+};
+
+export const writeSkillDirectory = async (directory, files) => {
+  const root = path.resolve(directory);
+  if (!Array.isArray(files) || files.length === 0 || files.length > MAX_FILES) {
+    throw new Error('A downloaded skill must contain 1–512 files.');
+  }
+  try {
+    await lstat(root);
+    throw new Error(`Refusing to overwrite existing path: ${root}`);
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+
+  const prepared = [];
+  const paths = new Set();
+  let byteCount = 0;
+  for (const file of files) {
+    const relativePath = safeRelativePath(file.path);
+    const collisionKey = relativePath.toLocaleLowerCase('en-US');
+    if (paths.has(collisionKey)) {
+      throw new Error(`Duplicate skill file path: ${JSON.stringify(file.path)}.`);
+    }
+    paths.add(collisionKey);
+    if (
+      typeof file.contentBase64 !== 'string' ||
+      !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(file.contentBase64)
+    ) {
+      throw new Error(`Invalid base64 content for skill file: ${JSON.stringify(file.path)}.`);
+    }
+    const content = Buffer.from(file.contentBase64, 'base64');
+    byteCount += content.byteLength;
+    if (byteCount > MAX_BYTES) throw new Error('A downloaded skill can contain at most 16 MiB.');
+    prepared.push({ content, relativePath });
+  }
+  for (const file of prepared) {
+    const segments = file.relativePath.split('/');
+    for (let length = 1; length < segments.length; length += 1) {
+      if (paths.has(segments.slice(0, length).join('/').toLocaleLowerCase('en-US'))) {
+        throw new Error(
+          `A skill path cannot be both a file and a directory: ${JSON.stringify(file.relativePath)}.`,
+        );
+      }
+    }
+  }
+
+  await mkdir(path.dirname(root), { mode: 0o700, recursive: true });
+  try {
+    await mkdir(root, { mode: 0o700 });
+  } catch (error) {
+    if (error?.code === 'EEXIST') throw new Error(`Refusing to overwrite existing path: ${root}`);
+    throw error;
+  }
+  try {
+    for (const file of prepared) {
+      const relativePath = file.relativePath;
+      const content = file.content;
+      const target = path.resolve(root, ...relativePath.split('/'));
+      if (!target.startsWith(`${root}${path.sep}`)) {
+        throw new Error(`Unsafe skill file path: ${JSON.stringify(relativePath)}.`);
+      }
+      await mkdir(path.dirname(target), { mode: 0o700, recursive: true });
+      await writeFile(target, content, { flag: 'wx', mode: 0o600 });
+    }
+  } catch (error) {
+    await rm(root, { force: true, recursive: true });
+    throw error;
+  }
+};