@tbsten/mir-core 0.0.1-alpha02

package/src/remote-registry.ts

@@ -0,0 +1,260 @@
+import { RemoteRegistryFetchError, InvalidManifestError, MirError } from "./errors.js";
+import { parseSnippetYaml } from "./snippet-schema.js";
+import { expandTemplate, expandPath } from "./template-engine.js";
+import { t } from "./i18n/index.js";
+import type { SnippetDefinition } from "./snippet-schema.js";
+
+/**
+ * リモート registry のマニフェスト (index.json) の型
+ */
+export interface RegistryManifest {
+  snippets: Record<string, { files: string[] }>;
+}
+
+/**
+ * fetch オプション (タイムアウト等)
+ */
+export interface FetchOptions {
+  /** タイムアウト時間（ミリ秒）。未指定の場合はタイムアウトなし */
+  timeoutMs?: number;
+}
+
+/**
+ * リモートから取得した snippet の情報
+ */
+export interface RemoteSnippet {
+  definition: SnippetDefinition;
+  files: Map<string, string>;
+}
+
+/**
+ * キャッシュエントリの型
+ */
+interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+}
+
+const CACHE_TTL_MS = 60000; // 60秒
+const manifestCache = new Map<string, CacheEntry<RegistryManifest>>();
+const snippetListCache = new Map<string, CacheEntry<string[]>>();
+
+/**
+ * キャッシュが有効か確認
+ */
+function isCacheValid<T>(entry: CacheEntry<T>): boolean {
+  return Date.now() - entry.timestamp < CACHE_TTL_MS;
+}
+
+/**
+ * すべてのリモート registry キャッシュをクリア
+ */
+export function clearAllRemoteRegistryCaches(): void {
+  manifestCache.clear();
+  snippetListCache.clear();
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+
+/**
+ * AbortController を使ったタイムアウト付き fetch
+ */
+async function fetchWithTimeout(
+  url: string,
+  options: FetchOptions = {},
+): Promise<Response> {
+  if (!options.timeoutMs) {
+    return fetch(url);
+  }
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs);
+
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      const timeoutSec = Math.round(options.timeoutMs / 1000);
+      throw new MirError(t("error.fetch-timeout", { url, timeout: timeoutSec }));
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * マニフェスト (index.json) を取得する（キャッシュ付き）
+ */
+export async function fetchRegistryManifest(
+  baseUrl: string,
+  options: FetchOptions = {},
+): Promise<RegistryManifest> {
+  const normalizedUrl = normalizeBaseUrl(baseUrl);
+  const cached = manifestCache.get(normalizedUrl);
+
+  if (cached && isCacheValid(cached)) {
+    return cached.data;
+  }
+
+  const url = `${normalizedUrl}/index.json`;
+  let res: Response;
+  try {
+    res = await fetchWithTimeout(url, options);
+  } catch (err) {
+    if (err instanceof MirError) throw err;
+    throw new RemoteRegistryFetchError(url);
+  }
+  if (!res.ok) {
+    throw new RemoteRegistryFetchError(url, res.status);
+  }
+  let data: unknown;
+  try {
+    data = await res.json();
+  } catch {
+    throw new InvalidManifestError(url);
+  }
+  if (
+    typeof data !== "object" ||
+    data === null ||
+    !("snippets" in data) ||
+    typeof (data as RegistryManifest).snippets !== "object"
+  ) {
+    throw new InvalidManifestError(url);
+  }
+
+  const manifest = data as RegistryManifest;
+  manifestCache.set(normalizedUrl, {
+    data: manifest,
+    timestamp: Date.now(),
+  });
+
+  return manifest;
+}
+
+/**
+ * リモート registry の snippet 名一覧を返す（キャッシュ付き）
+ */
+export async function listRemoteSnippets(
+  baseUrl: string,
+  options: FetchOptions = {},
+): Promise<string[]> {
+  const normalizedUrl = normalizeBaseUrl(baseUrl);
+  const cached = snippetListCache.get(normalizedUrl);
+
+  if (cached && isCacheValid(cached)) {
+    return cached.data;
+  }
+
+  const manifest = await fetchRegistryManifest(baseUrl, options);
+  const snippetList = Object.keys(manifest.snippets);
+
+  snippetListCache.set(normalizedUrl, {
+    data: snippetList,
+    timestamp: Date.now(),
+  });
+
+  return snippetList;
+}
+
+/**
+ * snippet 定義 (YAML) を取得する
+ */
+export async function fetchSnippetDefinition(
+  baseUrl: string,
+  name: string,
+  options: FetchOptions = {},
+): Promise<SnippetDefinition> {
+  const url = `${normalizeBaseUrl(baseUrl)}/${name}.yaml`;
+  let res: Response;
+  try {
+    res = await fetchWithTimeout(url, options);
+  } catch (err) {
+    if (err instanceof MirError) throw err;
+    throw new RemoteRegistryFetchError(url);
+  }
+  if (!res.ok) {
+    throw new RemoteRegistryFetchError(url, res.status);
+  }
+  const text = await res.text();
+  return parseSnippetYaml(text);
+}
+
+/**
+ * テンプレートファイル群を並列で取得する
+ */
+export async function fetchRemoteFiles(
+  baseUrl: string,
+  name: string,
+  files: string[],
+  options: FetchOptions = {},
+): Promise<Map<string, string>> {
+  const base = normalizeBaseUrl(baseUrl);
+  const result = new Map<string, string>();
+
+  const entries = await Promise.all(
+    files.map(async (filePath) => {
+      const url = `${base}/${name}/${encodeURIComponent(filePath)}`;
+      let res: Response;
+      try {
+        res = await fetchWithTimeout(url, options);
+      } catch (err) {
+        if (err instanceof MirError) throw err;
+        throw new RemoteRegistryFetchError(url);
+      }
+      if (!res.ok) {
+        throw new RemoteRegistryFetchError(url, res.status);
+      }
+      const content = await res.text();
+      return [filePath, content] as const;
+    }),
+  );
+
+  for (const [filePath, content] of entries) {
+    result.set(filePath, content);
+  }
+  return result;
+}
+
+/**
+ * snippet 定義とテンプレートファイルを統合して取得する
+ */
+export async function fetchRemoteSnippet(
+  baseUrl: string,
+  name: string,
+  options: FetchOptions = {},
+): Promise<RemoteSnippet> {
+  const manifest = await fetchRegistryManifest(baseUrl, options);
+  const snippetEntry = manifest.snippets[name];
+  if (!snippetEntry) {
+    throw new RemoteRegistryFetchError(
+      `${normalizeBaseUrl(baseUrl)}/${name}.yaml`,
+      404,
+    );
+  }
+
+  const [definition, files] = await Promise.all([
+    fetchSnippetDefinition(baseUrl, name, options),
+    fetchRemoteFiles(baseUrl, name, snippetEntry.files, options),
+  ]);
+
+  return { definition, files };
+}
+
+/**
+ * リモートから取得したテンプレートファイルの変数を展開する
+ */
+export function expandRemoteTemplateFiles(
+  files: Map<string, string>,
+  variables: Record<string, unknown>,
+): Map<string, string> {
+  const result = new Map<string, string>();
+  for (const [filePath, content] of files) {
+    const expandedPath = expandPath(filePath, variables);
+    const expandedContent = expandTemplate(content, variables);
+    result.set(expandedPath, expandedContent);
+  }
+  return result;
+}

package/src/safe-yaml-parser.ts

@@ -0,0 +1,71 @@
+/**
+ * 安全な YAML パーサー
+ *
+ * チケット 008-yaml-injection の対策として以下を実装:
+ * - 入力サイズ上限チェック（YAML Bomb / DoS 対策）
+ * - CORE_SCHEMA 使用によりカスタムタグ攻撃（!!js/function 等）を防止
+ * - JSON Schema の $ref 禁止チェック（外部リソース読み込み攻撃対策）
+ */
+import yaml from "js-yaml";
+import { ValidationError } from "./errors.js";
+
+/**
+ * YAML ドキュメントの最大許容サイズ（バイト）。
+ * 64 KB を上限とする。通常の snippet 定義には十分な値。
+ */
+export const YAML_MAX_SIZE_BYTES = 64 * 1024; // 64 KB
+
+/**
+ * 安全な設定で YAML をパースする。
+ *
+ * - 入力サイズが YAML_MAX_SIZE_BYTES を超える場合は ValidationError を投げる
+ * - CORE_SCHEMA を使用し、JS 固有のカスタムタグ（!!js/function 等）を禁止する
+ *
+ * @param content パースする YAML 文字列
+ * @returns パース結果
+ * @throws ValidationError 入力サイズ超過、または無効な YAML の場合
+ */
+export function safeParseYaml(content: string): unknown {
+  // 入力サイズチェック（YAML Bomb 対策）
+  const sizeBytes = Buffer.byteLength(content, "utf-8");
+  if (sizeBytes > YAML_MAX_SIZE_BYTES) {
+    throw new ValidationError(
+      `YAML ドキュメントのサイズが上限 (${YAML_MAX_SIZE_BYTES} バイト) を超えています: ${sizeBytes} バイト`,
+    );
+  }
+
+  try {
+    // CORE_SCHEMA: bool/int/float/null のみを認識し、JS 固有タグ（!!js/function 等）を拒否する
+    return yaml.load(content, {
+      schema: yaml.CORE_SCHEMA,
+    });
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      throw err;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ValidationError(`YAML パースエラー: ${message}`);
+  }
+}
+
+/**
+ * JSON Schema オブジェクト内に $ref キーが存在しないか検証する。
+ *
+ * $ref を使った外部スキーマ読み込み攻撃を防ぐため、
+ * snippet.yaml 内の schema フィールドには $ref を禁止する。
+ *
+ * @param schema 検証対象の schema 値（any）
+ * @throws ValidationError $ref が見つかった場合
+ */
+export function checkNoRefInSchema(schema: unknown): void {
+  if (schema === null || schema === undefined) {
+    return;
+  }
+  // JSON.stringify 経由で深いネストも含めて $ref キーを検出する
+  const serialized = JSON.stringify(schema);
+  if (serialized.includes('"$ref"')) {
+    throw new ValidationError(
+      'snippet の schema フィールドに "$ref" を使用することはセキュリティ上禁止されています',
+    );
+  }
+}

package/src/snippet-schema.ts

@@ -0,0 +1,117 @@
+import yaml from "js-yaml";
+import { ValidationError } from "./errors.js";
+import { validateSnippetName } from "./validate-name.js";
+import { safeParseYaml, checkNoRefInSchema } from "./safe-yaml-parser.js";
+
+export interface VariableSchema {
+  type?: "string" | "number" | "boolean";
+  default?: unknown;
+  enum?: unknown[];
+}
+
+export interface VariableDefinition {
+  name?: string;
+  description?: string;
+  suggests?: string[];
+  schema?: VariableSchema;
+}
+
+export interface Action {
+  echo?: string;
+  exit?: boolean;
+  if?: string;
+  input?: Record<
+    string,
+    {
+      name?: string;
+      description?: string;
+      schema?: VariableSchema;
+      "answer-to"?: string;
+    }
+  >;
+}
+
+export interface SnippetDefinition {
+  name: string;
+  /** semver 形式のバージョン文字列 (例: "1.0.0")。省略時は未バージョン管理扱い */
+  version?: string;
+  description?: string;
+  tags?: string[];
+  dependencies?: string[];
+  variables?: Record<string, VariableDefinition>;
+  hooks?: {
+    "before-install"?: Action[];
+    "after-install"?: Action[];
+  };
+}
+
+export function parseSnippetYaml(content: string): SnippetDefinition {
+  // 安全なパーサー使用（サイズ制限・カスタムタグ禁止）
+  const parsed = safeParseYaml(content);
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new ValidationError("snippet YAML のパースに失敗しました");
+  }
+  const def = parsed as SnippetDefinition;
+  validateSnippetDefinition(def);
+  return def;
+}
+
+export function serializeSnippetYaml(def: SnippetDefinition): string {
+  return yaml.dump(def, { noRefs: true, lineWidth: -1 });
+}
+
+export function validateSnippetDefinition(def: SnippetDefinition): void {
+  if (!def.name || typeof def.name !== "string") {
+    throw new ValidationError("snippet 定義に name フィールドが必要です");
+  }
+  validateSnippetName(def.name);
+  if (def.dependencies !== undefined) {
+    if (!Array.isArray(def.dependencies)) {
+      throw new ValidationError("dependencies は配列でなければなりません");
+    }
+    for (const dep of def.dependencies) {
+      if (typeof dep !== "string") {
+        throw new ValidationError(
+          `dependencies の各要素は文字列でなければなりません。受け取った値: ${typeof dep}`,
+        );
+      }
+      validateSnippetName(dep);
+    }
+  }
+  if (def.variables !== undefined) {
+    if (typeof def.variables !== "object" || def.variables === null) {
+      throw new ValidationError("variables はオブジェクトでなければなりません");
+    }
+    for (const [key, varDef] of Object.entries(def.variables)) {
+      if (typeof varDef !== "object" || varDef === null) {
+        throw new ValidationError(
+          `変数 "${key}" の定義はオブジェクトでなければなりません`,
+        );
+      }
+      if (varDef.suggests !== undefined) {
+        if (!Array.isArray(varDef.suggests)) {
+          throw new ValidationError(
+            `変数 "${key}" の suggests は配列でなければなりません`,
+          );
+        }
+        for (const item of varDef.suggests) {
+          if (typeof item !== "string") {
+            throw new ValidationError(
+              `変数 "${key}" の suggests の各要素は文字列でなければなりません`,
+            );
+          }
+        }
+      }
+      // $ref によるJSON Schema外部参照攻撃を禁止
+      checkNoRefInSchema(varDef.schema);
+      if (varDef.schema?.type !== undefined) {
+        const validTypes = ["string", "number", "boolean"];
+        if (!validTypes.includes(varDef.schema.type)) {
+          throw new ValidationError(
+            `変数 "${key}" の type "${varDef.schema.type}" は無効です。string, number, boolean のいずれかを指定してください`,
+          );
+        }
+      }
+    }
+  }
+}

