AI-native design editor. Open-source Figma alternative.
import { describe, expect, test } from 'bun:test'
import { readFileSync } from 'node:fs'
import * as v from 'valibot'
import { ACP_AGENTS } from '@open-pencil/core/constants'
import { signInScope } from '@/app/ai/agents/acp/auth/terminal'
import { HARNESS_PACKAGE } from '@/app/ai/agents/pi/companion'
import { bunInstallArgs, npmInstallArgs } from '@/app/ai/agents/setup/native'
import { MCP_PACKAGE_NAME } from '@/app/automation/mcp/failure'
import { resolvePlatformCommand, resolveScopedCommand } from '@/app/tauri/command'
import { repoPath } from '#tests/helpers/paths'
const WINDOWS_UA =
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0'
const MAC_UA =
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko)'
describe('resolvePlatformCommand', () => {
test('wraps a bare command in cmd /c through its own scope entry on Windows', () => {
expect(resolvePlatformCommand('claude-agent-acp', [], WINDOWS_UA)).toEqual({
command: 'cmd-claude-agent-acp',
args: ['/c', 'claude-agent-acp']
})
})
test('preserves extra args after the command on Windows', () => {
expect(resolvePlatformCommand('gemini', ['--acp'], WINDOWS_UA)).toEqual({
command: 'cmd-gemini',
args: ['/c', 'gemini', '--acp']
})
})
test('passes the command through unchanged on non-Windows', () => {
expect(resolvePlatformCommand('claude-agent-acp', ['--acp'], MAC_UA)).toEqual({
command: 'claude-agent-acp',
args: ['--acp']
})
})
test('defaults args to an empty array', () => {
expect(resolvePlatformCommand('openpencil-mcp-http', undefined, MAC_UA)).toEqual({
command: 'openpencil-mcp-http',
args: []
})
})
test('runs a program through a scope entry named apart from it', () => {
expect(resolveScopedCommand('agent-sign-in', 'agent', ['login'], WINDOWS_UA)).toEqual({
command: 'cmd-agent-sign-in',
args: ['/c', 'agent', 'login']
})
expect(resolveScopedCommand('agent-sign-in', 'agent', ['login'], MAC_UA)).toEqual({
command: 'agent-sign-in',
args: ['login']
})
})
test('passes through when the user agent is unavailable (headless/non-browser)', () => {
expect(resolvePlatformCommand('openpencil-mcp-http', ['--stdio'], '')).toEqual({
command: 'openpencil-mcp-http',
args: ['--stdio']
})
})
})
const shellScopeSchema = v.object({
permissions: v.array(
v.union([
v.string(),
v.object({
identifier: v.string(),
allow: v.optional(
v.array(
v.object({
name: v.optional(v.string()),
cmd: v.optional(v.string()),
args: v.optional(v.union([v.boolean(), v.array(v.unknown())]))
})
)
)
})
])
)
})
function spawnScope() {
const text = readFileSync(repoPath('desktop/capabilities/default.json'), 'utf8')
const capability = v.parse(v.pipe(v.string(), v.parseJson(), shellScopeSchema), text)
const spawn = capability.permissions.find(
(permission) => typeof permission !== 'string' && permission.identifier === 'shell:allow-spawn'
)
return typeof spawn === 'string' ? [] : (spawn?.allow ?? [])
}
/** The arguments a scope entry lets through for `args`, the way the shell plugin builds them. */
function allowedArgs(scope: boolean | unknown[] | undefined, args: string[]): unknown[] | null {
if (scope === false) return []
if (!Array.isArray(scope)) return null
return scope.map((allowed, index) => {
if (typeof allowed === 'string') return allowed
const validator = v.parse(v.object({ validator: v.string() }), allowed).validator
const value = args[index] ?? ''
return new RegExp(validator).test(value) ? value : { rejected: value }
})
}
const rootPackage = v.parse(
v.pipe(v.string(), v.parseJson(), v.object({ version: v.string() })),
readFileSync(repoPath('package.json'), 'utf8')
)
describe('shell scope', () => {
// Every program the app starts, with the arguments it starts it with.
// npm installs only these packages; a build pins the companions to the app's version, which
// tests stand in for with a placeholder the scope rightly refuses.
const installs = [
...ACP_AGENTS.flatMap((agent) => (agent.adapterPackage ? [agent.adapterPackage] : [])),
`${MCP_PACKAGE_NAME}@${rootPackage.version}`,
`${HARNESS_PACKAGE}@${rootPackage.version}`
]
// Agents' terminal sign-ins run the agent under a scope entry of their own.
const signIns = ACP_AGENTS.flatMap((agent): [string, string, string[]][] =>
agent.signIn?.via === 'terminal' ? [[signInScope(agent), agent.command, agent.signIn.args]] : []
)
const spawns: [string, string[]][] = [
...ACP_AGENTS.map((agent): [string, string[]] => [agent.command, agent.args]),
['openpencil-mcp-http', []],
['openpencil-harness', []],
...installs.map((target): [string, string[]] => ['npm', npmInstallArgs(target)]),
// Bun updates the companions it installed; agent adapters always come from npm.
...[
`${MCP_PACKAGE_NAME}@${rootPackage.version}`,
`${HARNESS_PACKAGE}@${rootPackage.version}`
].map((target): [string, string[]] => ['bun', bunInstallArgs(target)])
]
for (const userAgent of [WINDOWS_UA, MAC_UA]) {
for (const [name, args] of spawns) {
test(`allows exactly ${name} ${args.join(' ')} on ${userAgent === MAC_UA ? 'macOS' : 'Windows'}`, () => {
const resolved = resolvePlatformCommand(name, args, userAgent)
const entry = spawnScope().find((candidate) => candidate.name === resolved.command)
expect(entry?.cmd).toBe(userAgent === WINDOWS_UA ? 'cmd' : name)
expect(allowedArgs(entry?.args, resolved.args)).toEqual(resolved.args)
})
}
}
for (const userAgent of [WINDOWS_UA, MAC_UA]) {
for (const [scope, program, args] of signIns) {
test(`allows exactly ${program} ${args.join(' ')} as ${scope} on ${userAgent === MAC_UA ? 'macOS' : 'Windows'}`, () => {
const resolved = resolveScopedCommand(scope, program, args, userAgent)
const entry = spawnScope().find((candidate) => candidate.name === resolved.command)
expect(entry?.cmd).toBe(userAgent === WINDOWS_UA ? 'cmd' : program)
expect(allowedArgs(entry?.args, resolved.args)).toEqual(resolved.args)
})
}
}
test('allows nothing but those programs', () => {
const expected = [WINDOWS_UA, MAC_UA].flatMap((userAgent) => [
...spawns.map(([name, args]) => resolvePlatformCommand(name, args, userAgent).command),
...signIns.map(
([scope, program, args]) => resolveScopedCommand(scope, program, args, userAgent).command
)
])
expect(
spawnScope()
.map((entry) => entry.name)
.sort()
).toEqual([...new Set(expected)].sort())
})
test('lets npm install nothing but those packages', () => {
const validators = spawnScope().flatMap((entry) =>
Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg !== 'string') : []
)
expect(validators.length).toBeGreaterThan(0)
for (const validator of validators) {
const pattern = new RegExp(v.parse(v.object({ validator: v.string() }), validator).validator)
for (const target of [
'left-pad',
'@open-pencil/[email protected] & calc',
'@open-pencil/[email protected] & calc',
'@open-pencil/[email protected]',
'@open-pencil/mcp'
]) {
expect(pattern.test(target)).toBe(false)
}
}
})
test('lets npm install companions pinned to a stable or beta app version', () => {
for (const target of ['@open-pencil/[email protected]', '@open-pencil/[email protected]']) {
for (const userAgent of [WINDOWS_UA, MAC_UA]) {
const resolved = resolvePlatformCommand('npm', npmInstallArgs(target), userAgent)
const entry = spawnScope().find((candidate) => candidate.name === resolved.command)
expect(allowedArgs(entry?.args, resolved.args)).toEqual(resolved.args)
}
}
})
test('lets Bun install only the OpenPencil companions', () => {
for (const userAgent of [WINDOWS_UA, MAC_UA]) {
const allowed = resolvePlatformCommand(
'bun',
bunInstallArgs('@open-pencil/[email protected]'),
userAgent
)
const entry = spawnScope().find((candidate) => candidate.name === allowed.command)
expect(allowedArgs(entry?.args, allowed.args)).toEqual(allowed.args)
const adapter = resolvePlatformCommand(
'bun',
bunInstallArgs('@agentclientprotocol/claude-agent-acp'),
userAgent
)
expect(allowedArgs(entry?.args, adapter.args)).not.toEqual(adapter.args)
}
})
test('lets no program take arbitrary arguments', () => {
expect(spawnScope().filter((entry) => entry.args === true)).toEqual([])
})
})