@pzy560117/opentest 0.1.3 → 0.1.5

package/scripts/smoke-test.js

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
 
 import { readFileSync } from 'fs';
-import { access } from 'fs/promises';
+import { access, mkdir, mkdtemp, rm, writeFile } from 'fs/promises';
 import path from 'path';
+import { tmpdir } from 'os';
 import { spawnSync } from 'child_process';
 
 const manifest = JSON.parse(readFileSync('assets/manifest.json', 'utf8'));
 let failures = 0;
+const requiredLanguages = ['en', 'zh'];
+const requiredPlatforms = ['codex', 'claude', 'cursor', 'opencode', 'gemini', 'qwen', 'qoder'];
+const expectedSharedFiles = [
+  'opentest/scripts/opentest-state.sh',
+  'opentest/scripts/opentest-detect.sh',
+  'opentest/scripts/opentest-guard.sh',
+];
 
 async function exists(filePath) {
   try {
@@ -17,45 +25,507 @@ async function exists(filePath) {
   }
 }
 
-for (const skillPath of manifest.skills) {
-  const fullPath = path.join('assets', 'skills', skillPath);
+function assert(condition, message) {
+  if (!condition) {
+    console.error(message);
+    failures += 1;
+  }
+}
+
+function pathSegments(file) {
+  return file.split(/[\\/]+/).filter(Boolean);
+}
+
+function manifestPathRelativityErrors(kind, file) {
+  const errors = [];
+  const normalized = file.replace(/\\/g, '/');
+
+  if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(file)) {
+    errors.push(`[${kind}] Managed file path must be relative: ${file}`);
+  }
+  if (pathSegments(file).includes('..')) {
+    errors.push(`[${kind}] Managed file path must not traverse parent directories: ${file}`);
+  }
+  if (kind === 'LOCALIZED' && (normalized.startsWith('skills/') || normalized.startsWith('skills-zh/'))) {
+    errors.push(`[${kind}] Localized file must be relative to each language skills dir: ${file}`);
+  }
+
+  return errors;
+}
+
+function assertManifestPathRelativity(kind, file) {
+  for (const error of manifestPathRelativityErrors(kind, file)) {
+    console.error(error);
+    failures += 1;
+  }
+}
+
+function runManifestPathRelativitySelfCheck() {
+  const localizedInvalidPaths = [
+    path.resolve('opentest/SKILL.md'),
+    '/tmp/x.md',
+    'C:/tmp/x.md',
+    'C:\\tmp\\x.md',
+    '\\\\server\\share\\x.md',
+    '../opentest/SKILL.md',
+    'skills/opentest/SKILL.md',
+    'skills-zh/opentest/SKILL.md',
+  ];
+
+  for (const file of localizedInvalidPaths) {
+    assert(
+      manifestPathRelativityErrors('LOCALIZED', file).length > 0,
+      `[SELFTEST] managedFiles.localized path relativity check did not reject ${file}`,
+    );
+  }
+
+  const sharedInvalidPaths = [
+    path.resolve('opentest/scripts/opentest-state.sh'),
+    '/tmp/x.md',
+    'C:/tmp/x.md',
+    'C:\\tmp\\x.md',
+    '\\\\server\\share\\x.md',
+    '../opentest/scripts/opentest-state.sh',
+  ];
+
+  for (const file of sharedInvalidPaths) {
+    assert(
+      manifestPathRelativityErrors('SHARED', file).length > 0,
+      `[SELFTEST] managedFiles.shared path relativity check did not reject ${file}`,
+    );
+  }
+}
+
+function languageById(languageId) {
+  return Array.isArray(manifest.languages)
+    ? manifest.languages.find((entry) => entry.id === languageId)
+    : undefined;
+}
+
+function assertManifestStructure() {
+  assert(typeof manifest.version === 'string' && manifest.version.length > 0, '[MANIFEST] missing version');
+  assert(Array.isArray(manifest.languages), '[MANIFEST] languages must be an array');
+  for (const language of requiredLanguages) {
+    const entry = languageById(language);
+    assert(entry, `[MANIFEST] missing languages entry ${language}`);
+    assert(entry?.name, `[MANIFEST] missing languages.${language}.name`);
+    assert(entry?.skillsDir, `[MANIFEST] missing languages.${language}.skillsDir`);
+  }
+  assert(languageById('en')?.name === 'English', '[MANIFEST] languages.en.name must be English');
+  assert(languageById('en')?.skillsDir === 'skills', '[MANIFEST] languages.en.skillsDir must be skills');
+  assert(languageById('zh')?.name === '中文', '[MANIFEST] languages.zh.name must be 中文');
+  assert(languageById('zh')?.skillsDir === 'skills-zh', '[MANIFEST] languages.zh.skillsDir must be skills-zh');
+
+  assert(Array.isArray(manifest.platforms), '[MANIFEST] missing platforms');
+  for (const platformId of requiredPlatforms) {
+    const platform = manifest.platforms?.find((entry) => entry.id === platformId);
+    assert(platform, `[MANIFEST] missing platforms.${platformId}`);
+    assert(platform?.name, `[MANIFEST] missing platforms.${platformId}.name`);
+    assert(platform?.projectSkillsDir, `[MANIFEST] missing platforms.${platformId}.projectSkillsDir`);
+    assert(platform?.globalSkillsDir, `[MANIFEST] missing platforms.${platformId}.globalSkillsDir`);
+  }
+  const opencode = manifest.platforms?.find((entry) => entry.id === 'opencode');
+  assert(opencode?.globalSkillsDir === '.config/opencode/skills', '[MANIFEST] platforms.opencode.globalSkillsDir must be .config/opencode/skills');
+
+  assert(manifest.managedFiles && typeof manifest.managedFiles === 'object' && !Array.isArray(manifest.managedFiles), '[MANIFEST] missing managedFiles');
+  assert(Array.isArray(manifest.managedFiles?.localized), '[MANIFEST] missing managedFiles.localized');
+  assert(Array.isArray(manifest.managedFiles?.shared), '[MANIFEST] missing managedFiles.shared');
+  for (const file of expectedSharedFiles) {
+    assert(manifest.managedFiles?.shared?.includes(file), `[MANIFEST] missing managedFiles.shared entry ${file}`);
+  }
+  for (const file of manifest.managedFiles?.shared ?? []) {
+    assert(!file.startsWith('skills/'), `[MANIFEST] managedFiles.shared must be relative to English skills dir: ${file}`);
+  }
+}
+
+function assertPrepublishGateCoversManifestAssets() {
+  const prepublishCheck = readFileSync('scripts/prepublish-check.js', 'utf8');
+  const secretsScanIndex = prepublishCheck.indexOf('for (const filePath of walkFiles');
+  const manifestReadIndex = prepublishCheck.indexOf("assets/manifest.json");
+
+  assert(secretsScanIndex !== -1, '[PREPUBLISH] secrets scan loop not found');
+  assert(manifestReadIndex !== -1, '[PREPUBLISH] prepublish check must load assets/manifest.json');
+  assert(
+    manifestReadIndex !== -1 && secretsScanIndex !== -1 && manifestReadIndex < secretsScanIndex,
+    '[PREPUBLISH] manifest checks must run before secrets scanning',
+  );
+  assert(prepublishCheck.includes('manifest.languages'), '[PREPUBLISH] must validate manifest.languages');
+  assert(prepublishCheck.includes("entry.id === 'zh'"), '[PREPUBLISH] must require zh language in manifest');
+  assert(prepublishCheck.includes('manifest.managedFiles?.localized'), '[PREPUBLISH] must validate managedFiles.localized');
+  assert(prepublishCheck.includes('manifest.managedFiles?.shared'), '[PREPUBLISH] must validate managedFiles.shared');
+  assert(prepublishCheck.includes("assets/skills-zh"), '[PREPUBLISH] must validate assets/skills-zh exists');
+}
+
+async function assertPrepublishRejectsPublishSecretTextFiles() {
+  const fixtureDir = path.join('assets', 'opentest-smoke-secret-fixtures');
+  const fixtures = [
+    {
+      file: path.join(fixtureDir, 'fixture.pem'),
+      content: `${['-----BEGIN PRIVATE', 'KEY-----'].join(' ')}\nnot-a-real-key\n-----END PRIVATE KEY-----\n`,
+      expected: 'Private key',
+    },
+    {
+      file: path.join(fixtureDir, '.env'),
+      content: `${['OPENTEST', 'TOKEN'].join('_')}="super-secret-token-value"\n`,
+      expected: 'Secret/token',
+    },
+    {
+      file: path.join(fixtureDir, 'extensionless-secret'),
+      content: `${['api', 'key'].join('_')}="1234567890abcdefghijklmnop"\n`,
+      expected: 'API key',
+    },
+  ];
+
+  try {
+    await mkdir(fixtureDir, { recursive: true });
+    await Promise.all(fixtures.map((fixture) => writeFile(fixture.file, fixture.content)));
+
+    const result = spawnSync(process.execPath, ['scripts/prepublish-check.js'], { encoding: 'utf8' });
+    assert(result.status !== 0, '[PREPUBLISH] expected secrets in publish text files to fail prepublish check');
+    for (const fixture of fixtures) {
+      assert(
+        result.stderr.includes(fixture.expected) && result.stderr.includes(fixture.file),
+        `[PREPUBLISH] expected ${fixture.file} to be reported as ${fixture.expected}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+      );
+    }
+  } finally {
+    await rm(fixtureDir, { recursive: true, force: true });
+  }
+}
+
+function localizedFiles() {
+  if (!Array.isArray(manifest.managedFiles?.localized)) {
+    return [];
+  }
+
+  return manifest.managedFiles.localized.flatMap((entry) => (
+    (manifest.languages ?? []).map((language) => path.join(language.skillsDir, entry))
+  ));
+}
+
+function sharedFiles() {
+  return Array.isArray(manifest.managedFiles?.shared) ? manifest.managedFiles.shared : [];
+}
+
+function sharedAssetFiles() {
+  return sharedFiles().map((entry) => path.join(languageById('en')?.skillsDir ?? 'skills', entry));
+}
+
+function hasChineseText(content) {
+  return /\p{Script=Han}/u.test(content);
+}
+
+function manifestDirSearchRoot(manifestDir, scope) {
+  const normalized = manifestDir.replace(/\\/g, '/');
+  if (scope === 'global') {
+    return normalized.startsWith('~/') ? `$HOME/${normalized.slice(2)}` : `$HOME/${normalized}`;
+  }
+  return normalized;
+}
+
+function assertOpenTestSearchRootsCoverPlatforms() {
+  for (const language of manifest.languages ?? []) {
+    const languageLabel = `${language.id ?? '<missing id>'} (${language.name ?? '<missing name>'})`;
+    if (!language.skillsDir) {
+      assert(false, `[SEARCH_ROOTS] ${languageLabel} missing skillsDir`);
+      continue;
+    }
+
+    const skillPath = path.join('assets', language.skillsDir, 'opentest', 'SKILL.md');
+    let skillContent;
+    try {
+      skillContent = readFileSync(skillPath, 'utf8');
+    } catch {
+      assert(false, `[SEARCH_ROOTS] ${languageLabel} missing router at ${skillPath}`);
+      continue;
+    }
+
+    const searchRootsLine = skillContent.split(/\r?\n/).find((line) => line.startsWith('OPENTEST_SEARCH_ROOTS='));
+    assert(searchRootsLine, `[SEARCH_ROOTS] ${languageLabel} router ${skillPath} must define OPENTEST_SEARCH_ROOTS`);
+    if (!searchRootsLine) continue;
+
+    for (const platform of manifest.platforms ?? []) {
+      for (const [scope, manifestDir] of [
+        ['project', platform.projectSkillsDir],
+        ['global', platform.globalSkillsDir],
+      ]) {
+        if (!manifestDir) {
+          assert(false, `[SEARCH_ROOTS] ${languageLabel} missing ${platform.id} ${scope} manifest dir`);
+          continue;
+        }
+
+        const expectedRoot = manifestDirSearchRoot(manifestDir, scope);
+        assert(
+          searchRootsLine.includes(`"${expectedRoot}"`),
+          `[SEARCH_ROOTS] ${languageLabel} router ${skillPath} missing ${platform.id} ${scope} search root ${expectedRoot}`,
+        );
+      }
+    }
+  }
+}
+
+function assertLanguageAssetContracts() {
+  for (const file of manifest.managedFiles?.localized ?? []) {
+    const englishPath = path.join('assets', languageById('en')?.skillsDir ?? 'skills', file);
+    const chinesePath = path.join('assets', languageById('zh')?.skillsDir ?? 'skills-zh', file);
+
+    if (existsSyncLike(englishPath)) {
+      const content = readFileSync(englishPath, 'utf8');
+      assert(!hasChineseText(content), `[LANGUAGE] English asset must not contain Chinese text: ${englishPath}`);
+    }
+
+    if (existsSyncLike(chinesePath)) {
+      const content = readFileSync(chinesePath, 'utf8');
+      assert(hasChineseText(content), `[LANGUAGE] Chinese asset must remain Chinese: ${chinesePath}`);
+    }
+  }
+}
+
+function existsSyncLike(filePath) {
+  try {
+    readFileSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function assertCliRejects(args, expectedStderr) {
+  const result = spawnSync(process.execPath, ['bin/opentest.js', ...args], { encoding: 'utf8' });
+  assert(result.status !== 0, `[CLI] expected failure for: ${args.join(' ')}`);
+  assert(
+    result.stderr.includes(expectedStderr),
+    `[CLI] expected stderr to include "${expectedStderr}" for: ${args.join(' ')}\n${result.stderr}`,
+  );
+}
+
+function runCli(args, options = {}) {
+  return spawnSync(process.execPath, ['bin/opentest.js', ...args], {
+    encoding: 'utf8',
+    ...options,
+    env: {
+      ...process.env,
+      ...(options.env ?? {}),
+    },
+  });
+}
+
+function assertCliSucceeds(args, options = {}) {
+  const result = runCli(args, options);
+  assert(
+    result.status === 0,
+    `[CLI] expected success for: ${args.join(' ')}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+  );
+  return result;
+}
+
+async function makeTempDir(prefix) {
+  return mkdtemp(path.join(tmpdir(), prefix));
+}
+
+async function assertExists(filePath, message) {
+  assert(await exists(filePath), message);
+}
+
+async function assertMissing(filePath, message) {
+  assert(!(await exists(filePath)), message);
+}
+
+async function assertInstallBehavior() {
+  const project = await makeTempDir('opentest-project-');
+  const projectResult = assertCliSucceeds([
+    'install',
+    '--scope',
+    'project',
+    '--platform',
+    'qoder',
+    '--language',
+    'zh',
+    '--project',
+    project,
+  ]);
+  const qoderSkills = path.join(project, '.qoder', 'skills');
+  await assertExists(path.join(qoderSkills, 'opentest', 'SKILL.md'), '[INSTALL] missing zh qoder project opentest/SKILL.md');
+  await assertExists(
+    path.join(qoderSkills, 'opentest', 'scripts', 'opentest-state.sh'),
+    '[INSTALL] missing shared script copied from English assets for zh qoder project install',
+  );
+  assert(projectResult.stdout.includes('Platform: Qoder'), '[INSTALL] project output must include Platform: Qoder');
+  assert(projectResult.stdout.includes('Language: 中文'), '[INSTALL] project output must include Language: 中文');
+  assert(
+    projectResult.stdout.includes('Restart your AI coding tool or open a new session'),
+    '[INSTALL] restart hint must be generic across AI coding tools',
+  );
+
+  const home = await makeTempDir('opentest-home-');
+  assertCliSucceeds(['install', '--scope', 'global', '--platform', 'opencode', '--language', 'en'], {
+    env: {
+      HOME: home,
+      USERPROFILE: home,
+    },
+  });
+  await assertExists(
+    path.join(home, '.config', 'opencode', 'skills', 'opentest', 'SKILL.md'),
+    '[INSTALL] missing en opencode global opentest/SKILL.md',
+  );
+
+  const forceProject = await makeTempDir('opentest-force-');
+  const forceSkills = path.join(forceProject, '.qoder', 'skills');
+  await mkdir(path.join(forceSkills, 'opentest'), { recursive: true });
+  await mkdir(path.join(forceSkills, 'user-skill'), { recursive: true });
+  await writeFile(path.join(forceSkills, 'opentest', 'stale.txt'), 'stale opentest managed file\n');
+  await writeFile(path.join(forceSkills, 'user-skill', 'SKILL.md'), 'user managed skill\n');
+
+  const forceResult = assertCliSucceeds([
+    'install',
+    '--scope',
+    'project',
+    '--platform',
+    'qoder',
+    '--language',
+    'zh',
+    '--project',
+    forceProject,
+    '--force',
+  ]);
+  await assertExists(
+    path.join(forceSkills, 'user-skill', 'SKILL.md'),
+    '[INSTALL] --force must preserve non-OpenTest user skill directories',
+  );
+  await assertMissing(
+    path.join(forceSkills, 'opentest', 'stale.txt'),
+    '[INSTALL] --force must replace OpenTest managed directories',
+  );
+  assert(forceResult.stdout.includes('Platform: Qoder'), '[INSTALL] force output must include Platform: Qoder');
+
+  const noForceProject = await makeTempDir('opentest-no-force-');
+  const existingSkill = path.join(noForceProject, '.qoder', 'skills', 'opentest');
+  await mkdir(existingSkill, { recursive: true });
+  await writeFile(path.join(existingSkill, 'SKILL.md'), 'existing opentest skill\n');
+  const noForceResult = runCli([
+    'install',
+    '--scope',
+    'project',
+    '--platform',
+    'qoder',
+    '--language',
+    'zh',
+    '--project',
+    noForceProject,
+  ]);
+  assert(noForceResult.status !== 0, '[INSTALL] expected existing OpenTest skill to fail without --force');
+  assert(
+    noForceResult.stderr.includes('already exists. Re-run with --force to overwrite.'),
+    `[INSTALL] expected overwrite guidance for existing skill\n${noForceResult.stderr}`,
+  );
+
+  const detectedProject = await makeTempDir('opentest-detected-');
+  const detectedResult = assertCliSucceeds(['install', '--project', detectedProject], {
+    env: {
+      OPENTEST_PLATFORM: 'claude',
+      OPENTEST_LANGUAGE: 'zh',
+    },
+  });
+  await assertExists(
+    path.join(detectedProject, '.claude', 'skills', 'opentest', 'SKILL.md'),
+    '[INSTALL] OPENTEST_PLATFORM=claude must install project skills into .claude/skills',
+  );
+  assert(detectedResult.stdout.includes('Platform: Claude Code'), '[INSTALL] detected output must include Platform: Claude Code');
+  assert(detectedResult.stdout.includes('Language: 中文'), '[INSTALL] detected output must include Language: 中文');
+}
+
+async function assertInitBehavior() {
+  const project = await makeTempDir('opentest-init-');
+  const initResult = assertCliSucceeds(['init'], {
+    input: `2\n2\n1\n${project}\n`,
+  });
+
+  await assertExists(
+    path.join(project, '.claude', 'skills', 'opentest', 'SKILL.md'),
+    '[INIT] interactive init must install Claude project skills when Claude Code is selected',
+  );
+  await assertExists(
+    path.join(project, '.claude', 'skills', 'opentest', 'scripts', 'opentest-state.sh'),
+    '[INIT] interactive init must install shared OpenTest scripts',
+  );
+  assert(initResult.stdout.includes('OpenTest init'), '[INIT] output must show init wizard heading');
+  assert(initResult.stdout.includes('Target AI coding tool:'), '[INIT] output must prompt for platform');
+  assert(initResult.stdout.includes('Skill language:'), '[INIT] output must prompt for language');
+  assert(initResult.stdout.includes('Install scope:'), '[INIT] output must prompt for scope');
+  assert(initResult.stdout.includes('Platform: Claude Code'), '[INIT] output must include selected platform');
+  assert(initResult.stdout.includes('Language: 中文'), '[INIT] output must include selected language');
+}
+
+runManifestPathRelativitySelfCheck();
+assertManifestStructure();
+assertPrepublishGateCoversManifestAssets();
+assertOpenTestSearchRootsCoverPlatforms();
+assertLanguageAssetContracts();
+await assertPrepublishRejectsPublishSecretTextFiles();
+
+assertCliRejects(['install', '--language', 'jp'], 'Available languages: en, zh');
+assertCliRejects(['install', '--platform', 'invalid'], 'Available platforms: codex, claude, cursor, opencode, gemini, qwen, qoder');
+assertCliRejects(['install', '--scope', 'team'], 'Available scopes: project, global');
+await assertInstallBehavior();
+await assertInitBehavior();
+
+for (const assetPath of [...localizedFiles(), ...sharedAssetFiles()]) {
+  const fullPath = path.join('assets', assetPath);
   if (!(await exists(fullPath))) {
     console.error(`[MISSING] ${fullPath}`);
     failures += 1;
   }
 }
 
-for (const skillName of [
-  'opentest',
-  'opentest-plan',
-  'opentest-author',
-  'opentest-run',
-  'opentest-accept',
-  'opentest-verify',
-  'opentest-heal',
-  'opentest-archive',
-]) {
-  const skillFile = path.join('assets', 'skills', skillName, 'SKILL.md');
-  const content = readFileSync(skillFile, 'utf8');
+for (const skillFile of localizedFiles().filter((entry) => entry.endsWith('SKILL.md'))) {
+  const fullPath = path.join('assets', skillFile);
+  if (!(await exists(fullPath))) {
+    continue;
+  }
+
+  const content = readFileSync(fullPath, 'utf8');
   if (!/^name:\s+/m.test(content) || !/^description:\s+/m.test(content)) {
-    console.error(`[FRONTMATTER] Missing name or description in ${skillFile}`);
+    console.error(`[FRONTMATTER] Missing name or description in ${fullPath}`);
     failures += 1;
   }
 }
 
-for (const script of [
-  'assets/skills/opentest/scripts/opentest-state.sh',
-  'assets/skills/opentest/scripts/opentest-detect.sh',
-  'assets/skills/opentest/scripts/opentest-guard.sh',
-]) {
-  const result = spawnSync('bash', ['-n', script], { encoding: 'utf8' });
+for (const script of sharedAssetFiles()) {
+  const scriptPath = path.join('assets', script);
+  if (!(await exists(scriptPath))) {
+    continue;
+  }
+
+  if (!scriptPath.endsWith('.sh')) {
+    console.error(`[SCRIPT] Shared file must be a shell script: ${scriptPath}`);
+    failures += 1;
+    continue;
+  }
+
+  const result = spawnSync('bash', ['-n', scriptPath], { encoding: 'utf8' });
   if (result.status !== 0) {
-    console.error(`[BASH] ${script}`);
+    console.error(`[BASH] ${scriptPath}`);
     console.error(result.stderr || result.stdout);
     failures += 1;
   }
 }
 
+for (const file of manifest.managedFiles?.localized ?? []) {
+  assertManifestPathRelativity('LOCALIZED', file);
+  if (!file.endsWith('.md')) {
+    console.error(`[LOCALIZED] Localized file must be Markdown: ${file}`);
+    failures += 1;
+  }
+}
+
+for (const file of manifest.managedFiles?.shared ?? []) {
+  assertManifestPathRelativity('SHARED', file);
+  if (file.endsWith('.md')) {
+    console.error(`[SHARED] Shared file must not be Markdown: ${file}`);
+    failures += 1;
+  }
+}
+
 if (failures > 0) {
   console.error(`[SMOKE] ${failures} failure(s)`);
   process.exit(1);