@adea-ai/plugins 3.0.10 → 4.0.1

package/src/icons.ts

@@ -73,42 +73,20 @@ const MARK_WORDS = new Set([
   'logomark',
   'wordmark',
 ])
-const VARIANT_WORDS = new Set([
-  'large',
-  'small',
-  'light',
-  'dark',
-  'mono',
-  'white',
-  'black',
-  'positive',
-  'negative',
-  'color',
-  'colour',
-  'primary',
-  'secondary',
-  'horizontal',
-  'vertical',
-  'square',
-  'flat',
-  'glyph',
-])
-
 /**
  * Splits a file name into mark tokens. Separators are normalised because
  * vendors write marks as `logo.svg`, `atlan-logo.png`, `Dynatrace_Logo_color_positive.png`
  * or `cs logo big.png` alike.
  */
-function splitName(basename: string): { stems: string[]; marks: boolean; size: number } {
+function splitName(basename: string): { stemRank: number | undefined; size: number } {
   const withoutExtension = basename.slice(0, basename.lastIndexOf('.'))
   const words = withoutExtension
     .split(/[\s._-]+/)
     .filter(Boolean)
     .map((word) => word.toLowerCase())
   const size = words.some((word) => word === 'small') ? 1 : 0
-  const marks = words.some((word) => MARK_WORDS.has(word))
-  const stems = words.filter((word) => !MARK_WORDS.has(word) && !VARIANT_WORDS.has(word))
-  return { stems, marks, size }
+  const ranks = words.filter((word) => MARK_WORDS.has(word)).map((word) => STEM_RANK[word] ?? 0)
+  return { stemRank: ranks.length > 0 ? Math.min(...ranks) : undefined, size }
 }
 
 /**
@@ -133,9 +111,7 @@ export function selectIconPath(fileIndex: readonly string[]): string | null {
     const directories = segments.map((segment) => segment.toLowerCase())
     if (directories.some((segment) => EXCLUDED.test(segment))) continue
     if (directories.some((segment) => EXCLUDED_DIRECTORIES.includes(segment))) continue
-    const { stems, marks, size } = splitName(basename)
-    const single = stems.length === 1 ? stems[0]! : undefined
-    const stemRank = marks ? (single ? (STEM_RANK[single] ?? 0) : 0) : undefined
+    const { stemRank, size } = splitName(basename)
     const nested = directories.filter((segment) => DIRECTORY_RANK[segment] !== undefined)
     // A mark named as one — `logo.svg`, `atlan-logo.png`, `cs_logo_large.png` —
     // is accepted anywhere, including the plugin root. An unnamed image must sit
@@ -149,7 +125,8 @@ export function selectIconPath(fileIndex: readonly string[]): string | null {
           : 0
     if (!Number.isFinite(directoryRank)) continue
     const score = [stemRank ?? 5, directoryRank, size, EXTENSION_RANK[extension] ?? 9, path.length]
-    if (!best || compareScore(score, best.score) < 0) best = { path, score }
+    const comparison = best ? compareScore(score, best.score) : -1
+    if (!best || comparison < 0 || (comparison === 0 && path < best.path)) best = { path, score }
   }
   return best ? best.path : null
 }

package/src/index.test.ts

@@ -1,4 +1,5 @@
-import { mkdtemp, mkdir, readFile, symlink, writeFile } from 'node:fs/promises'
+import { chmod, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises'
+import { execFileSync } from 'node:child_process'
 import { readdirSync, readFileSync } from 'node:fs'
 import { gzipSync } from 'node:zlib'
 import { pack } from 'tar-stream'
@@ -21,6 +22,7 @@ import {
   type CategoryMap,
   type ProductAliases,
   type ResolvedSource,
+  type GeneratedArtifacts,
 } from './index.js'
 import {
   parseJsonDocument,
@@ -28,7 +30,6 @@ import {
   parseSourceSpec,
   type SourceConfig,
 } from './sources.js'
-import { createMaterializationPlan, supportedHarnesses } from './harness.js'
 
 const sources: SourceConfig[] = [
   {
@@ -409,6 +410,232 @@ describe('deterministic catalog synchronization', () => {
     ).rejects.toThrow('SOURCE_LOCK_PLUGIN_PIN_MISMATCH: pin-test:remote')
   })
 
+  test('refreshes explicit external revisions and repositories outside lock replay', async () => {
+    const fixtureRoot = await mkdtemp(join(tmpdir(), 'plugin-pin-refresh-'))
+    try {
+      await mkdir(join(fixtureRoot, 'pin-test'), { recursive: true })
+      const manifestPath = join(fixtureRoot, 'pin-test', 'marketplace.json')
+      const writeManifest = (sha: string, url = 'https://github.com/acme/remote-plugin') =>
+        writeFile(
+          manifestPath,
+          JSON.stringify({
+            plugins: [
+              {
+                name: 'remote',
+                description: 'Remote fixture plugin.',
+                source: { source: 'git', url, sha },
+              },
+            ],
+          })
+        )
+      const source: SourceConfig = {
+        ...sources[0]!,
+        sourceId: 'pin-test',
+        manifestPath: 'marketplace.json',
+        fixturePath: 'pin-test',
+        fixtureCommitSha: '5'.repeat(40),
+      }
+      const options = {
+        sources: [source],
+        categoryMap,
+        productAliases,
+        policy,
+        mode: 'offline' as const,
+        fixtureRoot,
+        snapshotLoader: {
+          load: async () => ({
+            files: new Map([['plugin.json', new TextEncoder().encode('{"name":"Remote"}')]]),
+            symlinks: [],
+          }),
+        },
+      }
+      await writeManifest('6'.repeat(40))
+      const first = await synchronize(options)
+      await writeManifest('7'.repeat(40))
+      const refreshed = await synchronize({ ...options, existingLock: first.lock! })
+      expect(refreshed.lock?.sources[0]?.pluginPins[0]?.resolvedCommitSha).toBe('7'.repeat(40))
+      expect(refreshed.catalog?.plugins[0]?.availableReleases[0]?.resolvedCommitSha).toBe(
+        '7'.repeat(40)
+      )
+      await writeManifest('8'.repeat(40), 'https://github.com/acme/replacement-plugin')
+      const replaced = await synchronize({ ...options, existingLock: refreshed.lock! })
+      expect(replaced.lock?.sources[0]?.pluginPins[0]?.repositoryUrl).toBe(
+        'https://github.com/acme/replacement-plugin'
+      )
+      expect(replaced.lock?.sources[0]?.pluginPins[0]?.resolvedCommitSha).toBe('8'.repeat(40))
+    } finally {
+      await rm(fixtureRoot, { recursive: true, force: true })
+    }
+  })
+
+  test.skipIf(process.platform === 'win32')(
+    'pins annotated and lightweight tags to the target commit',
+    async () => {
+      const root = await mkdtemp(join(tmpdir(), 'plugin-tag-pin-'))
+      const repo = join(root, 'repository')
+      const bin = join(root, 'bin')
+      const originalPath = process.env.PATH
+      const originalGit = process.env.ADEA_TEST_REAL_GIT
+      const originalRepo = process.env.ADEA_TEST_TAG_REPO
+      const originalFetch = globalThis.fetch
+      const realGit = execFileSync('which', ['git'], { encoding: 'utf8' }).trim()
+      const git = (...args: string[]) =>
+        execFileSync(realGit, ['-C', repo, ...args], { encoding: 'utf8' }).trim()
+      try {
+        await mkdir(repo)
+        await mkdir(bin)
+        git('init', '-q', '-b', 'main')
+        git(
+          '-c',
+          'user.name=Fixture',
+          '-c',
+          'user.email=fixture@example.invalid',
+          'commit',
+          '--allow-empty',
+          '-qm',
+          'fixture'
+        )
+        git(
+          '-c',
+          'user.name=Fixture',
+          '-c',
+          'user.email=fixture@example.invalid',
+          'tag',
+          '-a',
+          'annotated',
+          '-m',
+          'fixture'
+        )
+        git('tag', 'lightweight')
+        const commit = git('rev-parse', 'HEAD')
+        expect(git('rev-parse', 'refs/tags/annotated')).not.toBe(commit)
+        const sourceSha = '5'.repeat(40)
+        const source: SourceConfig = {
+          ...sources[0]!,
+          sourceId: 'tag-fixture',
+          repositoryUrl: 'https://github.com/acme/marketplace',
+          manifestPath: 'marketplace.json',
+        }
+        const script = join(bin, 'git')
+        await writeFile(
+          script,
+          `#!/bin/sh\nif [ "$2" = "${source.repositoryUrl}" ]; then\n  printf '%s\\t%s\\n' '${sourceSha}' "$3"\nelse\n  shift 2\n  exec "$ADEA_TEST_REAL_GIT" ls-remote "$ADEA_TEST_TAG_REPO" "$@"\nfi\n`
+        )
+        await chmod(script, 0o700)
+        process.env.ADEA_TEST_REAL_GIT = realGit
+        process.env.ADEA_TEST_TAG_REPO = repo
+        process.env.PATH = `${bin}:${originalPath ?? ''}`
+        for (const ref of ['refs/tags/annotated', 'refs/tags/lightweight', 'refs/heads/main']) {
+          const manifest = JSON.stringify({
+            plugins: [
+              {
+                name: 'remote',
+                source: { source: 'git', url: 'https://github.com/acme/remote-plugin', ref },
+              },
+            ],
+          })
+          globalThis.fetch = (async (_url: unknown) => new Response(manifest)) as typeof fetch
+          const loaded: string[] = []
+          const result = await synchronize({
+            sources: [source],
+            categoryMap,
+            productAliases,
+            policy,
+            mode: 'live',
+            snapshotLoader: {
+              load: async (_url, sha) => {
+                loaded.push(sha)
+                return {
+                  files: new Map([['plugin.json', new TextEncoder().encode('{"name":"Remote"}')]]),
+                  symlinks: [],
+                }
+              },
+            },
+          })
+          expect(result.lock?.sources[0]?.pluginPins[0]?.resolvedCommitSha).toBe(commit)
+          expect(loaded).toEqual([commit])
+        }
+      } finally {
+        globalThis.fetch = originalFetch
+        if (originalPath === undefined) delete process.env.PATH
+        else process.env.PATH = originalPath
+        if (originalGit === undefined) delete process.env.ADEA_TEST_REAL_GIT
+        else process.env.ADEA_TEST_REAL_GIT = originalGit
+        if (originalRepo === undefined) delete process.env.ADEA_TEST_TAG_REPO
+        else process.env.ADEA_TEST_TAG_REPO = originalRepo
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+
+  test.skipIf(process.platform === 'win32')(
+    'refreshes floating external refs even when the marketplace head is unchanged',
+    async () => {
+      const bin = await mkdtemp(join(tmpdir(), 'plugin-live-pin-'))
+      const originalPath = process.env.PATH
+      const originalFetch = globalThis.fetch
+      const sourceSha = '5'.repeat(40)
+      const source: SourceConfig = {
+        ...sources[0]!,
+        sourceId: 'live-pin-test',
+        repositoryUrl: 'https://github.com/acme/marketplace',
+        manifestPath: 'marketplace.json',
+      }
+      const manifest = JSON.stringify({
+        plugins: [
+          {
+            name: 'remote',
+            description: 'Remote plugin.',
+            source: { source: 'git', url: 'https://github.com/acme/remote-plugin', ref: 'main' },
+          },
+        ],
+      })
+      const gitPath = join(bin, 'git')
+      const writeGit = async (pluginSha: string) => {
+        await writeFile(
+          gitPath,
+          `#!/bin/sh\nif [ "$2" = "${source.repositoryUrl}" ]; then\n  printf '%s\\t%s\\n' '${sourceSha}' "$3"\nelse\n  printf '%s\\t%s\\n' '${pluginSha}' "$3"\nfi\n`
+        )
+        await chmod(gitPath, 0o700)
+      }
+      try {
+        process.env.PATH = `${bin}:${originalPath ?? ''}`
+        globalThis.fetch = (async (url) => {
+          expect(String(url)).toBe(
+            `https://raw.githubusercontent.com/acme/marketplace/${sourceSha}/marketplace.json`
+          )
+          return new Response(manifest)
+        }) as typeof fetch
+        const options = {
+          sources: [source],
+          categoryMap,
+          productAliases,
+          policy,
+          mode: 'live' as const,
+          snapshotLoader: {
+            load: async () => ({
+              files: new Map([['plugin.json', new TextEncoder().encode('{"name":"Remote"}')]]),
+              symlinks: [],
+            }),
+          },
+        }
+        await writeGit('6'.repeat(40))
+        const first = await synchronize(options)
+        await writeGit('7'.repeat(40))
+        const next = await synchronize({ ...options, existingLock: first.lock! })
+        expect(next.changed).toBe(true)
+        expect(next.lock?.sources[0]?.pluginPins[0]?.resolvedCommitSha).toBe('7'.repeat(40))
+        const replay = await synchronize({ ...options, fromLock: first.lock! })
+        expect(replay.lock?.sources[0]?.pluginPins[0]?.resolvedCommitSha).toBe('6'.repeat(40))
+      } finally {
+        globalThis.fetch = originalFetch
+        if (originalPath === undefined) delete process.env.PATH
+        else process.env.PATH = originalPath
+        await rm(bin, { recursive: true, force: true })
+      }
+    }
+  )
+
   test('skips apollo-skills symlinks deterministically without dropping safe plugins', async () => {
     const fixtureRoot = await mkdtemp(join(tmpdir(), 'apollo-symlink-'))
     await mkdir(join(fixtureRoot, 'apollo'), { recursive: true })
@@ -477,6 +704,26 @@ describe('deterministic catalog synchronization', () => {
     verifyArtifacts(result.artifacts!)
   })
 
+  test('preserves an existing recovery directory when writing artifacts', async () => {
+    const parent = await mkdtemp(join(tmpdir(), 'plugin-recovery-'))
+    const output = join(parent, 'generated')
+    const backup = `${output}.previous`
+    try {
+      await mkdir(backup)
+      await writeFile(join(backup, 'keep.txt'), 'recover me')
+      const artifacts = { 'catalog.v1.json': '{}' } as unknown as GeneratedArtifacts
+      await expect(writeArtifacts(output, artifacts)).rejects.toThrow('CATALOG_RECOVERY_REQUIRED')
+      expect(await readFile(join(backup, 'keep.txt'), 'utf8')).toBe('recover me')
+      await mkdir(output)
+      await writeFile(join(output, 'current.txt'), 'current')
+      await expect(writeArtifacts(output, artifacts)).rejects.toThrow('CATALOG_RECOVERY_REQUIRED')
+      expect(await readFile(join(backup, 'keep.txt'), 'utf8')).toBe('recover me')
+      expect(await readFile(join(output, 'current.txt'), 'utf8')).toBe('current')
+    } finally {
+      await rm(parent, { recursive: true, force: true })
+    }
+  })
+
   test('keeps a failed build from producing a new artifact set', async () => {
     const first = await synchronize({
       sources,
@@ -537,37 +784,6 @@ describe('identity, classification, and harness contracts', () => {
     )
     expect(normalizeCategory('Developer Tools', categoryMap)).toBe('developer-tools')
   })
-
-  test('generates a deterministic non-installing plan for every harness', async () => {
-    const result = await synchronize({
-      sources,
-      categoryMap,
-      productAliases,
-      policy,
-      mode: 'offline',
-      fixtureRoot: join(process.cwd(), 'fixtures'),
-    })
-    const catalog = result.catalog!
-    for (const harness of supportedHarnesses()) {
-      const plan = createMaterializationPlan({
-        catalog,
-        pluginId: 'plugin:openai-official:linear',
-        harness,
-      })
-      expect(plan.pluginId).toBe('plugin:openai-official:linear')
-      expect(plan.configuration.executeInstallation).toBe(false)
-      expect(JSON.stringify(plan)).toBe(
-        JSON.stringify(
-          createMaterializationPlan({
-            catalog,
-            pluginId: plan.pluginId,
-            harness,
-            releaseId: plan.releaseId,
-          })
-        )
-      )
-    }
-  })
 })
 
 describe('filesystem safety', () => {
@@ -699,9 +915,13 @@ describe('upstream fetch quarantine', () => {
   })
 
   test('quarantines a plugin when the archive keeps failing', async () => {
-    const stub = stubFetch((url) => {
+    let recovered = false
+    const stub = stubFetch(async (url) => {
       if (url === treeUrl) return jsonResponse(treePayload(['plugins/demo/plugin.json']))
-      if (isArchive(url)) return new Response('broken', { status: 500 })
+      if (isArchive(url))
+        return recovered
+          ? tarballResponse([{ path: 'plugins/demo/plugin.json', body: manifestBytes }])
+          : new Response('broken', { status: 500 })
       return new Response('unexpected', { status: 200 })
     })
     try {
@@ -712,6 +932,9 @@ describe('upstream fetch quarantine', () => {
       )
       expect(error?.message).toMatch(/^PLUGIN_SOURCE_UNAVAILABLE:/)
       expect(stub.calls.filter(isArchive)).toHaveLength(3)
+      recovered = true
+      expect((await loader.load(repo, sha, 'plugins/demo')).files.has('plugin.json')).toBe(true)
+      expect(stub.calls.filter(isArchive)).toHaveLength(4)
     } finally {
       stub.restore()
     }
@@ -745,11 +968,15 @@ describe('upstream fetch quarantine', () => {
 
   test('does not retry a forbidden tree without rate-limit signals', async () => {
     let treeCalls = 0
-    const stub = stubFetch((url) => {
+    const stub = stubFetch(async (url) => {
       if (url === treeUrl) {
         treeCalls += 1
-        return new Response('denied', { status: 403 })
+        return treeCalls === 1
+          ? new Response('denied', { status: 403 })
+          : jsonResponse(treePayload(['plugins/demo/plugin.json']))
       }
+      if (isArchive(url))
+        return tarballResponse([{ path: 'plugins/demo/plugin.json', body: manifestBytes }])
       return new Response('unexpected', { status: 500 })
     })
     try {
@@ -760,6 +987,8 @@ describe('upstream fetch quarantine', () => {
       )
       expect(error?.message).toMatch(/^PLUGIN_SOURCE_UNAVAILABLE:/)
       expect(treeCalls).toBe(1)
+      expect((await loader.load(repo, sha, 'plugins/demo')).files.has('plugin.json')).toBe(true)
+      expect(treeCalls).toBe(2)
     } finally {
       stub.restore()
     }
@@ -779,11 +1008,14 @@ describe('upstream fetch quarantine', () => {
     })
     try {
       const loader = new NetworkSnapshotLoader(policy)
-      const first = await loader.load(repo, sha, 'plugins/one')
-      const second = await loader.load(repo, sha, 'plugins/two')
+      const [first, second] = await Promise.all([
+        loader.load(repo, sha, 'plugins/one'),
+        loader.load(repo, sha, 'plugins/two'),
+      ])
       expect([...first.files.keys()]).toEqual(['plugin.json'])
       expect([...second.files.keys()].toSorted()).toEqual(['plugin.json', 'run.sh'])
-      // The whole point: three files, and the archive is fetched once.
+      // Concurrent plugins share both requests, not only the finished cache.
+      expect(stub.calls.filter((url) => url === treeUrl)).toHaveLength(1)
       expect(stub.calls.filter(isArchive)).toHaveLength(1)
       expect(stub.calls.filter(isRawGitHubHost)).toHaveLength(0)
     } finally {