@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/terminal/piExtension.ts

@@ -1,295 +0,0 @@
-// Loaded by the `pi` command in a terminal session (`--extension`). It reports what the native
-// session does to the harness, asks before each tool call, takes instructions the harness
-// queues for it, and gives the session the harness's own tools. It runs in the `pi` process,
-// so everything it knows about the harness comes through the session socket.
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
-import { Type } from 'typebox'
-
-import { connectionFromEnv, socketCall, terminalCall } from './client'
-import { runAccountsMenu, type SessionAccount } from './accountsMenu'
-import { runPluginsMenu } from './pluginMenu'
-import { runHubMenu } from './hubMenu'
-import { claimTerminalControl, controlCall } from './control'
-import { SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, subagentHistory, type SubagentReceipt } from '../sessions/subagents'
-import { askUserTool } from '../tools/askUser'
-import type { QuestionAnswer } from '../sessions/registry'
-
-interface SocketTool {
-  name: string
-  label: string
-  description: string
-  parameters: Record<string, unknown>
-}
-
-/** How much text a tool handed back to the model. */
-function resultSize(result: unknown): number | null {
-  const content = (result as { content?: unknown } | null | undefined)?.content
-  if (!Array.isArray(content)) return typeof result === 'string' ? result.length : null
-  return content.reduce((total: number, part: { type?: string; text?: unknown }) => total + (part?.type === 'text' && typeof part.text === 'string' ? part.text.length : 0), 0)
-}
-
-async function withParentCancellation<T>(signal: AbortSignal | undefined, work: () => Promise<T>): Promise<T> {
-  const stop = () => { void controlCall('terminal.interrupt').catch(() => {}) }
-  if (signal?.aborted) stop()
-  signal?.addEventListener('abort', stop, { once: true })
-  try { return await work() } finally { signal?.removeEventListener('abort', stop) }
-}
-
-export default async function (pi: ExtensionAPI) {
-  await terminalCall('startup', { phase: 'Pi extension loaded' })
-  let context: ExtensionContext | null = null
-  let nativeSubagents = false
-  let subagentParent = false
-  let timer: ReturnType<typeof setInterval> | null = null
-  let polling = false
-  let failure: string | undefined
-  const emptyUsage = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, requests: 0, costUsd: 0 })
-  let usage = emptyUsage()
-  let reasoningTokens: number | undefined
-  let costReported = false
-  let requestStartedAt: number | null = null
-  const toolStartedAt = new Map<string, number>()
-  const fileTools = new Map<string, string>()
-
-  // The harness's own tools for this session (connected apps and what the application offers).
-  let stage = 'Tool discovery'
-  try {
-    await terminalCall('startup', { phase: stage })
-    const connection = connectionFromEnv()
-    // Claimed here, before the model has run anything, and kept in this process's memory: a
-    // command the model runs can read the session token from its environment, never this key.
-    const control = await claimTerminalControl(connection).catch(() => null)
-    pi.registerCommand('hub', {
-      description: 'Browse and install reviewed skills, plugins, and reusable documents',
-      handler: async (_args, ctx) => {
-        if (!control) return ctx.ui.notify('This session cannot install hub items.', 'warning')
-        await runHubMenu(
-          { select: (title, options) => ctx.ui.select(title, options), confirm: (title, message) => ctx.ui.confirm(title, message), notify: (message, level) => ctx.ui.notify(message, level) },
-          (method, params) => socketCall(connection, method, params ?? {}, 300_000, control)
-        )
-      }
-    })
-    pi.registerCommand('plugins', {
-      description: 'See what this session loads, and switch a plugin on or off or trust its code',
-      handler: async (_args, ctx) => {
-        if (!control) return ctx.ui.notify('This session cannot change plugins.', 'warning')
-        const { projectId } = await socketCall<{ projectId: string | null }>(connection, 'plugins.session', {}, 15_000, control).catch(() => ({ projectId: null }))
-        await runPluginsMenu(
-          { select: (title, options) => ctx.ui.select(title, options), confirm: (title, message) => ctx.ui.confirm(title, message), notify: (message, level) => ctx.ui.notify(message, level) },
-          (method, params) => socketCall(connection, method, params ?? {}, 60_000, control),
-          projectId
-        )
-      }
-    })
-    pi.registerCommand('accounts', {
-      description: 'Add, sign in to, check, switch, or remove the Pi accounts this harness uses',
-      handler: async (_args, ctx) => {
-        if (!control) return ctx.ui.notify('This session cannot manage accounts.', 'warning')
-        const session = await socketCall<SessionAccount>(connection, 'accounts.session', {}, 15_000, control).catch(() => null)
-        if (!session) return ctx.ui.notify('This session has no account to manage.', 'warning')
-        const outcome = await runAccountsMenu(
-          {
-            select: (title, options) => ctx.ui.select(title, options),
-            confirm: (title, message) => ctx.ui.confirm(title, message),
-            input: (title, placeholder) => ctx.ui.input(title, placeholder),
-            notify: (message, level) => ctx.ui.notify(message, level)
-          },
-          (method, params) => socketCall(connection, method, params ?? {}, 120_000, control),
-          session
-        )
-        // The session restarts on the account it chose: Pi ends here, and the launcher starts it again.
-        if (outcome === 'relaunch') ctx.shutdown()
-      }
-    })
-    const { tools } = await socketCall<{ tools: SocketTool[] }>(connection, 'tools.list', {}, 15_000)
-    stage = 'Tool registration'
-    for (const tool of tools) {
-      pi.registerTool({
-        name: tool.name,
-        label: tool.label,
-        description: tool.description,
-        parameters: Type.Unsafe(tool.parameters),
-        async execute(_id, input) {
-          const result = await socketCall<{ text: string }>(connection, 'tools.call', { name: tool.name, input: input as Record<string, unknown> }, 1_230_000)
-          return { content: [{ type: 'text', text: result.text }], details: undefined }
-        }
-      })
-    }
-    const native = await controlCall<{ tools: SocketTool[] }>('terminal.subagents.tools')
-    nativeSubagents = native.tools.length > 0
-    for (const tool of native.tools) pi.registerTool({
-      name: tool.name, label: tool.label, description: tool.description, parameters: Type.Unsafe(tool.parameters),
-      execute: async (_id, input, signal) => {
-        const result = await withParentCancellation(signal, () => controlCall<{ text: string; details?: Record<string, unknown> }>('terminal.subagents.call', { name: tool.name, input }, 2_147_483_647))
-        return { content: [{ type: 'text' as const, text: result.text }], details: result.details ?? {} }
-      }
-    })
-  } catch (error) {
-    await terminalCall('startupFailed', { reason: `${stage} failed: ${error instanceof Error ? error.message : 'Unavailable'}` }).catch(() => {})
-    throw error
-  }
-
-  pi.on('session_start', async (_event, ctx) => {
-    context = ctx
-    if (timer) clearInterval(timer)
-    await terminalCall('ready', { nativeSessionId: ctx.sessionManager.getSessionFile() })
-    timer = setInterval(() => {
-      if (polling || !context) return
-      polling = true
-      void terminalCall<{ command: { type: string; text?: string } | null }>('poll', {}, 5_000)
-        .then(({ command }) => {
-          if (command?.type === 'interrupt') context?.abort()
-          else if (command?.type === 'send') {
-            if (context?.ui.getEditorText().trim()) throw new Error('The terminal contains a user draft.')
-            // Pi 1.2 needs deliverAs while a run is busy; a message sent then waits for that run to finish.
-            pi.sendUserMessage(command.text!, context?.isIdle() === false ? { deliverAs: 'followUp' } : undefined)
-          }
-        })
-        .catch(() => {
-          context?.abort()
-          if (timer) clearInterval(timer)
-        })
-        .finally(() => {
-          polling = false
-        })
-    }, 100)
-  })
-  pi.on('before_agent_start', async (event, ctx) => {
-    context = ctx
-    failure = undefined
-    usage = emptyUsage()
-    reasoningTokens = undefined
-    costReported = false
-    // A run a plugin starts with a custom message has no user prompt to record; it still begins a turn.
-    const begun = await terminalCall<{ runId: string }>('begin', { text: event.messageType === 'user' ? event.prompt : '' })
-    if (nativeSubagents) {
-      pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId })
-      await controlCall('terminal.subagents.register', { tools: pi.getActiveTools(), model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel(), history: subagentHistory(ctx.sessionManager.getBranch()) })
-      subagentParent = true
-    }
-  })
-  const deliverChildren = async (event: any, ctx: ExtensionContext, settle: boolean) => {
-    if (!nativeSubagents || (settle && event.outcome !== 'completed') || ctx.signal?.aborted) return
-    const result = await withParentCancellation(ctx.signal, () => controlCall<{ text: string; receipt: SubagentReceipt } | null>('terminal.subagents.delivery', { history: subagentHistory([...ctx.sessionManager.getBranch(), ...event.entries]), settle }, 2_147_483_647))
-    if (!result) return
-    return { entries: [...event.entries, { type: 'custom_message' as const, customType: SUBAGENT_RESULTS, content: result.text, display: false, details: { [SUBAGENT_RECEIPT]: result.receipt } }], continue: true }
-  }
-  pi.on('turn_end', (event, ctx) => deliverChildren(event, ctx, false))
-  pi.on('agent_before_settle', (event, ctx) => deliverChildren(event, ctx, true))
-  pi.on('message_end', async (event) => {
-    if (event.message.role !== 'assistant') return
-    if (event.message.stopReason === 'error' || event.message.stopReason === 'aborted') failure = event.message.errorMessage ?? `Pi stopped: ${event.message.stopReason}`
-    const text = event.message.content.filter((part) => part.type === 'text').map((part) => part.text).join('\n')
-    if (text) await terminalCall('message', { text })
-    if (event.message.usage) {
-      const reported = event.message.usage
-      usage.inputTokens += reported.input ?? 0
-      usage.outputTokens += reported.output ?? 0
-      usage.cacheReadTokens += reported.cacheRead ?? 0
-      usage.cacheWriteTokens += reported.cacheWrite ?? 0
-      usage.requests += 1
-      if (typeof reported.reasoning === 'number') reasoningTokens = (reasoningTokens ?? 0) + reported.reasoning
-      const cost = reported.cost?.total
-      if (typeof cost === 'number') {
-        usage.costUsd += cost
-        costReported = true
-      }
-      const identity = { model: event.message.model, provider: event.message.provider }
-      const { costUsd, ...tokens } = usage
-      await terminalCall('usage', {
-        ...tokens,
-        ...(costReported ? { costUsd, costSource: 'harness' } : {}),
-        ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
-        contextTokens: (reported.input ?? 0) + (reported.cacheRead ?? 0) + (reported.cacheWrite ?? 0),
-        ...(context?.model?.contextWindow ? { contextWindow: context.model.contextWindow } : {}),
-        ...identity,
-        request: {
-          index: usage.requests,
-          ...identity,
-          responseId: event.message.responseId,
-          inputTokens: reported.input ?? 0,
-          cacheReadTokens: reported.cacheRead ?? 0,
-          cacheWriteTokens: reported.cacheWrite ?? 0,
-          outputTokens: reported.output ?? 0,
-          ...(typeof reported.reasoning === 'number' ? { reasoningTokens: reported.reasoning } : {}),
-          ...(typeof cost === 'number' ? { costUsd: cost, costSource: 'harness' } : {}),
-          ...(requestStartedAt === null ? {} : { durationMs: Date.now() - requestStartedAt }),
-          stopReason: event.message.stopReason
-        }
-      })
-      requestStartedAt = null
-    }
-  })
-  pi.on('turn_start', async () => {
-    requestStartedAt = Date.now()
-  })
-  pi.on('tool_call', async (event) => {
-    try {
-      const policy = await controlCall<{ allowed: boolean; reason?: string; requiresApproval?: boolean }>('terminal.policy', { tool: event.toolName, args: event.input })
-      if (policy.requiresApproval) {
-        const approval = await controlCall<{ decision: string }>('terminal.approval', { requestId: event.toolCallId, tool: event.toolName, args: event.input })
-        if (approval.decision === 'approved') return
-        return { block: true, reason: 'The user denied this action. Ask how they would like to proceed.' }
-      }
-      if (!policy.allowed) return { block: true, reason: policy.reason ?? 'Outside what this session may do.' }
-    } catch {
-      return { block: true, reason: 'The terminal controller is unavailable.' }
-    }
-  })
-  pi.on('tool_execution_start', async (event) => {
-    if (['edit', 'write'].includes(event.toolName) && typeof event.args.path === 'string') fileTools.set(event.toolCallId, event.args.path)
-    toolStartedAt.set(event.toolCallId, Date.now())
-    await terminalCall('tool', { phase: 'start', id: event.toolCallId, name: event.toolName, summary: JSON.stringify(event.args).slice(0, 200) })
-  })
-  pi.on('tool_execution_end', async (event) => {
-    const started = toolStartedAt.get(event.toolCallId)
-    toolStartedAt.delete(event.toolCallId)
-    const resultChars = resultSize(event.result)
-    await terminalCall('tool', { phase: 'end', id: event.toolCallId, name: event.toolName, ok: !event.isError, ...(started === undefined ? {} : { durationMs: Date.now() - started }), ...(resultChars === null ? {} : { resultChars }) })
-    const path = fileTools.get(event.toolCallId)
-    fileTools.delete(event.toolCallId)
-    if (!event.isError && path) await terminalCall('file', { path, change: 'modified' })
-  })
-  pi.on('agent_settled', async (event, ctx) => {
-    if (subagentParent && !event.aborted && !failure) {
-      try { await controlCall('terminal.subagents.verify', { history: subagentHistory(ctx.sessionManager.getBranch()) }, 2_147_483_647) } catch (error) { failure = error instanceof Error ? error.message : String(error) }
-    }
-    subagentParent = false
-    await terminalCall('settled', { error: failure, aborted: event.aborted })
-  })
-  pi.on('user_bash', async () => {
-    throw new Error('Use the bash tool so this action can be checked.')
-  })
-  pi.on('session_shutdown', async () => {
-    if (timer) clearInterval(timer)
-    timer = null
-    context = null
-    // This clears the controller's readiness while the next native session binds. The
-    // process-level control claim survives replacement; only the session poller stops.
-    await terminalCall('shutdown').catch(() => {})
-  })
-  const ask = askUserTool({ requestAnswers: questions => terminalCall<QuestionAnswer[]>('questions', { questions }, 1_230_000) })
-  pi.registerTool({
-    name: ask.name, label: ask.label, description: ask.description,
-    parameters: Type.Unsafe(ask.parameters(Type) as Record<string, unknown>),
-    async execute(_id, input) {
-      const result = await ask.execute(input as Record<string, unknown>)
-      return { content: [{ type: 'text', text: typeof result === 'string' ? result : result.text }], details: undefined }
-    }
-  })
-  pi.registerTool({
-    name: 'ask_user_question',
-    label: 'Ask a question',
-    description: 'Ask the user a question and wait for their answer.',
-    parameters: Type.Object({
-      question: Type.String(),
-      options: Type.Optional(Type.Array(Type.Object({ label: Type.String(), description: Type.Optional(Type.String()) }))),
-      multiSelect: Type.Optional(Type.Boolean())
-    }),
-    async execute(id, input) {
-      const answer = await terminalCall('question', { requestId: id, ...input })
-      return { content: [{ type: 'text', text: JSON.stringify(answer) }], details: undefined }
-    }
-  })
-  await terminalCall('startup', { phase: 'Pi hooks registered' })
-}

