chore(repo): migrate biome config and disable cognitive-complexity rule (#195)

* chore(repo): migrate biome config and disable cognitive-complexity rule

Migrate biome.json to the 2.5.3 schema and the new `preset` field, and
turn off noExcessiveCognitiveComplexity. The rule produced 55
non-blocking warnings, mostly on legitimately branchy CLI command
handlers; disabling it clears the noise (biome check is now clean).

Assisted-by: Opus 4.8 via Claude Code

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(cli): sweep the run's buckets on teardown and raise hook timeout

The CLI integration suite's beforeAll timed out (30s) sweeping stale
tigris-cli-test-* buckets left by prior failed runs — a self-worsening
loop. Add a prefix-scoped catch-all in the top-level afterAll so every
run deletes all the buckets it created (all names use testPrefix), and
raise hookTimeout to 120s so a slow setup doesn't fail the suite.

Assisted-by: Opus 4.8 via Claude Code

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(repo): make integration suites clean up their resources reliably

- agent-kit: capture the fork/workspace cleanup handle before asserting,
  and track the base bucket before creating it, so a failed assertion no
  longer orphans fork buckets or their IAM access keys. Guard afterEach
  so one failed removal can't strand the rest.
- storage fork/merge/rebase: push buckets to cleanup before createBucket
  so a create/assert failure still deletes them.
- storage integration softDelete: guard each removeBucket so force-
  removing an already-soft-deleted bucket can't strand the others.

Deliberately did not add a shared test-* bucket sweep: storage runs test
files in parallel, so a per-file sweep would delete other files'
in-flight buckets.

Assisted-by: Opus 4.8 via Claude Code

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: designcode

biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.5.0/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.3/schema.json",
   "vcs": {
     "enabled": true,
     "clientKind": "git",
@@ -30,10 +30,10 @@
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true,
+      "preset": "recommended",
       "complexity": {
         "noBannedTypes": "error",
-        "noExcessiveCognitiveComplexity": "warn"
+        "noExcessiveCognitiveComplexity": "off"
       },
       "correctness": {
         "noUnusedImports": "error",

packages/agent-kit/test/integration.test.ts

@@ -190,23 +190,32 @@ describe.skipIf(skipTests)('createForks / teardownForks', () => {
 
   afterEach(async () => {
     if (forkSet) {
-      await teardownForks(forkSet);
+      try {
+        await teardownForks(forkSet);
+      } catch {
+        // best-effort — don't let a cleanup failure mask the test result
+      }
       forkSet = undefined;
     }
     for (const bucket of extraBucketsToCleanup) {
-      await removeBucket(bucket, { force: true });
+      try {
+        await removeBucket(bucket, { force: true });
+      } catch {
+        // best-effort
+      }
     }
     extraBucketsToCleanup.length = 0;
   });
 
   it('should create forks from a base bucket', async () => {
     // Create a base bucket with snapshots and data
     const baseBucket = uniqueName('forks-base');
+    // Track before creating so a mid-create failure still cleans it up.
+    extraBucketsToCleanup.push(baseBucket);
     const wsResult = await createWorkspace(baseBucket, {
       enableSnapshots: true,
     });
     expect(wsResult.error).toBeUndefined();
-    extraBucketsToCleanup.push(baseBucket);
 
     await put('dataset.json', '{"items": [1,2,3]}', {
       config: { bucket: baseBucket },
@@ -216,14 +225,17 @@ describe.skipIf(skipTests)('createForks / teardownForks', () => {
     const result = await createForks(baseBucket, 2, {
       prefix: uniqueName('fork'),
     });
+    // Capture the handle before asserting so teardown revokes keys and deletes
+    // fork buckets even if an assertion below throws.
+    forkSet = result.data;
 
     expect(result.error).toBeUndefined();
     expect(result.data!.forks).toHaveLength(2);
     expect(result.data!.snapshotId).toBeTruthy();
-    forkSet = result.data!;
+    const forks = result.data!;
 
     // Verify each fork has the data from the base bucket
-    for (const fork of forkSet.forks) {
+    for (const fork of forks.forks) {
       const getResult = await get('dataset.json', 'string', {
         config: { bucket: fork.bucket },
       });
@@ -233,40 +245,44 @@ describe.skipIf(skipTests)('createForks / teardownForks', () => {
 
     // Verify forks are isolated — write to fork 0, fork 1 unchanged
     await put('fork-0-only.txt', 'only in fork 0', {
-      config: { bucket: forkSet.forks[0].bucket },
+      config: { bucket: forks.forks[0].bucket },
     });
 
     const fork1Check = await get('fork-0-only.txt', 'string', {
-      config: { bucket: forkSet.forks[1].bucket },
+      config: { bucket: forks.forks[1].bucket },
     });
     expect(fork1Check.error).toBeDefined();
   });
 
   it('should create forks with scoped credentials', async () => {
     const baseBucket = uniqueName('forks-creds');
+    // Track before creating so a mid-create failure still cleans it up.
+    extraBucketsToCleanup.push(baseBucket);
     const wsResult = await createWorkspace(baseBucket, {
       enableSnapshots: true,
     });
     expect(wsResult.error).toBeUndefined();
-    extraBucketsToCleanup.push(baseBucket);
 
     const result = await createForks(baseBucket, 2, {
       prefix: uniqueName('fork-cred'),
       credentials: { role: 'Editor' },
     });
+    // Capture the handle before asserting so teardown revokes the forks'
+    // access keys even if an assertion below throws.
+    forkSet = result.data;
 
     expect(result.error).toBeUndefined();
-    forkSet = result.data!;
+    const forks = result.data!;
 
     // Each fork should have its own credentials
-    for (const fork of forkSet.forks) {
+    for (const fork of forks.forks) {
       expect(fork.credentials).toBeDefined();
       expect(fork.credentials!.accessKeyId).toBeTruthy();
       expect(fork.credentials!.secretAccessKey).toBeTruthy();
     }
 
     // Verify scoped credentials can write to their own fork
-    const fork = forkSet.forks[0];
+    const fork = forks.forks[0];
     const putResult = await put('scoped-write.txt', 'written with scoped key', {
       config: {
         bucket: fork.bucket,
@@ -279,16 +295,20 @@ describe.skipIf(skipTests)('createForks / teardownForks', () => {
 
   it('should teardown forks cleanly', async () => {
     const baseBucket = uniqueName('forks-td');
+    // Track before creating so a mid-create failure still cleans it up.
+    extraBucketsToCleanup.push(baseBucket);
     const wsResult = await createWorkspace(baseBucket, {
       enableSnapshots: true,
     });
     expect(wsResult.error).toBeUndefined();
-    extraBucketsToCleanup.push(baseBucket);
 
     const result = await createForks(baseBucket, 2, {
       prefix: uniqueName('fork-td'),
       credentials: { role: 'Editor' },
     });
+    // Capture the handle before asserting so teardown revokes keys / deletes
+    // fork buckets if an assertion below throws.
+    forkSet = result.data;
     expect(result.error).toBeUndefined();
     const created = result.data!;
 
@@ -297,15 +317,14 @@ describe.skipIf(skipTests)('createForks / teardownForks', () => {
     // Teardown
     const teardown = await teardownForks(created);
     expect(teardown.error).toBeUndefined();
+    // Torn down explicitly; prevent afterEach from double-tearing-down.
+    forkSet = undefined;
 
     // Verify forks are deleted
     for (const bucket of forkBuckets) {
       const info = await getBucketInfo(bucket);
       expect(info.error).toBeDefined();
     }
-
-    // Forks cleaned up, don't double-teardown in afterEach
-    forkSet = undefined;
   });
 });
 

packages/cli/test/cli.test.ts

@@ -377,6 +377,28 @@ describe.skipIf(skipTests)('CLI Integration Tests', () => {
     console.log(`Cleaning up second test bucket: ${otherBucket}`);
     runCli(`rm ${t3(otherBucket)}/* -f`);
     runCli(`rm ${t3(otherBucket)} -f`);
+
+    // Catch-all: delete every bucket this run created. All test bucket names
+    // are prefixed with testPrefix, so this guarantees the suite cleans up
+    // after itself even if a nested block's teardown was skipped by a failure.
+    // Keeping leftovers to a minimum keeps the beforeAll stale-bucket sweep
+    // fast (a growing sweep is what caused the setup hook to time out).
+    const listResult = runCli('buckets list --format json');
+    if (listResult.exitCode === 0 && listResult.stdout.trim()) {
+      try {
+        const parsed = JSON.parse(listResult.stdout.trim()) as {
+          items: Array<{ name: string }>;
+        };
+        for (const bucket of parsed.items) {
+          if (!bucket.name.startsWith(testPrefix)) continue;
+          console.log(`Cleaning up leftover test bucket: ${bucket.name}`);
+          runCli(`rm ${t3(bucket.name)}/* -r -f`);
+          runCli(`rm ${t3(bucket.name)} -f`);
+        }
+      } catch {
+        // Best-effort — don't fail teardown on cleanup errors.
+      }
+    }
   });
 
   describe('ls command', () => {

packages/cli/vitest.config.ts

@@ -24,7 +24,11 @@ export default defineConfig({
       NODE_ENV: 'test',
     },
     testTimeout: 30000,
-    hookTimeout: 30000,
+    // Integration setup/teardown hooks do live-gateway work (bucket
+    // create/delete, plus a best-effort sweep of stale buckets), which can
+    // exceed 30s under load. Give hooks more headroom so a slow setup doesn't
+    // fail the whole suite.
+    hookTimeout: 120000,
     coverage: {
       provider: 'v8',
       reporter: ['text', 'json', 'html'],

packages/storage/src/test/fork-merge-rebase.integration.test.ts

@@ -28,6 +28,8 @@ describe.skipIf(skipTests)('mergeFork integration', () => {
   const bucketsToCleanup: string[] = [];
 
   beforeAll(async () => {
+    // Track before creating so a create/assert failure still cleans up.
+    bucketsToCleanup.push(sourceBucket);
     const src = await createBucket(sourceBucket, {
       enableSnapshot: true,
       config,
@@ -36,14 +38,14 @@ describe.skipIf(skipTests)('mergeFork integration', () => {
       src.error,
       `source bucket create failed: ${src.error?.message}`
     ).toBeUndefined();
-    bucketsToCleanup.push(sourceBucket);
 
     // Seed the source with an object that exists before either fork is made.
     const seed = await put('base.txt', 'base', {
       config: bucketConfig(sourceBucket),
     });
     expect(seed.error).toBeUndefined();
 
+    bucketsToCleanup.push(forkBucket);
     const fork = await createBucket(forkBucket, {
       sourceBucketName: sourceBucket,
       config,
@@ -52,7 +54,6 @@ describe.skipIf(skipTests)('mergeFork integration', () => {
       fork.error,
       `fork create failed: ${fork.error?.message}`
     ).toBeUndefined();
-    bucketsToCleanup.push(forkBucket);
 
     await waitForConsistency();
   }, 60_000);
@@ -126,24 +127,25 @@ describe.skipIf(skipTests)('rebaseFork integration', () => {
   const bucketsToCleanup: string[] = [];
 
   beforeAll(async () => {
+    // Track before creating so a create/assert failure still cleans up.
+    bucketsToCleanup.push(sourceBucket);
     const src = await createBucket(sourceBucket, {
       enableSnapshot: true,
       config,
     });
     expect(src.error).toBeUndefined();
-    bucketsToCleanup.push(sourceBucket);
 
     const seed = await put('base.txt', 'base', {
       config: bucketConfig(sourceBucket),
     });
     expect(seed.error).toBeUndefined();
 
+    bucketsToCleanup.push(forkBucket);
     const fork = await createBucket(forkBucket, {
       sourceBucketName: sourceBucket,
       config,
     });
     expect(fork.error).toBeUndefined();
-    bucketsToCleanup.push(forkBucket);
 
     await waitForConsistency();
   }, 60_000);

packages/storage/src/test/integration.test.ts

@@ -928,8 +928,14 @@ describe.skipIf(skipTests)('Tigris Storage Integration Tests', () => {
     });
 
     afterAll(async () => {
+      // Per-item guard: force-removing an already-soft-deleted bucket can
+      // error, and one failure must not strand the remaining buckets.
       for (const bucket of bucketsToCleanup) {
-        await removeBucket(bucket, { force: true, config });
+        try {
+          await removeBucket(bucket, { force: true, config });
+        } catch {
+          // best-effort cleanup
+        }
       }
     });