@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/__tests__/env-ci.test.ts

@@ -0,0 +1,167 @@
+import { describe, test, expect, afterEach } from 'bun:test'
+
+import { getCiEnv, ciEnv, isCI } from '../env-ci'
+import { createTestCiEnv } from '../testing-env-ci'
+
+describe('env-ci', () => {
+  describe('getCiEnv', () => {
+    const originalEnv = { ...process.env }
+
+    afterEach(() => {
+      // Restore original env
+      Object.keys(process.env).forEach((key) => {
+        if (!(key in originalEnv)) {
+          delete process.env[key]
+        }
+      })
+      Object.assign(process.env, originalEnv)
+    })
+
+    test('returns current process.env values for CI', () => {
+      process.env.CI = 'true'
+      const env = getCiEnv()
+      expect(env.CI).toBe('true')
+    })
+
+    test('returns current process.env values for GITHUB_ACTIONS', () => {
+      process.env.GITHUB_ACTIONS = 'true'
+      const env = getCiEnv()
+      expect(env.GITHUB_ACTIONS).toBe('true')
+    })
+
+    test('returns current process.env values for ANVIL_API_KEY', () => {
+      process.env.ANVIL_API_KEY = 'test-key-123'
+      const env = getCiEnv()
+      expect(env.ANVIL_API_KEY).toBe('test-key-123')
+    })
+
+    test('returns current process.env values for ANVIL_GITHUB_TOKEN', () => {
+      process.env.ANVIL_GITHUB_TOKEN = 'ghp_test_token'
+      const env = getCiEnv()
+      expect(env.ANVIL_GITHUB_TOKEN).toBe('ghp_test_token')
+    })
+
+    test('returns undefined for unset env vars', () => {
+      delete process.env.RENDER
+      const env = getCiEnv()
+      expect(env.RENDER).toBeUndefined()
+    })
+
+    test('returns a snapshot that does not change when process.env changes', () => {
+      process.env.CI = 'true'
+      const env = getCiEnv()
+      process.env.CI = 'false'
+      // The snapshot should still have the old value
+      expect(env.CI).toBe('true')
+    })
+  })
+
+  describe('ciEnv', () => {
+    test('is a CiEnv object', () => {
+      expect(ciEnv).toBeDefined()
+      expect(typeof ciEnv).toBe('object')
+    })
+
+    test('contains expected keys', () => {
+      expect('CI' in ciEnv).toBe(true)
+      expect('GITHUB_ACTIONS' in ciEnv).toBe(true)
+      expect('ANVIL_API_KEY' in ciEnv).toBe(true)
+      expect('ANVIL_GITHUB_TOKEN' in ciEnv).toBe(true)
+    })
+  })
+
+  describe('isCI', () => {
+    const originalEnv = { ...process.env }
+
+    afterEach(() => {
+      // Restore original env
+      Object.keys(process.env).forEach((key) => {
+        if (!(key in originalEnv)) {
+          delete process.env[key]
+        }
+      })
+      Object.assign(process.env, originalEnv)
+    })
+
+    test('returns true when CI=true', () => {
+      process.env.CI = 'true'
+      delete process.env.GITHUB_ACTIONS
+      expect(isCI()).toBe(true)
+    })
+
+    test('returns true when CI=1', () => {
+      process.env.CI = '1'
+      delete process.env.GITHUB_ACTIONS
+      expect(isCI()).toBe(true)
+    })
+
+    test('returns true when GITHUB_ACTIONS=true', () => {
+      delete process.env.CI
+      process.env.GITHUB_ACTIONS = 'true'
+      expect(isCI()).toBe(true)
+    })
+
+    test('returns false when neither CI nor GITHUB_ACTIONS is set', () => {
+      delete process.env.CI
+      delete process.env.GITHUB_ACTIONS
+      expect(isCI()).toBe(false)
+    })
+
+    test('returns false when CI=false', () => {
+      process.env.CI = 'false'
+      delete process.env.GITHUB_ACTIONS
+      expect(isCI()).toBe(false)
+    })
+  })
+
+  describe('createTestCiEnv', () => {
+    test('returns a CiEnv with default test values', () => {
+      const env = createTestCiEnv()
+      expect(env.ANVIL_API_KEY).toBe('test-api-key')
+    })
+
+    test('returns undefined for most vars by default', () => {
+      const env = createTestCiEnv()
+      expect(env.CI).toBeUndefined()
+      expect(env.GITHUB_ACTIONS).toBeUndefined()
+      expect(env.RENDER).toBeUndefined()
+      expect(env.IS_PULL_REQUEST).toBeUndefined()
+      expect(env.ANVIL_GITHUB_TOKEN).toBeUndefined()
+    })
+
+    test('allows overriding specific values', () => {
+      const env = createTestCiEnv({
+        CI: 'true',
+        GITHUB_ACTIONS: 'true',
+      })
+      expect(env.CI).toBe('true')
+      expect(env.GITHUB_ACTIONS).toBe('true')
+      // Other values should still have defaults
+      expect(env.ANVIL_API_KEY).toBe('test-api-key')
+    })
+
+    test('allows overriding default values', () => {
+      const env = createTestCiEnv({
+        ANVIL_API_KEY: 'custom-api-key',
+      })
+      expect(env.ANVIL_API_KEY).toBe('custom-api-key')
+    })
+
+    test('allows setting all CI-related vars for CI simulation', () => {
+      const env = createTestCiEnv({
+        CI: 'true',
+        GITHUB_ACTIONS: 'true',
+        RENDER: 'true',
+        IS_PULL_REQUEST: 'true',
+        ANVIL_GITHUB_TOKEN: 'ghp_simulated_token',
+        ANVIL_API_KEY: 'test-api-key-override',
+      })
+      expect(env.CI).toBe('true')
+      expect(env.GITHUB_ACTIONS).toBe('true')
+      expect(env.RENDER).toBe('true')
+      expect(env.IS_PULL_REQUEST).toBe('true')
+      expect(env.ANVIL_GITHUB_TOKEN).toBe('ghp_simulated_token')
+      expect(env.ANVIL_API_KEY).toBe('test-api-key-override')
+    })
+  })
+})