package/src/terminal/pluginControl.test.ts

@@ -1,146 +0,0 @@
-import { existsSync, 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 { runPluginsCli } from '../plugins/cli'
-import type { Plugin } from '../plugins/types'
-import { rootWithProject, writeFile } from '../../tests/helpers'
-import { SOCKET_ENV, TOKEN_ENV, socketCall, type SocketConnection } from './client'
-import { menuRows, rowActions, runPluginsMenu, type MenuUi } from './pluginMenu'
-
-const open: Harness[] = []
-afterEach(async () => {
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-function kit(folder: string): void {
-  writeFile(join(folder, 'package.json'), JSON.stringify({ name: 'review-kit', description: 'Review helpers.', version: '1.0.0' }))
-  writeFile(join(folder, 'extensions/guard.ts'), 'export default function () {}\n')
-  writeFile(join(folder, 'skills/audit/SKILL.md'), '---\nname: audit\ndescription: Audit a change.\n---\nSteps.\n')
-}
-
-async function session() {
-  const root = rootWithProject()
-  const base = mkdtempSync(join(tmpdir(), 'control-'))
-  writeFile(join(root, 'registry/rules/tests.md'), '---\nname: Run tests\ndescription: Always test.\n---\nAlways run the tests.\n')
-  const harness = createHarness({ dataRoot: root, stateDir: join(base, 'state'), secrets: memorySecretStore(), piProgram: () => '/opt/pi/bin/pi', assets: { node: '/opt/node', cli: '/opt/harness/cli.js', piExtension: '/opt/harness/terminal-pi.js' } })
-  open.push(harness)
-  const account = harness.accounts.create('Main', 'apiKey').accounts[0]
-  harness.plugins.trust.adopt([])
-  kit(join(root, 'plugins/review-kit'))
-  const launch = await harness.terminals.prepare({ sessionId: 'term-1', accountId: account.id, projectId: 'p1', cwd: base, sessionFolder: join(root, 'sessions', 'p1', 'term-1') })
-  const connection: SocketConnection = { socket: String(launch.env[SOCKET_ENV]), token: String(launch.env[TOKEN_ENV]) }
-  return { harness, root, base, connection }
-}
-
-/** A person at the terminal, answering each dialog in turn from a script. */
-function person(answers: (string | boolean | undefined)[]) {
-  const shown: string[] = []
-  const said: string[] = []
-  const ui: MenuUi = {
-    select: async (title, options) => {
-      shown.push(`${title} → ${options.join(' | ')}`)
-      return answers.shift() as string | undefined
-    },
-    confirm: async (title, message) => {
-      shown.push(`${title} ${message}`)
-      return answers.shift() === true
-    },
-    notify: (message) => void said.push(message)
-  }
-  return { ui, shown, said }
-}
-
-describe('plugin control from a terminal session', () => {
-  it("lists for anyone in the session, and changes only for the session's own extension", async () => {
-    const { connection } = await session()
-    const listed = await socketCall<Plugin[]>(connection, 'plugins.list')
-    const plugin = listed.find((candidate) => candidate.id === 'package:review-kit')!
-    expect(plugin).toMatchObject({ trust: 'untrusted' })
-    // A command the model runs in the shell has the session token and nothing more.
-    await expect(socketCall(connection, 'plugins.trust', { hash: plugin.code!.hash })).rejects.toThrow('Only a person at this terminal can change plugins')
-    await expect(socketCall(connection, 'plugins.detach', { id: plugin.id })).rejects.toThrow('Only a person at this terminal')
-    await expect(socketCall(connection, 'plugins.trust', { hash: plugin.code!.hash }, 5_000, 'guessed')).rejects.toThrow('Only a person at this terminal')
-
-    // The extension claims the key as it loads. It is given out once.
-    const { key } = await socketCall<{ key: string }>(connection, 'control.claim')
-    await expect(socketCall(connection, 'control.claim')).rejects.toThrow('already claimed')
-    const trusted = await socketCall<Plugin[]>(connection, 'plugins.trust', { hash: plugin.code!.hash }, 5_000, key)
-    expect(trusted.find((candidate) => candidate.id === plugin.id)).toMatchObject({ trust: 'trusted' })
-    // Without "everywhere", a switch from a terminal is for the session's project.
-    const off = await socketCall<Plugin[]>(connection, 'plugins.detach', { id: plugin.id }, 5_000, key)
-    expect(off.find((candidate) => candidate.id === plugin.id)!.attachment).toEqual({ global: true, on: { agentIds: [], projectIds: [] }, off: { agentIds: [], projectIds: ['p1'] } })
-  })
-
-  it('walks a person through switching and trusting, and changes nothing they did not choose', async () => {
-    const { harness, connection } = await session()
-    const { key } = await socketCall<{ key: string }>(connection, 'control.claim')
-    const call = <T>(method: string, params?: Record<string, unknown>) => socketCall<T>(connection, method, params ?? {}, 5_000, key)
-    const rows = menuRows(await call<Plugin[]>('plugins.list'), 'p1')
-    expect(rows.map((row) => row.label)).toEqual(['● review-kit · code not trusted', '○ Run tests · instruction in Yours', '○ Budget guard · runs code', '○ Output trim · runs code'])
-    expect(rowActions(rows[0], 'p1')).toEqual(['Switch off for this project', 'Switch off everywhere', 'Trust its code', 'Back'])
-    expect(rowActions(rows[1], null)).toEqual(['Switch on everywhere', 'Back'])
-    // A part that ships with the harness needs no trust: it is the harness's own code.
-    expect(rowActions(rows[2], 'p1')).toEqual(['Switch on for this project', 'Switch on everywhere', 'Back'])
-
-    // Declining the trust question leaves the code untrusted; then they trust it, switch a rule on, and leave.
-    const { ui, shown, said } = person(['● review-kit · code not trusted', 'Trust its code', false, '● review-kit · code not trusted', 'Trust its code', true, '○ Run tests · instruction in Yours', 'Switch on for this project', 'Done'])
-    await runPluginsMenu(ui, call, 'p1')
-    expect(shown.find((line) => line.startsWith('Trust this code?'))).toContain('extensions/guard.ts')
-    expect(shown.find((line) => line.startsWith('Trust this code?'))).toContain('can do anything this app can')
-    expect(said).toEqual(['Saved. It applies when this session restarts.'])
-    const after = await call<Plugin[]>('plugins.list')
-    expect(after.find((plugin) => plugin.id === 'package:review-kit')).toMatchObject({ trust: 'trusted' })
-    expect(after.flatMap((plugin) => plugin.contributions).find((entry) => entry.id === 'yours/rules/tests')).toMatchObject({ state: 'on', scope: 'App' })
-    expect(harness.plugins.trust.list()).toHaveLength(1)
-
-    // Leaving at once changes nothing and says nothing.
-    const idle = person([undefined])
-    await runPluginsMenu(idle.ui, call, 'p1')
-    expect(idle.said).toEqual([])
-  })
-})
-
-describe('the plugins command', () => {
-  it('lists, installs, switches, trusts only on a yes, and removes, on its own data', async () => {
-    const base = mkdtempSync(join(tmpdir(), 'plugins-cli-'))
-    kit(join(base, 'kit'))
-    const lines: string[] = []
-    const run = (argv: string[], answer?: string) => runPluginsCli([...argv, '--data', join(base, 'data'), '--state', join(base, 'state')], { home: base, cwd: base, write: (text) => void lines.push(text), ...(answer === undefined ? {} : { ask: async () => answer }) })
-    const last = (): string => lines.at(-1) ?? ''
-
-    expect(await run(['list'])).toBe(0)
-    expect(last()).toMatch(/^memory\s+required\s+Memory$/m)
-    expect(await run(['install', join(base, 'kit')])).toBe(0)
-    expect(last()).toContain('Installed, switched off.')
-    expect(last()).toContain('trust its code with "plugins trust <id>"')
-    expect(await run(['list'])).toBe(0)
-    expect(last()).toMatch(/^package:review-kit\s+off, code not trusted\s+review-kit$/m)
-
-    expect(await run(['attach', 'package:review-kit'])).toBe(0)
-    expect(last()).toBe('package:review-kit is on everywhere. It applies from the next session start.\n')
-    // No terminal to ask on and no --yes: the files are shown and nothing is trusted.
-    expect(await run(['trust', 'package:review-kit'])).toBe(1)
-    expect(lines.at(-2)).toContain('extensions/guard.ts')
-    expect(last()).toBe('Read the files, then run this again with --yes to trust them.\n')
-    expect(await run(['trust', 'package:review-kit'], 'no')).toBe(1)
-    expect(last()).toBe('Not trusted.\n')
-    expect(await run(['trust', 'package:review-kit'], 'yes')).toBe(0)
-    expect(await run(['show', 'package:review-kit'])).toBe(0)
-    expect(last()).toContain('State: on')
-    expect(last()).toContain('Code (trusted)')
-    expect(last()).toContain('● skill audit (package:review-kit/skill/audit)')
-
-    expect(await run(['detach', 'memory'])).toBe(1)
-    expect(last()).toContain('Memory cannot be switched off.')
-    expect(await run(['untrust', 'package:review-kit'])).toBe(0)
-    expect(await run(['remove', 'package:review-kit'])).toBe(0)
-    expect(await run(['show', 'package:review-kit'])).toBe(1)
-    expect(await run(['nonsense'])).toBe(2)
-    // The folder that was installed in place is still the person's.
-    expect(existsSync(join(base, 'kit/package.json'))).toBe(true)
-  })
-})

package/src/terminal/pluginMenu.ts

@@ -1,112 +0,0 @@
-// The `/plugins` command of a terminal session, without Pi: what it lists, what it offers for
-// each row, and the conversation it has with the person. It asks through whatever interface it
-// is given (Pi's own dialogs in a terminal) and changes things through one function, so the
-// same flow is tested without a terminal.
-import type { Attachment } from '../plugins/attachments'
-import type { Contribution, Plugin } from '../plugins/types'
-
-export interface MenuUi {
-  select(title: string, options: string[]): Promise<string | undefined>
-  confirm(title: string, message: string): Promise<boolean>
-  notify(message: string, level?: 'info' | 'warning' | 'error'): void
-}
-
-/** `plugins.list`, `plugins.attach`, `plugins.detach`, `plugins.trust`, `plugins.untrust`. */
-export type MenuCall = <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>
-
-export interface MenuRow {
-  /** The plugin's id, or one contribution's. */
-  id: string
-  label: string
-  on: boolean
-  /** The plugin it is, or belongs to. */
-  plugin: Plugin
-  /** Set when the row is the whole plugin. */
-  whole: boolean
-}
-
-const here = (attachment: Attachment, projectId: string | null): boolean => {
-  if (projectId && attachment.on.projectIds.includes(projectId)) return true
-  if (projectId && attachment.off.projectIds.includes(projectId)) return false
-  return attachment.global
-}
-
-const mark = (on: boolean): string => (on ? '●' : '○')
-
-/** What can be switched or trusted from here: each found or installed plugin, and each item of the rest that has a switch. */
-export function menuRows(plugins: readonly Plugin[], projectId: string | null): MenuRow[] {
-  const rows: MenuRow[] = []
-  for (const plugin of plugins) {
-    if (plugin.attachment) {
-      const on = here(plugin.attachment, projectId)
-      rows.push({ id: plugin.id, plugin, whole: true, on, label: `${mark(on)} ${plugin.title}${plugin.trust === 'untrusted' ? ' · code not trusted' : plugin.runsCode ? ' · runs code' : ''}` })
-      continue
-    }
-    if (plugin.trust !== 'none') rows.push({ id: plugin.id, plugin, whole: true, on: plugin.trust === 'trusted', label: `${mark(plugin.trust === 'trusted')} ${plugin.title} · ${plugin.trust === 'trusted' ? 'code trusted' : 'code not trusted'}` })
-    for (const entry of plugin.contributions) {
-      if (!entry.attachment) continue
-      rows.push({ id: entry.id, plugin, whole: false, on: entry.state === 'on', label: `${mark(entry.state === 'on')} ${entry.name} · ${kindWord(entry)} in ${plugin.title}` })
-    }
-  }
-  return rows
-}
-
-const kindWord = (entry: Contribution): string => (entry.kind === 'connection' ? 'connected app' : entry.kind === 'code' ? 'extension' : entry.kind)
-
-const SWITCH_OFF_PROJECT = 'Switch off for this project'
-const SWITCH_ON_PROJECT = 'Switch on for this project'
-const SWITCH_OFF_EVERYWHERE = 'Switch off everywhere'
-const SWITCH_ON_EVERYWHERE = 'Switch on everywhere'
-const TRUST = 'Trust its code'
-const UNTRUST = 'Stop trusting its code'
-const BACK = 'Back'
-const DONE = 'Done'
-
-/** What a person can do with one row. A whole plugin whose code waits for trust can be trusted here. */
-export function rowActions(row: MenuRow, projectId: string | null): string[] {
-  const switchable = row.whole ? row.plugin.attachment !== null : true
-  const actions: string[] = []
-  if (switchable) {
-    if (projectId) actions.push(row.on ? SWITCH_OFF_PROJECT : SWITCH_ON_PROJECT)
-    actions.push(row.on ? SWITCH_OFF_EVERYWHERE : SWITCH_ON_EVERYWHERE)
-  }
-  if (row.whole && row.plugin.code) actions.push(row.plugin.trust === 'untrusted' ? TRUST : UNTRUST)
-  return [...actions, BACK]
-}
-
-/**
- * Runs the command: list, pick a row, pick what to do, until the person is done. Nothing changes
- * without a choice made here, and trusting code asks once more with the files in view.
- */
-export async function runPluginsMenu(ui: MenuUi, call: MenuCall, projectId: string | null): Promise<void> {
-  let changed = false
-  for (;;) {
-    const rows = menuRows(await call<Plugin[]>('plugins.list'), projectId)
-    if (!rows.length) {
-      ui.notify('There is nothing to switch or trust here yet.', 'info')
-      return
-    }
-    const picked = await ui.select(`Plugins${changed ? ' (changes apply when this session restarts)' : ''}`, [...rows.map((row) => row.label), DONE])
-    const row = rows.find((candidate) => candidate.label === picked)
-    if (!row) break
-    const action = await ui.select(`${row.plugin.title}: ${row.plugin.description || 'No description.'}`, rowActions(row, projectId))
-    if (!action || action === BACK) continue
-    try {
-      if (action === TRUST || action === UNTRUST) {
-        const code = row.plugin.code!
-        if (action === TRUST) {
-          const sure = await ui.confirm('Trust this code?', `${code.files.join('\n')}\n\nFingerprint ${code.hash.slice(0, 12)}. It runs inside the session and can do anything this app can, including reading your files and credentials.`)
-          if (!sure) continue
-        }
-        await call(action === TRUST ? 'plugins.trust' : 'plugins.untrust', { hash: code.hash })
-      } else {
-        const on = action === SWITCH_ON_PROJECT || action === SWITCH_ON_EVERYWHERE
-        await call(on ? 'plugins.attach' : 'plugins.detach', { id: row.id, everywhere: action === SWITCH_ON_EVERYWHERE || action === SWITCH_OFF_EVERYWHERE })
-      }
-      changed = true
-    } catch (error) {
-      ui.notify(error instanceof Error ? error.message : String(error), 'error')
-    }
-  }
-  if (changed) ui.notify('Saved. It applies when this session restarts.', 'info')
-}

package/src/terminal/socket.test.ts

@@ -1,94 +0,0 @@
-import { chmodSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs'
-import { createConnection } from 'node:net'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { SessionSocket, socketPath } from './socket'
-
-const handlers = { memory: () => '', apps: async () => null }
-
-/** Runs `body` as if on another operating system; `process.platform` is read at call time. */
-function onPlatform<T>(platform: NodeJS.Platform, body: () => T): T {
-  const original = Object.getOwnPropertyDescriptor(process, 'platform')!
-  Object.defineProperty(process, 'platform', { value: platform })
-  try {
-    return body()
-  } finally {
-    Object.defineProperty(process, 'platform', original)
-  }
-}
-
-describe('session socket path', () => {
-  it('keeps the socket file in the state folder on Unix', () => {
-    expect(onPlatform('darwin', () => socketPath('/tmp/state'))).toBe(join('/tmp/state', 'run', 'harness.sock'))
-  })
-
-  it('uses a named pipe on Windows, with a random name each time', () => {
-    const first = onPlatform('win32', () => socketPath('C:\\Users\\someone\\.xingular-harness\\state'))
-    const second = onPlatform('win32', () => socketPath('C:\\Users\\someone\\.xingular-harness\\state'))
-    expect(first).toMatch(/^\\\\\.\\pipe\\xingular-harness-[0-9a-f]{24}$/)
-    expect(second).not.toBe(first)
-  })
-})
-
-describe('session socket', () => {
-  it.skipIf(process.platform === 'win32')('keeps an existing Harness socket reachable when another instance uses the same state folder', async () => {
-    const base = mkdtempSync(join(tmpdir(), 'sock-shared-state-'))
-    const path = socketPath(base)
-    const first = new SessionSocket(path, handlers)
-    const second = new SessionSocket(path, handlers)
-    const canConnect = (socketPath: string): Promise<void> => new Promise((resolve, reject) => {
-      const client = createConnection(socketPath)
-      client.once('connect', () => { client.end(); resolve() })
-      client.once('error', reject)
-    })
-    try {
-      await first.listen()
-      await second.listen()
-      expect(second.path).not.toBe(first.path)
-      await second.close()
-      await expect(canConnect(first.path)).resolves.toBeUndefined()
-    } finally {
-      await first.close()
-      await second.close()
-      rmSync(base, { recursive: true, force: true })
-    }
-  })
-
-  it.skipIf(process.platform !== 'win32')('listens on a named pipe and answers a request on Windows', async () => {
-    const socket = new SessionSocket(socketPath('unused'), handlers)
-    await socket.listen()
-    try {
-      const reply = await new Promise<string>((resolve, reject) => {
-        const client = createConnection(socket.path)
-        let buffer = ''
-        client.on('connect', () => client.write('{"token":"nope","call":"wiki.read"}\n'))
-        client.on('data', (chunk) => (buffer += chunk.toString('utf8')))
-        client.on('end', () => resolve(buffer))
-        client.on('error', reject)
-      })
-      expect(JSON.parse(reply)).toMatchObject({ error: { code: 'unauthorized' } })
-    } finally {
-      await socket.close()
-    }
-  })
-
-  it('names the folder and the user when the operating system refuses to create the socket', async () => {
-    // Root can write anywhere, so the refusal cannot be produced there.
-    if (process.platform === 'win32' || process.getuid?.() === 0) return
-    const base = mkdtempSync(join(tmpdir(), 'sock-'))
-    const run = join(base, 'run')
-    mkdirSync(run)
-    chmodSync(run, 0o500)
-    try {
-      await expect(new SessionSocket(join(run, 'harness.sock'), handlers).listen()).rejects.toMatchObject({
-        code: 'session_socket_denied',
-        message: expect.stringMatching(/could not be created \((?:EACCES|EPERM)\)\. .*mode 500; this process runs as uid \d+\./)
-      })
-    } finally {
-      chmodSync(run, 0o700)
-      rmSync(base, { recursive: true, force: true })
-    }
-  })
-})