@jigging/agent-acp 0.0.0 → 0.1.0-alpha.3

package/test/pack.test.ts

@@ -0,0 +1,76 @@
+import { expect, test } from 'bun:test'
+import { execFileSync } from 'node:child_process'
+import { mkdir, mkdtemp, readdir, readFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+test('ordinary packing retains editable source, registry dependencies and a standalone runtime', async () => {
+  const root = fileURLToPath(new URL('../', import.meta.url))
+  const temporary = await mkdtemp(join(tmpdir(), 'agent-acp-pack-test-'))
+  const originalManifest = await readFile(join(root, 'package.json'), 'utf8')
+  try {
+    const first = join(temporary, 'first')
+    const extracted = join(temporary, 'extracted')
+    const repacked = join(temporary, 'repacked')
+    await mkdir(extracted)
+    await mkdir(first)
+    await mkdir(repacked)
+    const pack = (cwd: string, destination: string) =>
+      execFileSync(
+        process.execPath,
+        ['pm', 'pack', '--ignore-scripts', '--destination', destination],
+        {
+          cwd,
+          stdio: 'pipe',
+        },
+      )
+    pack(root, first)
+    const archives = (await readdir(first)).filter((name) => name.endsWith('.tgz'))
+    expect(archives).toHaveLength(1)
+    const archive = join(first, archives[0]!)
+    const entries = execFileSync('tar', ['-tzf', archive], { encoding: 'utf8' }).trim().split('\n')
+    expect(entries).toContain('package/src/flow.ts')
+    expect(entries).toContain('package/FLOW.contract.json')
+    expect(entries.some((name) => name.includes('/tooling/') || name.endsWith('.tgz'))).toBe(false)
+    expect(entries.some((name) => name.includes('/node_modules/'))).toBe(false)
+    execFileSync('tar', ['-xzf', archive, '--strip-components=1', '-C', extracted])
+    const manifest = JSON.parse(await readFile(join(extracted, 'package.json'), 'utf8'))
+    for (const name of ['@jigging/flow', '@jigging/agent-method']) {
+      const version = manifest.devDependencies[name]
+      expect(version).toMatch(/^\d+\.\d+\.\d+/)
+      expect(version).not.toMatch(/workspace:|file:/)
+    }
+    expect(Object.keys(manifest.dependencies ?? {})).toHaveLength(0)
+    // Public built exports and the complete Flow bundle work without development dependencies.
+    execFileSync(
+      process.execPath,
+      [
+        '-e',
+        `await import('./dist/flow.js');
+        const transport = await import('@jigging/agent-acp/transport');
+        new transport.FiniteAcpFrames('requests').finish();
+        const ready = transport.readFiniteAcpReady({ kind: 'ready', protocolVersion: 1, cwd: '/work', configuration: [], maxTurns: 1, restoreSessionId: 'owned-session' });
+        if (ready.restoreSessionId !== 'owned-session') throw new Error('missing owned restore identity')`,
+      ],
+      { cwd: extracted, stdio: 'pipe' },
+    )
+    pack(extracted, repacked)
+    const next = (await readdir(repacked)).filter((name) => name.endsWith('.tgz'))
+    expect(next).toHaveLength(1)
+    const nextManifest = JSON.parse(
+      execFileSync('tar', ['-xOf', join(repacked, next[0]!), 'package/package.json'], {
+        encoding: 'utf8',
+      }),
+    )
+    expect(nextManifest.devDependencies).toEqual(manifest.devDependencies)
+    expect(
+      execFileSync('tar', ['-xOf', join(repacked, next[0]!), 'package/src/flow.ts'], {
+        encoding: 'utf8',
+      }),
+    ).toBe(await readFile(join(extracted, 'src/flow.ts'), 'utf8'))
+    expect(await readFile(join(root, 'package.json'), 'utf8')).toBe(originalManifest)
+  } finally {
+    await rm(temporary, { recursive: true, force: true })
+  }
+}, 30_000)

package/test/transport.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  FINITE_ACP_LIMITS,
+  FiniteAcpFrames,
+  fragmentFiniteAcpFrame,
+  readFiniteAcpReady,
+} from '../src/transport.js'
+
+describe('finite ACP framing', () => {
+  test('round-trips large text and supplementary scalars without exceeding channel items', () => {
+    const text = JSON.stringify({ text: '\u0001\\"😀é'.repeat(90_000) })
+    const fragments = [...fragmentFiniteAcpFrame(text)]
+    expect(fragments.length).toBeGreaterThan(1)
+    const frames = new FiniteAcpFrames('requests')
+    const results: string[] = []
+    for (const fragment of fragments) {
+      expect(Buffer.byteLength(fragment.text)).toBeLessThanOrEqual(8_192)
+      expect(Buffer.byteLength(JSON.stringify(fragment))).toBeLessThanOrEqual(65_536)
+      expect(fragment.text.isWellFormed()).toBe(true)
+      const result = frames.accept(fragment)
+      if (result !== undefined) results.push(result)
+    }
+    frames.finish()
+    expect(results).toEqual([text])
+    expect(() => frames.accept(fragments[0])).toThrow('not open')
+  })
+
+  test('rejects invalid fragments and stays poisoned after the caller catches failure', () => {
+    for (const value of [
+      null,
+      [],
+      {},
+      { kind: 'data', text: '', end: true },
+      { kind: 'data', text: 'x', end: 0 },
+      { kind: 'data', text: 'x', end: true, id: 'replay' },
+      { kind: 'data', text: '\ud800', end: true },
+      { kind: 'data', text: 'x'.repeat(8_193), end: true },
+    ]) {
+      const frames = new FiniteAcpFrames('responses')
+      expect(() => frames.accept(value)).toThrow()
+      expect(() => frames.accept({ kind: 'data', text: '{}', end: true })).toThrow('not open')
+      expect(() => frames.finish()).toThrow('not open')
+    }
+  })
+
+  test('EOF inside a frame fails; a complete empty stream does not assert protocol settlement', () => {
+    const partial = new FiniteAcpFrames('requests')
+    partial.accept({ kind: 'data', text: '{', end: false })
+    expect(() => partial.finish()).toThrow('inside a frame')
+    new FiniteAcpFrames('requests').finish()
+    expect(() => [...fragmentFiniteAcpFrame('')]).toThrow()
+    expect(() => [...fragmentFiniteAcpFrame('\udc00')]).toThrow()
+  })
+
+  test('bounds aggregate request bytes even when complete frames are individually valid', () => {
+    const reader = new FiniteAcpFrames('requests')
+    for (let count = 0; count < FINITE_ACP_LIMITS.requestBytes / 8_192; count++)
+      reader.accept({ kind: 'data', text: 'x'.repeat(8_192), end: false })
+    expect(() => reader.accept({ kind: 'data', text: 'x', end: true })).toThrow('bounds')
+  })
+
+  test('bounds complete request count and one response frame', () => {
+    const requests = new FiniteAcpFrames('requests')
+    for (let count = 0; count < FINITE_ACP_LIMITS.requestFrames; count++)
+      requests.accept({ kind: 'data', text: '{}', end: true })
+    expect(() => requests.accept({ kind: 'data', text: '{}', end: true })).toThrow(
+      'too many frames',
+    )
+    const responses = new FiniteAcpFrames('responses')
+    for (let count = 0; count < FINITE_ACP_LIMITS.frameBytes / 8_192; count++)
+      responses.accept({ kind: 'data', text: 'x'.repeat(8_192), end: false })
+    expect(() => responses.accept({ kind: 'data', text: 'x', end: true })).toThrow('bounds')
+  })
+})
+
+describe('reviewed ready record', () => {
+  test('snapshots configuration without allowing later model replacement', () => {
+    const input = {
+      kind: 'ready',
+      protocolVersion: 1,
+      cwd: '/work',
+      maxTurns: 1,
+      configuration: [{ configId: 'model', value: 'reviewed' }],
+      modeId: 'read-only',
+    }
+    const ready = readFiniteAcpReady(input)
+    input.configuration[0]!.value = 'other'
+    expect(ready.configuration[0]!.value).toBe('reviewed')
+    expect(Object.isFrozen(ready.configuration)).toBe(true)
+    expect(Object.isFrozen(ready.configuration[0])).toBe(true)
+    expect(
+      readFiniteAcpReady({ ...input, restoreSessionId: 'owned-session' }).restoreSessionId,
+    ).toBe('owned-session')
+    expect(
+      readFiniteAcpReady({
+        ...input,
+        configuration: [{ configId: 'compaction', type: 'boolean', value: false }],
+      }).configuration,
+    ).toEqual([{ configId: 'compaction', type: 'boolean', value: false }])
+  })
+
+  test('rejects extra authority, malformed or duplicate configuration, and accessors', () => {
+    const base = { kind: 'ready', protocolVersion: 1, cwd: '/work', maxTurns: 1, configuration: [] }
+    for (const value of [
+      { ...base, cwd: '/' },
+      { ...base, protocolVersion: 2 },
+      { ...base, token: 'secret' },
+      { ...base, modeId: null },
+      ...[null, '', 'x\0y', 'x'.repeat(1_025)].map((restoreSessionId) => ({
+        ...base,
+        restoreSessionId,
+      })),
+      { ...base, configuration: [{ configId: 'model', value: 'x', type: 'string' }] },
+      {
+        ...base,
+        configuration: [
+          { configId: 'x', value: '1' },
+          { configId: 'x', value: '2' },
+        ],
+      },
+      { ...base, configuration: new Array(17).fill({ configId: 'x', value: 'y' }) },
+    ])
+      expect(() => readFiniteAcpReady(value)).toThrow()
+    let invoked = false
+    const accessor = {
+      ...base,
+      get modeId() {
+        invoked = true
+        return 'bad'
+      },
+    }
+    expect(() => readFiniteAcpReady(accessor)).toThrow('data properties')
+    expect(invoked).toBe(false)
+  })
+})