package/src/template-engine.ts

@@ -0,0 +1,114 @@
+import Handlebars from "handlebars";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  listTemplateFiles,
+  readTemplateFile,
+} from "./registry.js";
+
+export function expandTemplate(
+  template: string,
+  variables: Record<string, unknown>,
+): string {
+  const compiled = Handlebars.compile(template, { noEscape: true });
+  return compiled(variables);
+}
+
+export function expandPath(
+  pathTemplate: string,
+  variables: Record<string, unknown>,
+): string {
+  const expanded = expandTemplate(pathTemplate, variables);
+  // 展開後のパスを正規化（空セグメント除去、区切り文字統一）
+  return path.normalize(expanded);
+}
+
+export function extractVariables(template: string): string[] {
+  const ast = Handlebars.parse(template);
+  const vars = new Set<string>();
+
+  function visitExpression(expr: hbs.AST.Expression): void {
+    if (expr.type === "PathExpression") {
+      const pathExpr = expr as hbs.AST.PathExpression;
+      vars.add(pathExpr.parts[0]);
+    }
+  }
+
+  function visit(node: hbs.AST.Node): void {
+    if (node.type === "MustacheStatement") {
+      const stmt = node as hbs.AST.MustacheStatement;
+      if (stmt.path) visitExpression(stmt.path);
+      if (stmt.params) {
+        for (const param of stmt.params) visitExpression(param);
+      }
+    }
+    if (node.type === "BlockStatement") {
+      const block = node as hbs.AST.BlockStatement;
+      // #if, #unless, #each 等のパラメータから変数を抽出
+      if (block.params) {
+        for (const param of block.params) visitExpression(param);
+      }
+      if (block.program) visit(block.program);
+      if (block.inverse) visit(block.inverse);
+    }
+    if ("body" in node && Array.isArray((node as hbs.AST.Program).body)) {
+      for (const child of (node as hbs.AST.Program).body) {
+        visit(child);
+      }
+    }
+  }
+
+  visit(ast);
+  return [...vars];
+}
+
+export function extractVariablesFromDirectory(dirPath: string): string[] {
+  const allVars = new Set<string>();
+
+  function walkDir(currentPath: string): void {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        // ディレクトリ名からも変数を抽出
+        for (const v of extractVariables(entry.name)) {
+          allVars.add(v);
+        }
+        walkDir(fullPath);
+      } else {
+        // ファイル名から変数を抽出
+        for (const v of extractVariables(entry.name)) {
+          allVars.add(v);
+        }
+        // ファイル内容から変数を抽出
+        const content = fs.readFileSync(fullPath, "utf-8");
+        for (const v of extractVariables(content)) {
+          allVars.add(v);
+        }
+      }
+    }
+  }
+
+  if (fs.existsSync(dirPath)) {
+    walkDir(dirPath);
+  }
+  return [...allVars];
+}
+
+export function expandTemplateDirectory(
+  registryPath: string,
+  snippetName: string,
+  variables: Record<string, unknown>,
+): Map<string, string> {
+  const files = listTemplateFiles(registryPath, snippetName);
+  const result = new Map<string, string>();
+
+  for (const filePath of files) {
+    const expandedPath = expandPath(filePath, variables);
+    const content = readTemplateFile(registryPath, snippetName, filePath);
+    const expandedContent = expandTemplate(content, variables);
+    result.set(expandedPath, expandedContent);
+  }
+
+  return result;
+}

package/src/validate-name.ts

@@ -0,0 +1,12 @@
+import { ValidationError } from "./errors.js";
+import { t } from "./i18n/index.js";
+
+const SNIPPET_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9-]*$/;
+
+export function validateSnippetName(name: string): void {
+  if (!SNIPPET_NAME_PATTERN.test(name)) {
+    throw new ValidationError(
+      t("error.invalid-snippet-name", { name }),
+    );
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true,
+    "composite": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}