@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/server/server.test.ts

@@ -1,193 +0,0 @@
-import { mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { memorySecretStore } from '../accounts/secrets'
-import { createHarness, type Harness } from '../harness'
-import type { PiSessionLike } from '../sessions/runner'
-import { rootWithProject, writeFile } from '../../tests/helpers'
-import { remoteDirectory, remotePolicy, remoteSecrets, remoteTools } from './remote'
-import { RpcPeer, type Transport } from './rpc'
-import { attach, serve } from './serve'
-
-const open: Harness[] = []
-afterEach(async () => {
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-/** A host on the other end of the protocol: sends requests, answers the harness's calls. */
-function host(hostCalls: Record<string, (params: any) => unknown> = {}) {
-  let toHarness: (line: string) => void = () => undefined
-  const events: any[] = []
-  const notices: any[] = []
-  const waiting = new Map<string, { resolve: (value: any) => void; reject: (error: any) => void }>()
-  let next = 0
-  const transport: Transport = {
-    onLine: (listener) => void (toHarness = listener),
-    write: (line) => {
-      const message = JSON.parse(line)
-      if (message.event) events.push(message.event)
-      else if (message.notice) notices.push(message.notice)
-      else if (message.call) {
-        queueMicrotask(async () => {
-          try {
-            const handler = hostCalls[message.call]
-            if (!handler) throw new Error(`host has no ${message.call}`)
-            toHarness(JSON.stringify({ v: 1, id: message.id, result: (await handler(message.params)) ?? null }))
-          } catch (error) {
-            toHarness(JSON.stringify({ v: 1, id: message.id, error: { code: 'host_error', message: error instanceof Error ? error.message : String(error) } }))
-          }
-        })
-      } else {
-        const pending = waiting.get(message.id)
-        waiting.delete(message.id)
-        if (message.error) pending?.reject(message.error)
-        else pending?.resolve(message.result)
-      }
-    }
-  }
-  const request = <T = any>(method: string, params: unknown = {}): Promise<T> =>
-    new Promise<T>((resolve, reject) => {
-      const id = `h${++next}`
-      waiting.set(id, { resolve, reject })
-      toHarness(JSON.stringify({ v: 1, id, method, params }))
-    })
-  return { transport, request, events, notices }
-}
-
-const idle = (): PiSessionLike => ({ sessionId: 'native-1', subscribe: () => () => undefined, prompt: async () => undefined, sendCustomMessage: async () => undefined, abort: async () => undefined, dispose: () => undefined })
-
-describe('the harness served to a host', () => {
-  it('starts native subagents over RPC using the live parent launch', async () => {
-    const { transport, request } = host()
-    const harness = createHarness({
-      dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(),
-      sessionFactory: async ({ params }) => ({ ...idle(), ...(params.runId === 'rpc-parent' ? { prompt: async () => new Promise<void>(() => undefined) } : {}) })
-    })
-    open.push(harness)
-    serve(harness, transport)
-    harness.accounts.create('Main', 'apiKey')
-    await request('sessions.run', { run: { id: 'rpc-parent', sessionId: 'opaque-session' }, cwd: harness.env.root, sessionDir: join(harness.env.root, 'sessions'), text: 'Parent', caller: { agentId: 'caller' }, tools: { allow: ['read'] }, subagents: {} })
-    const child = await request('subagents.spawn', { parentRunId: 'rpc-parent', brief: 'Review', tools: ['read'] })
-    expect(await request('subagents.wait', { parentRunId: 'rpc-parent', runIds: [child.runId] })).toMatchObject([{ runId: child.runId, status: 'completed' }])
-    const { loadRun } = await import('../sessions/runStore')
-    expect(loadRun(harness.env.root, child.runId)).toMatchObject({ parentRunId: 'rpc-parent', relation: 'subagent', agentId: 'caller', status: 'completed' })
-    await request('runs.interrupt', { runId: 'rpc-parent' })
-  })
-
-  it('answers by method name, reports failures with their code, and forwards events and notices', async () => {
-    const { transport, request, events, notices } = host()
-    const harness = createHarness({ dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), sessionFactory: async () => idle() })
-    open.push(harness)
-    serve(harness, transport)
-
-    const status = await request('harness.status')
-    expect(status).toMatchObject({ dataRoot: harness.env.root, productName: 'Xingular Harness', activeRuns: [] })
-    expect(await request<string[]>('harness.methods')).toEqual(expect.arrayContaining(['accounts.list', 'sessions.run', 'sessions.spawnSubagent', 'subagents.spawn', 'subagents.wait', 'subagents.results', 'wiki.pages', 'terminal.prepare', 'skills.list', 'skills.import', 'connections.list', 'harness.shutdown']))
-
-    await expect(request('sessions.spawnSubagent', { parentRunId: 'missing', brief: 'Review' })).rejects.toMatchObject({ code: 'run_not_active' })
-
-    const overview = await request('accounts.create', { label: 'Main', authKind: 'apiKey' })
-    expect(overview.accounts).toHaveLength(1)
-    expect(notices).toContainEqual(expect.objectContaining({ type: 'accounts.changed' }))
-    await expect(request('accounts.rename', { accountId: 'nope', label: 'x' })).rejects.toMatchObject({ code: 'not_found' })
-    await expect(request('accounts.rename', {})).rejects.toMatchObject({ code: 'invalid_request', message: 'accountId is required.' })
-    await expect(request('nope.nothing')).rejects.toMatchObject({ code: 'unknown_method' })
-
-    expect((await request<any[]>('wiki.namespaces')).map((entry) => entry.namespace)).toEqual(expect.arrayContaining(['/projects/app']))
-    const blocks = await request<any[]>('blocks.list', { agentIds: ['a1'] })
-    expect(blocks.map((block) => block.label)).toEqual(expect.arrayContaining(['user', 'persona', 'notes']))
-    expect(await request('memory.call', { context: { agentId: 'a1', agentName: 'Helper', actor: 'Chat' }, call: 'memory.append', params: { block: 'notes', text: 'Ship on Fridays.' } })).toContain('notes')
-    expect(notices).toContainEqual({ type: 'wiki.changed' })
-    const compiled = await request('context.compile', { context: { agentId: 'a1', agentName: 'Helper', actor: 'Chat' }, render: true })
-    expect(compiled.text).toContain('Ship on Fridays.')
-    expect(await request('context.profiles')).toEqual({ profiles: {}, stats: [] })
-
-    const started = await request('sessions.run', { run: { id: 'r1', sessionId: 'a1' }, cwd: harness.env.root, sessionDir: join(harness.env.root, 'sessions', 'a1'), text: 'hello', caller: { agentId: 'a1', agentName: 'Helper', actor: 'Chat' }, tools: { allow: ['read'] } })
-    expect(started).toEqual({ runId: 'r1', nativeSessionId: 'native-1' })
-    await new Promise((resolve) => setTimeout(resolve, 30))
-    expect(events.map((event) => event.type)).toEqual(['started', 'status.changed', 'context.snapshot', 'completed'])
-    expect((await request('runs.load', { runId: 'r1' })).run).toMatchObject({ id: 'r1', status: 'completed' })
-    expect((await request<any[]>('runs.list', { filter: { sessionId: 'a1' } })).map((run) => run.id)).toEqual(['r1'])
-    expect((await request('context.profiles')).stats).toMatchObject([{ subject: 'a1', mode: 'chat', contextProfile: 'full', runs: 1, completed: 1, runIds: ['r1'] }])
-  })
-
-  it('lets a host that is not a Node program supply secrets, policy, names, and tools over the protocol', async () => {
-    const secrets = new Map<string, string>()
-    const called: any[] = []
-    const { transport, request } = host({
-      'secrets.get': ({ key }) => secrets.get(key) ?? null,
-      'secrets.set': ({ key, value }) => void secrets.set(key, value),
-      'secrets.delete': ({ key }) => void secrets.delete(key),
-      'policy.scope': ({ tool }) => ({ allowed: tool !== 'bash', reason: 'No shell here.' }),
-      'policy.authorize': () => null,
-      'tools.call': (params) => {
-        called.push(params)
-        return { ok: true, echoed: params.input }
-      }
-    })
-    const peer = new RpcPeer(transport)
-    let gate: { check: (name: string, input: unknown) => Promise<string | null> } | null = null
-    let offered: { name: string; execute: (input: Record<string, unknown>) => Promise<unknown> }[] = []
-    const harness = createHarness({
-      dataRoot: rootWithProject(),
-      stateDir: mkdtempSync(join(tmpdir(), 'hs-')),
-      secrets: remoteSecrets(peer),
-      policy: remotePolicy(peer),
-      directory: remoteDirectory(peer),
-      sessionFactory: async (input) => {
-        gate = input.gate
-        offered = input.tools.filter((tool) => input.allow.includes(tool.name))
-        return idle()
-      }
-    })
-    open.push(harness)
-    harness.sessions.provide(remoteTools(peer))
-    attach(harness, peer)
-
-    const { accounts } = await request('accounts.create', { label: 'Main', authKind: 'apiKey' })
-    await request('accounts.setApiKey', { accountId: accounts[0].id, key: 'sk-test-0000000000000000', provider: 'anthropic' })
-    expect([...secrets.keys()]).toEqual([`${accounts[0].id}/pi-auth/anthropic`])
-
-    await request('directory.set', { agents: { a1: 'Scout' } })
-    expect(harness.env.directory.agentName('a1')).toBe('Scout')
-
-    expect(await request('tools.register', { tools: [{ name: 'lookup', description: 'Look something up', parameters: { type: 'object', properties: { q: { type: 'string' } } } }] })).toEqual({ registered: ['lookup'] })
-    await request('sessions.run', { run: { id: 'r1', sessionId: 'a1' }, cwd: harness.env.root, sessionDir: join(harness.env.root, 'sessions', 'a1'), text: 'hello', caller: { agentId: 'a1', actor: 'Chat' }, tools: { allow: ['lookup', 'bash'] } })
-    expect(offered.map((tool) => tool.name)).toContain('lookup')
-    expect(await offered.find((tool) => tool.name === 'lookup')!.execute({ q: 'x' })).toBe('{"ok":true,"echoed":{"q":"x"}}')
-    expect(called[0]).toMatchObject({ name: 'lookup', runId: 'r1', sessionId: 'a1', caller: { agentId: 'a1' } })
-    expect(await gate!.check('bash', {})).toBe('No shell here.')
-    expect(await gate!.check('lookup', {})).toBeNull()
-  })
-})
-
-describe('built-in skills', () => {
-  it('are on everywhere until switched off, and a person\'s own item of the same name replaces one', async () => {
-    const builtins = mkdtempSync(join(tmpdir(), 'builtin-'))
-    writeFile(join(builtins, 'skills', 'review', 'SKILL.md'), '---\nname: review\ndescription: Review a change before it ships\n---\nRead the diff first.\n')
-    writeFile(join(builtins, 'rules', 'plain.md'), '---\nname: Plain words\ndescription: Write plainly\n---\nUse plain words.\n')
-    const { transport, request } = host()
-    const harness = createHarness({ dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), builtins: [builtins] })
-    open.push(harness)
-    serve(harness, transport)
-
-    const state = await request('skills.list')
-    expect(state.items).toMatchObject([{ id: 'rules/plain', builtin: true }, { id: 'skills/review', builtin: true }])
-    expect(state.enabled.global).toEqual(['rules/plain', 'skills/review'])
-    expect((await request<any[]>('skills.enabledFor', { projectId: 'p1' })).map((item) => item.id)).toEqual(['rules/plain', 'skills/review'])
-    expect((await request('context.compile', { context: { projectId: 'p1', actor: 'Code' }, render: true })).text).toContain('Use plain words.')
-
-    const off = await request('skills.setEnabled', { projectId: null, ids: ['skills/review'] })
-    expect(off.enabled).toMatchObject({ global: ['skills/review'], builtinOff: ['rules/plain'] })
-    expect((await request<any[]>('skills.enabledFor', {})).map((item) => item.id)).toEqual(['skills/review'])
-
-    writeFile(join(harness.env.root, 'registry', 'skills', 'review', 'SKILL.md'), '---\nname: review\ndescription: My own review steps\n---\nMine.\n')
-    const mine = (await request('skills.list')).items.find((item: any) => item.id === 'skills/review')
-    expect(mine).toMatchObject({ description: 'My own review steps' })
-    expect(mine.builtin).toBeUndefined()
-    // A person's own item is enabled the usual way, not by default.
-    expect((await request<any[]>('skills.enabledFor', {})).map((item) => item.id)).toEqual([])
-  })
-})

package/src/sessions/approvals.test.ts

@@ -1,49 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { Bus } from '../core/bus'
-import { Approvals, grant } from './approvals'
-
-const folders: string[] = []
-afterEach(() => { for (const folder of folders.splice(0)) rmSync(folder, { recursive: true, force: true }) })
-
-function state() {
-  const folder = mkdtempSync(join(tmpdir(), 'harness-approvals-'))
-  folders.push(folder)
-  const bus = new Bus()
-  return { folder, approvals: new Approvals(folder, bus) }
-}
-
-describe('standing approval policy', () => {
-  it('loads old files with no global tool grants', () => {
-    const { folder, approvals } = state()
-    writeFileSync(join(folder, 'approvals.json'), JSON.stringify({ auto: { pi: true }, remembered: { old: ['write'] } }))
-
-    expect(approvals.read()).toEqual({ auto: { pi: true }, globalTools: {}, remembered: { old: ['write'] } })
-  })
-
-  it('persists a profile-wide tool grant, while read-only and other profiles stay isolated', () => {
-    const { folder, approvals } = state()
-    approvals.allowTool('pi', 'bash')
-    const policy = approvals.read()
-
-    expect(policy.globalTools).toEqual({ pi: ['bash'] })
-    expect(grant(policy, 'pi', 'terminal-one', 'bash')).toBe('remembered')
-    expect(grant(policy, 'pi', 'terminal-two', 'bash')).toBe('remembered')
-    expect(grant(policy, 'chat', 'terminal-two', 'bash')).toBeNull()
-    expect(grant(policy, 'pi', 'terminal-two', 'bash', { readOnly: true })).toBeNull()
-    expect(JSON.parse(readFileSync(join(folder, 'approvals.json'), 'utf8'))).toMatchObject({ globalTools: { pi: ['bash'] } })
-  })
-
-  it('revokes a global tool grant without changing the full switch or session grants', () => {
-    const { approvals } = state()
-    approvals.setAuto('pi', true)
-    approvals.remember('one-session', 'write')
-    approvals.allowTool('pi', 'bash')
-
-    expect(approvals.revokeTool('pi', 'bash')).toEqual({ auto: { pi: true }, globalTools: {}, remembered: { 'one-session': ['write'] } })
-    expect(approvals.read().globalTools).toEqual({})
-  })
-})

package/src/sessions/approvals.ts

@@ -1,140 +0,0 @@
-// What the user has chosen to stop being asked about: an "always approve" switch, tools allowed
-// across a harness state directory, and tools remembered for one session.
-import { chmodSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { Bus } from '../core/bus'
-import { invalid } from '../core/errors'
-import { readJson, writeJson } from '../core/fs'
-import type { RunRecord } from './contracts'
-
-/** Kinds of session with a switch: an agent's own conversations, and sessions in a project. */
-export const APPROVAL_KEYS = ['chat', 'pi'] as const
-
-export interface ApprovalPolicy {
-  /** Switch key → every approval is granted without asking. */
-  auto: Record<string, boolean>
-  /** Approval key → tools allowed across sessions that share this local state directory. */
-  globalTools: Record<string, string[]>
-  /** Session id → approval targets always allowed there. */
-  remembered: Record<string, string[]>
-}
-
-/** Why a request is granted without asking. */
-export type AutomaticReason = 'always' | 'remembered' | 'scope'
-
-/** What only the embedding application knows about a pending approval. */
-export interface ApprovalFacts {
-  /** Unattended work keeps to its saved scope whatever the switches say. */
-  unattended?: boolean
-  /** The session may not change anything; the switch must not approve its way out of that. */
-  readOnly?: boolean
-  /** The application's own scope already covers this exact operation. */
-  inScope?: boolean
-}
-
-/** Why the standing choices grant this request, if they do. */
-export function decide(policy: ApprovalPolicy, key: string, sessionId: string, target: string): AutomaticReason | null {
-  if (policy.auto[key]) return 'always'
-  if (policy.globalTools[key]?.includes(target)) return 'remembered'
-  return policy.remembered[sessionId]?.includes(target) ? 'remembered' : null
-}
-
-export function grant(policy: ApprovalPolicy, key: string, sessionId: string, target: string, facts: ApprovalFacts = {}): AutomaticReason | null {
-  if (facts.unattended) return null
-  // "Always approve" must not let a read-only session approve its way out of read-only mode.
-  return decide(facts.readOnly ? { auto: {}, globalTools: {}, remembered: policy.remembered } : policy, key, sessionId, target)
-}
-
-/** A conversation's runs share one switch whatever model they use; other runs follow their own. */
-export const approvalKey = (run: Pick<RunRecord, 'mode' | 'harness'>): string => (run.mode === 'chat' ? 'chat' : run.harness)
-
-export class Approvals {
-  private readonly path: string
-
-  constructor(stateDir: string, private readonly bus: Bus) {
-    this.path = join(stateDir, 'approvals.json')
-  }
-
-  read(): ApprovalPolicy {
-    const stored = readJson<Partial<ApprovalPolicy>>(this.path) ?? {}
-    return { auto: stored.auto ?? {}, globalTools: stored.globalTools ?? {}, remembered: stored.remembered ?? {} }
-  }
-
-  private change(update: (policy: ApprovalPolicy) => void): ApprovalPolicy {
-    const policy = this.read()
-    update(policy)
-    writeJson(this.path, policy)
-    try {
-      chmodSync(this.path, 0o600)
-    } catch {
-      // The file was written; a mode that cannot be set is not worth failing the change.
-    }
-    this.bus.emit({ type: 'approvals.changed' })
-    return policy
-  }
-
-  isAuto(key: string): boolean {
-    try {
-      return Boolean(this.read().auto[key])
-    } catch {
-      return false
-    }
-  }
-
-  /** Why this run's approval for `target` can be granted without asking, if it can. */
-  automatic(run: RunRecord, target: string, facts: ApprovalFacts = {}): AutomaticReason | null {
-    // What the application's own scope already covers needs neither the switch nor the user.
-    return grant(this.read(), approvalKey(run), run.sessionId, target, facts) ?? (!facts.unattended && facts.inScope ? 'scope' : null)
-  }
-
-  setAuto(key: string, on: boolean): ApprovalPolicy {
-    if (!(APPROVAL_KEYS as readonly string[]).includes(key)) throw invalid('Unknown harness.')
-    return this.change((policy) => void (policy.auto[key] = on))
-  }
-
-  /** Always allow `target` for every session in this approval profile and state directory. */
-  allowTool(key: string, target: string): ApprovalPolicy {
-    if (!(APPROVAL_KEYS as readonly string[]).includes(key)) throw invalid('Unknown harness.')
-    if (!target.trim()) throw invalid('A tool is required.')
-    return this.change((policy) => {
-      const targets = (policy.globalTools[key] ??= [])
-      if (!targets.includes(target)) targets.push(target)
-    })
-  }
-
-  revokeTool(key: string, target: string): ApprovalPolicy {
-    if (!(APPROVAL_KEYS as readonly string[]).includes(key)) throw invalid('Unknown harness.')
-    return this.change((policy) => {
-      const targets = policy.globalTools[key]?.filter((item) => item !== target) ?? []
-      if (targets.length) policy.globalTools[key] = targets
-      else delete policy.globalTools[key]
-    })
-  }
-
-  /** Always allow `target` in this session. */
-  remember(sessionId: string, target: string): ApprovalPolicy {
-    if (!target.trim()) throw invalid('A tool is required.')
-    return this.change((policy) => {
-      const targets = (policy.remembered[sessionId] ??= [])
-      if (!targets.includes(target)) targets.push(target)
-    })
-  }
-
-  forget(sessionId: string, target: string): ApprovalPolicy {
-    return this.change((policy) => {
-      const targets = policy.remembered[sessionId]?.filter((item) => item !== target) ?? []
-      if (targets.length) policy.remembered[sessionId] = targets
-      else delete policy.remembered[sessionId]
-    })
-  }
-
-  /** Forgets what was remembered for a session that no longer exists. */
-  forgetSession(sessionId: string): void {
-    try {
-      if (sessionId in this.read().remembered) this.change((policy) => void delete policy.remembered[sessionId])
-    } catch {
-      // Nothing recorded.
-    }
-  }
-}