package/vendor/@anvil/common/src/__tests__/env-process.test.ts

@@ -0,0 +1,145 @@
+import { describe, test, expect, afterEach } from 'bun:test'
+
+import { getProcessEnv, processEnv } from '../env-process'
+import { createTestProcessEnv } from '../testing-env-process'
+
+describe('env-process', () => {
+  describe('getProcessEnv', () => {
+    const originalEnv = { ...process.env }
+
+    afterEach(() => {
+      // Restore original env
+      Object.keys(process.env).forEach((key) => {
+        if (!(key in originalEnv)) {
+          delete process.env[key]
+        }
+      })
+      Object.assign(process.env, originalEnv)
+    })
+
+    test('returns current process.env values for SHELL', () => {
+      process.env.SHELL = '/bin/zsh'
+      const env = getProcessEnv()
+      expect(env.SHELL).toBe('/bin/zsh')
+    })
+
+    test('returns current process.env values for HOME', () => {
+      process.env.HOME = '/Users/testuser'
+      const env = getProcessEnv()
+      expect(env.HOME).toBe('/Users/testuser')
+    })
+
+    test('returns current process.env values for TERM', () => {
+      process.env.TERM = 'xterm-256color'
+      const env = getProcessEnv()
+      expect(env.TERM).toBe('xterm-256color')
+    })
+
+    test('returns current process.env values for TERM_PROGRAM', () => {
+      process.env.TERM_PROGRAM = 'iTerm.app'
+      const env = getProcessEnv()
+      expect(env.TERM_PROGRAM).toBe('iTerm.app')
+    })
+
+    test('returns current process.env values for NODE_ENV', () => {
+      process.env.NODE_ENV = 'development'
+      const env = getProcessEnv()
+      expect(env.NODE_ENV).toBe('development')
+    })
+
+    test('returns undefined for unset env vars', () => {
+      delete process.env.KITTY_WINDOW_ID
+      const env = getProcessEnv()
+      expect(env.KITTY_WINDOW_ID).toBeUndefined()
+    })
+
+    test('returns current process.env values for ANVIL_IS_BINARY', () => {
+      process.env.ANVIL_IS_BINARY = 'true'
+      const env = getProcessEnv()
+      expect(env.ANVIL_IS_BINARY).toBe('true')
+    })
+
+    test('returns a snapshot that does not change when process.env changes', () => {
+      process.env.SHELL = '/bin/bash'
+      const env = getProcessEnv()
+      process.env.SHELL = '/bin/zsh'
+      // The snapshot should still have the old value
+      expect(env.SHELL).toBe('/bin/bash')
+    })
+  })
+
+  describe('processEnv', () => {
+    test('is a ProcessEnv object', () => {
+      expect(processEnv).toBeDefined()
+      expect(typeof processEnv).toBe('object')
+    })
+
+    test('contains expected keys', () => {
+      expect('SHELL' in processEnv).toBe(true)
+      expect('HOME' in processEnv).toBe(true)
+      expect('TERM' in processEnv).toBe(true)
+      expect('NODE_ENV' in processEnv).toBe(true)
+      expect('PATH' in processEnv).toBe(true)
+    })
+  })
+
+  describe('createTestProcessEnv', () => {
+    test('returns a ProcessEnv with default test values', () => {
+      const env = createTestProcessEnv()
+      expect(env.HOME).toBe('/home/test')
+      expect(env.NODE_ENV).toBe('test')
+      expect(env.TERM).toBe('xterm-256color')
+      expect(env.PATH).toBe('/usr/bin')
+    })
+
+    test('returns undefined for most vars by default', () => {
+      const env = createTestProcessEnv()
+      expect(env.SHELL).toBeUndefined()
+      expect(env.COMSPEC).toBeUndefined()
+      expect(env.TERM_PROGRAM).toBeUndefined()
+      expect(env.KITTY_WINDOW_ID).toBeUndefined()
+      expect(env.ANVIL_IS_BINARY).toBeUndefined()
+    })
+
+    test('allows overriding specific values', () => {
+      const env = createTestProcessEnv({
+        SHELL: '/bin/fish',
+        TERM_PROGRAM: 'vscode',
+      })
+      expect(env.SHELL).toBe('/bin/fish')
+      expect(env.TERM_PROGRAM).toBe('vscode')
+      // Other values should still have defaults
+      expect(env.HOME).toBe('/home/test')
+      expect(env.NODE_ENV).toBe('test')
+    })
+
+    test('allows overriding default values', () => {
+      const env = createTestProcessEnv({
+        HOME: '/custom/home',
+        NODE_ENV: 'production',
+      })
+      expect(env.HOME).toBe('/custom/home')
+      expect(env.NODE_ENV).toBe('production')
+    })
+
+    test('allows setting ANVIL_IS_BINARY for binary mode tests', () => {
+      const env = createTestProcessEnv({
+        ANVIL_IS_BINARY: 'true',
+        ANVIL_CLI_VERSION: '1.0.0',
+      })
+      expect(env.ANVIL_IS_BINARY).toBe('true')
+      expect(env.ANVIL_CLI_VERSION).toBe('1.0.0')
+    })
+
+    test('allows setting terminal-specific vars', () => {
+      const env = createTestProcessEnv({
+        TERM_PROGRAM: 'iTerm.app',
+        KITTY_WINDOW_ID: '12345',
+        SIXEL_SUPPORT: 'true',
+      })
+      expect(env.TERM_PROGRAM).toBe('iTerm.app')
+      expect(env.KITTY_WINDOW_ID).toBe('12345')
+      expect(env.SIXEL_SUPPORT).toBe('true')
+    })
+  })
+})