package/test/updates.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, spyOn, test } from 'bun:test'
+import type { ChannelCloseOptions, ChannelSender, JsonValue } from '@jigging/flow'
+import { OptionalUpdates } from '../src/updates.js'
+
+describe('optional ordinary presentation relay', () => {
+  test('healthy delivery preserves order and closes cleanly', async () => {
+    const sent: JsonValue[] = []
+    const ends: (ChannelCloseOptions | undefined)[] = []
+    const sender: ChannelSender = {
+      direction: 'send',
+      delivery: 'direct',
+      async send(value) {
+        sent.push(value)
+      },
+      async close(options) {
+        ends.push(options)
+      },
+    }
+    const updates = new OptionalUpdates(sender, new AbortController().signal)
+    updates.offer({ text: 'first' })
+    updates.offer({ text: 'second' })
+    await updates.finish()
+    expect(sent).toEqual([{ text: 'first' }, { text: 'second' }])
+    expect(ends).toEqual([undefined])
+  })
+
+  test('overflow aborts the blocked send, drops the suffix and declares LAGGED', async () => {
+    const diagnostic = spyOn(console, 'error').mockImplementation(() => {})
+    const ends: (ChannelCloseOptions | undefined)[] = []
+    let sends = 0
+    let aborted = false
+    const sender: ChannelSender = {
+      direction: 'send',
+      delivery: 'direct',
+      async send(_value, options) {
+        sends++
+        await new Promise<void>((_resolve, reject) =>
+          options!.signal!.addEventListener(
+            'abort',
+            () => {
+              aborted = true
+              reject(new Error('aborted'))
+            },
+            { once: true },
+          ),
+        )
+      },
+      async close(options) {
+        ends.push(options)
+      },
+    }
+    try {
+      const updates = new OptionalUpdates(sender, new AbortController().signal)
+      for (let index = 0; index < 20; index++) updates.offer({ index })
+      await updates.finish()
+      updates.offer({ later: 'must never resume' })
+      expect(aborted).toBe(true)
+      expect(sends).toBe(1)
+      expect(ends).toEqual([{ error: 'LAGGED' }])
+      expect(diagnostic).toHaveBeenCalledTimes(1)
+    } finally {
+      diagnostic.mockRestore()
+    }
+  })
+
+  test('a blocked send has a finite wait without cancelling the Agent', async () => {
+    const diagnostic = spyOn(console, 'error').mockImplementation(() => {})
+    const owner = new AbortController()
+    let end: ChannelCloseOptions | undefined
+    const sender: ChannelSender = {
+      direction: 'send',
+      delivery: 'direct',
+      async send(_value, options) {
+        await new Promise<void>((_resolve, reject) =>
+          options!.signal!.addEventListener('abort', () => reject(new Error('blocked')), {
+            once: true,
+          }),
+        )
+      },
+      async close(options) {
+        end = options
+      },
+    }
+    try {
+      const updates = new OptionalUpdates(sender, owner.signal)
+      updates.offer({ text: 'bounded wait' })
+      await updates.finish()
+      expect(end).toEqual({ error: 'LAGGED' })
+      expect(owner.signal.aborted).toBe(false)
+    } finally {
+      diagnostic.mockRestore()
+    }
+  })
+})

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["node"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "test"]
+}