package/vendor/@anvil/common/src/__tests__/foreign-client-shipped-agents.test.ts

@@ -0,0 +1,234 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
+
+import { describe, expect, test } from 'bun:test'
+
+import { ANVIL_ROOT_AGENT_IDS } from '../constants/free-agents'
+import {
+  detectForeignAnvilClient,
+  ANVIL_CUSTOM_TOOL_NAMES,
+} from '../constants/foreign-client-signals'
+
+/**
+ * Nothing we ship may be mistaken for a third-party client.
+ *
+ * The downgrade now runs unconditionally with no flag to disable it, so a
+ * anvil agent the detector flags is served a different model in production
+ * with no way to switch it off short of a revert and redeploy. This has already
+ * happened twice, both silently:
+ *
+ *  - `researcher-web` offers `['web_search', 'read_url']` and was flagged on
+ *    100% of its 334,042 requests from 4,821 users over 30 days.
+ *  - `anvil-desktop-autorun` offers only the custom tool `decide`, so it had
+ *    no signature tool at all — 2,904 requests from 41 users.
+ *
+ * Both were found by querying production, which is the wrong place to find
+ * them. This scans the source instead, so the next one fails CI.
+ *
+ * Reading source with a regex is crude, and the real hazard is that it quietly
+ * stops matching and the test passes on an empty set — hence the floor below
+ * and the named spot checks.
+ */
+
+const REPO_ROOT = join(import.meta.dir, '..', '..', '..')
+
+/** Where agent definitions live. */
+const SEARCH_ROOTS = [
+  'agents',
+  '.agents',
+  'anvil',
+  'anvil-desktop/src',
+  'web/src',
+  'common/src',
+  'sdk/src',
+  'cli/src',
+]
+
+/**
+ * Definitions that cannot reach the downgrade, with the property that makes
+ * that true. `mustContain` is the load-bearing part: if the reason stops
+ * holding, this fails rather than the exclusion silently outliving it.
+ */
+const EXCLUDED: Array<{ path: string; mustContain: string; why: string }> = [
+  {
+    path: 'anvil/e2e/agent/anvil-tester.ts',
+    mustContain: "model: 'anthropic/claude-sonnet-4.5'",
+    why:
+      'e2e harness pinned to a paid Anthropic model. The downgrade only runs ' +
+      'on free-mode requests, and a free-mode request for a non-free model is ' +
+      'rejected by isFreeModeAllowedAgentModel long before the detector. It ' +
+      'also had 0 production requests over 30 days. If it ever moves to a ' +
+      'free model this exclusion stops applying and the test says so.',
+  },
+]
+
+/**
+ * The regex only sees literal names. A declaration built at runtime is invisible
+ * to it, which is precisely how `decide` slipped through — so custom tools are
+ * asserted separately below rather than assumed covered here.
+ */
+const TOOL_NAMES_DECLARATION = /toolNames:\s*\[([^\]]*)\]/g
+const QUOTED_NAME = /'([^']+)'|"([^"]+)"/g
+
+/** Below this, assume the scan broke rather than that we deleted 20 agents. */
+const MINIMUM_DECLARATIONS = 25
+
+type Declaration = { file: string; names: string[]; ids: string[] }
+
+function collectSourceFiles(): string[] {
+  const files: string[] = []
+  const walk = (dir: string) => {
+    let entries: string[]
+    try {
+      entries = readdirSync(dir)
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (entry === 'node_modules' || entry === '.next' || entry === 'dist') {
+        continue
+      }
+      const path = join(dir, entry)
+      if (statSync(path).isDirectory()) {
+        walk(path)
+        continue
+      }
+      // Test files carry deliberately-foreign fixtures; they are not shipped.
+      if (
+        path.endsWith('.ts') &&
+        !path.includes('__tests__') &&
+        !path.endsWith('.test.ts')
+      ) {
+        files.push(path)
+      }
+    }
+  }
+  for (const root of SEARCH_ROOTS) walk(join(REPO_ROOT, root))
+  return files
+}
+
+function collectDeclarations(): Declaration[] {
+  const excluded = new Set(EXCLUDED.map((entry) => entry.path))
+  const declarations: Declaration[] = []
+  for (const file of collectSourceFiles()) {
+    const relativePath = relative(REPO_ROOT, file)
+    if (excluded.has(relativePath)) continue
+    const source = readFileSync(file, 'utf8')
+    const ids = [...source.matchAll(/\bid:\s*'([^']+)'/g)].map((m) => m[1]!)
+    for (const match of source.matchAll(TOOL_NAMES_DECLARATION)) {
+      const names = [...match[1]!.matchAll(QUOTED_NAME)].map(
+        (name) => name[1] ?? name[2]!,
+      )
+      // Empty declarations are kept, not filtered. `toolNames: []` on a ROOT is
+      // precisely what the root test below must catch, and dropping it here
+      // made that test vacuous — a root with an empty toolset simply vanished
+      // from the scan and the assertion passed over nothing.
+      declarations.push({ file: relativePath, names, ids })
+    }
+  }
+  return declarations
+}
+
+const DECLARATIONS = collectDeclarations()
+
+function asToolSchemas(names: string[]) {
+  return names.map((name) => ({ type: 'function', function: { name } }))
+}
+
+describe('no shipped anvil agent is flagged as a foreign client', () => {
+  test('the scan actually found our agents', () => {
+    // Guards the failure mode where a reformat stops the regex matching and
+    // every assertion below passes over an empty set.
+    expect(DECLARATIONS.length).toBeGreaterThanOrEqual(MINIMUM_DECLARATIONS)
+  })
+
+  test.each(DECLARATIONS.map((d): [string, Declaration] => [d.file, d]))(
+    '%s',
+    (_file, declaration) => {
+      const verdict = detectForeignAnvilClient({
+        tools: asToolSchemas(declaration.names),
+      })
+      // Surface the toolset in the failure, since the fix is almost always
+      // "this agent's tools are all generic — give it a distinctive one, or
+      // add the missing name back to the signature".
+      expect({
+        file: declaration.file,
+        names: declaration.names,
+        signal: verdict.signal,
+      }).toEqual({
+        file: declaration.file,
+        names: declaration.names,
+        signal: null,
+      })
+    },
+  )
+
+  test.each([
+    ['researcher-web', 'agents/researcher/researcher-web.ts'],
+    ['desktop autorun', 'anvil-desktop/src/server/services/autorun.ts'],
+    ['glob-matcher', 'agents/file-explorer/glob-matcher.ts'],
+  ])('still covers %s, which the scan must not silently drop', (_name, path) => {
+    // The first two are the agents this test exists because of. The third has
+    // exactly one signature tool (`glob` is generic, `set_output` is not), so
+    // it is the closest thing we ship to the failure mode.
+    expect(DECLARATIONS.some((d) => d.file === path)).toBe(true)
+  })
+
+  test('every root agent we ship declares tools', () => {
+    // `root_agent_no_tools` downgrades any ROOT agent request that offers no
+    // tools, on the grounds that our roots are agentic by definition. A root
+    // shipped with an empty toolset would therefore have every one of its
+    // requests downgraded in production, with no flag to turn it off.
+    const roots = new Set<string>(ANVIL_ROOT_AGENT_IDS)
+    const shippedRoots = DECLARATIONS.filter((d) =>
+      d.ids.some((id) => roots.has(id)),
+    )
+    // The scan must actually be finding roots, or this passes vacuously.
+    expect(shippedRoots.length).toBeGreaterThan(0)
+    // Name the offending file in the failure, since "a root declares no tools"
+    // is useless without knowing which one.
+    expect(
+      shippedRoots
+        .filter((d) => d.names.length === 0)
+        .map((d) => `${d.file} (${d.ids.join(', ')})`),
+    ).toEqual([])
+  })
+
+  test.each([...ANVIL_CUSTOM_TOOL_NAMES])(
+    'custom tool %s clears on its own',
+    (name) => {
+      // Custom tools are registered at runtime through customToolDefinitions,
+      // so the source scan cannot see them. An agent offering one and nothing
+      // else — which is exactly what desktop autorun does — has no signature
+      // tool unless it is enumerated.
+      expect(
+        detectForeignAnvilClient({ tools: asToolSchemas([name]) }).signal,
+      ).toBeNull()
+    },
+  )
+
+  test('custom tools appended to a real toolset stay cleared', () => {
+    // How the chat surface composes: base-chat's tools plus per-turn image and
+    // document tools (anvil/web/src/server/chat/agent.ts). The additions are
+    // caller-named and arbitrary, so this must not depend on recognising them.
+    expect(
+      detectForeignAnvilClient({
+        tools: asToolSchemas([
+          'spawn_agents',
+          'gravity_index',
+          'render_ui',
+          'suggest_followups',
+          'read_attached_image_abc123',
+          'read_attached_doc_def456',
+        ]),
+      }).signal,
+    ).toBeNull()
+  })
+
+  test.each(EXCLUDED)('exclusion of $path still holds', (entry) => {
+    // An exclusion outliving its reason is how a real false positive gets
+    // waved through, so the reason is asserted rather than just written down.
+    const source = readFileSync(join(REPO_ROOT, entry.path), 'utf8')
+    expect(source).toContain(entry.mustContain)
+  })
+})