|
@@ -1,9 +1,11 @@
|
|
|
// @vitest-environment node
|
|
// @vitest-environment node
|
|
|
-import { afterEach, expect, it } from 'vitest'
|
|
|
|
|
|
|
+import { afterEach, expect, it, vi } from 'vitest'
|
|
|
import { mkdtempSync, readFileSync, readdirSync, rmSync } from 'node:fs'
|
|
import { mkdtempSync, readFileSync, readdirSync, rmSync } from 'node:fs'
|
|
|
import { join } from 'node:path'
|
|
import { join } from 'node:path'
|
|
|
import { tmpdir } from 'node:os'
|
|
import { tmpdir } from 'node:os'
|
|
|
|
|
+import { randomUUID } from 'node:crypto'
|
|
|
import { createCredentialVaultClient, LocalCredentialVaultClient } from '../../src/server/credentialVault/localClient'
|
|
import { createCredentialVaultClient, LocalCredentialVaultClient } from '../../src/server/credentialVault/localClient'
|
|
|
|
|
+import { sshFixture } from '../fixtures/credentialProtocols'
|
|
|
|
|
|
|
|
const homes: string[] = [], clients: LocalCredentialVaultClient[] = []
|
|
const homes: string[] = [], clients: LocalCredentialVaultClient[] = []
|
|
|
const session = 'a'.repeat(64), password = 'DUMMY-local-master-only', secret = 'DUMMY-local-website-secret'
|
|
const session = 'a'.repeat(64), password = 'DUMMY-local-master-only', secret = 'DUMMY-local-website-secret'
|
|
@@ -14,9 +16,9 @@ function client(home = mkdtempSync(join(tmpdir(), 'yaoyao-local-vault-'))) {
|
|
|
}
|
|
}
|
|
|
afterEach(async () => { clients.splice(0).forEach(c => c.close()); await Promise.resolve(); homes.splice(0).forEach(h => rmSync(h, { recursive: true, force: true })) })
|
|
afterEach(async () => { clients.splice(0).forEach(c => c.close()); await Promise.resolve(); homes.splice(0).forEach(h => rmSync(h, { recursive: true, force: true })) })
|
|
|
|
|
|
|
|
-it('provides encrypted local CRUD by default without an external service or Bot executor', async () => {
|
|
|
|
|
|
|
+it('provides encrypted local CRUD and bounded task execution by default without an external service', async () => {
|
|
|
const f = client()
|
|
const f = client()
|
|
|
- expect(await f.call('status')).toMatchObject({ online: true, initialized: false, unlocked: false, execution: 'disabled', storageMode: 'local' })
|
|
|
|
|
|
|
+ expect(await f.call('status')).toMatchObject({ online: true, initialized: false, unlocked: false, execution: 'local-adapters', reason: 'local_controlled', storageMode: 'local' })
|
|
|
await f.call('initialize', { password })
|
|
await f.call('initialize', { password })
|
|
|
await expect(f.call('add', {})).rejects.toMatchObject({ code: 'vault_locked' })
|
|
await expect(f.call('add', {})).rejects.toMatchObject({ code: 'vault_locked' })
|
|
|
await f.call('unlock', { password })
|
|
await f.call('unlock', { password })
|
|
@@ -25,13 +27,48 @@ it('provides encrypted local CRUD by default without an external service or Bot
|
|
|
const stored = readdirSync(join(f.home, 'credential-vault')).filter(name => name.endsWith('.vault')).map(name => readFileSync(join(f.home, 'credential-vault', name), 'utf8')).join('')
|
|
const stored = readdirSync(join(f.home, 'credential-vault')).filter(name => name.endsWith('.vault')).map(name => readFileSync(join(f.home, 'credential-vault', name), 'utf8')).join('')
|
|
|
expect(stored).not.toContain(secret); expect(stored).not.toContain(password); expect(stored).not.toContain('Dummy website')
|
|
expect(stored).not.toContain(secret); expect(stored).not.toContain(password); expect(stored).not.toContain('Dummy website')
|
|
|
expect((await f.call('status')).entries).toHaveLength(1)
|
|
expect((await f.call('status')).entries).toHaveLength(1)
|
|
|
- await expect(f.call('grant', {})).rejects.toMatchObject({ code: 'vault_executor_not_enabled' })
|
|
|
|
|
- await expect(f.call('execute', {})).rejects.toMatchObject({ code: 'vault_executor_not_enabled' })
|
|
|
|
|
|
|
+ await expect(f.call('read-secret', {id:entry.id})).rejects.toMatchObject({ code: 'vault_command_unknown' })
|
|
|
await f.call('update', { id: entry.id, entry: { name: 'Updated', username: 'dummy', target: entry.target, revision: entry.revision } })
|
|
await f.call('update', { id: entry.id, entry: { name: 'Updated', username: 'dummy', target: entry.target, revision: entry.revision } })
|
|
|
expect((await f.call('status')).entries[0].name).toBe('Updated')
|
|
expect((await f.call('status')).entries[0].name).toBe('Updated')
|
|
|
await f.call('remove', { id: entry.id }); expect((await f.call('status')).entries).toEqual([])
|
|
await f.call('remove', { id: entry.id }); expect((await f.call('status')).entries).toEqual([])
|
|
|
})
|
|
})
|
|
|
|
|
|
|
|
|
|
+it('binds one-use local execution to the owner and session and requires a configured usage policy',async()=>{
|
|
|
|
|
+ const f=client();await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ const entry=await f.call('add',{name:'Dummy',username:'dummy',target:{kind:'website',origin:'https://example.test'},secret})
|
|
|
|
|
+ const input={credentialRef:entry.id,agentId:randomUUID(),workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'website.login',target:entry.target,seconds:60}
|
|
|
|
|
+ const lease=await f.call('grant',input)
|
|
|
|
|
+ await expect(f.call('execute',{id:lease.id,input},'another-owner')).rejects.toMatchObject({code:'vault_lease_revoked'})
|
|
|
|
|
+ await expect(f.call('execute',{id:lease.id,input},'dummy-owner','b'.repeat(64))).rejects.toMatchObject({code:'vault_scope_forbidden'})
|
|
|
|
|
+ expect(await f.call('execute',{id:lease.id,input})).toEqual({status:'manual_takeover_required',reason:'usage_policy_required',submitted:false})
|
|
|
|
|
+ await expect(f.call('execute',{id:lease.id,input})).rejects.toMatchObject({code:'vault_lease_revoked'})
|
|
|
|
|
+})
|
|
|
|
|
+
|
|
|
|
|
+it('saves SSH offline, remembers the first host without authenticating, persists its pin and rejects a changed host before sending a password',async()=>{
|
|
|
|
|
+ const f=client();await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ let ssh=await sshFixture('password')
|
|
|
|
|
+ try{
|
|
|
|
|
+ const {hostKey:_initialKey,...target}=ssh.target
|
|
|
|
|
+ await ssh.close() // The server is actually offline while the password is saved.
|
|
|
|
|
+ const entry=await f.call('add',{name:'Dummy SSH',username:ssh.username,target,secret:ssh.secret,usage:{kind:'ssh.exec',command:'/usr/bin/uptime'}})
|
|
|
|
|
+ ssh=await sshFixture('password',target.port);const hostKey=ssh.target.hostKey
|
|
|
|
|
+ const input={credentialRef:entry.id,agentId:randomUUID(),workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target,seconds:60}
|
|
|
|
|
+ expect(ssh.state.authMethods).toEqual([])
|
|
|
|
|
+ await expect(f.call('grant',input)).rejects.toMatchObject({code:'vault_host_key_required'})
|
|
|
|
|
+ await expect(f.call('prepare-host',{id:entry.id,revision:entry.revision},'dummy-owner','b'.repeat(64))).rejects.toMatchObject({code:'vault_locked'})
|
|
|
|
|
+ const prepared=await f.call('prepare-host',{id:entry.id,revision:entry.revision})
|
|
|
|
|
+ expect(prepared.target.hostKey).toBe(hostKey);expect(ssh.state.authMethods).toEqual([])
|
|
|
|
|
+ await f.call('lock');await f.call('unlock',{password});expect((await f.call('status')).entries[0].target.hostKey).toBe(hostKey)
|
|
|
|
|
+ const port=target.port;await ssh.close();ssh=await sshFixture('password',port)
|
|
|
|
|
+ expect(ssh.target.hostKey).not.toBe(hostKey)
|
|
|
|
|
+ expect((await f.call('prepare-host',{id:entry.id,revision:prepared.revision})).target.hostKey).toBe(hostKey)
|
|
|
|
|
+ const bound={...input,target:prepared.target},lease=await f.call('grant',bound)
|
|
|
|
|
+ await expect(f.call('execute',{id:lease.id,input:bound})).rejects.toMatchObject({code:'vault_host_key_rejected'})
|
|
|
|
|
+ expect(ssh.state.authMethods).toEqual([]);expect(ssh.state.commands).toEqual([])
|
|
|
|
|
+ expect((await f.call('status')).entries[0].target.hostKey).toBe(hostKey)
|
|
|
|
|
+ }finally{await ssh.close()}
|
|
|
|
|
+},15000)
|
|
|
|
|
+
|
|
|
it('isolates accounts and login sessions and starts locked after a server restart', async () => {
|
|
it('isolates accounts and login sessions and starts locked after a server restart', async () => {
|
|
|
const f = client(); await f.call('initialize', { password }); await f.call('unlock', { password })
|
|
const f = client(); await f.call('initialize', { password }); await f.call('unlock', { password })
|
|
|
await f.call('add', { name: 'Dummy', username: 'dummy', target: { kind: 'website', origin: 'https://example.test' }, secret })
|
|
await f.call('add', { name: 'Dummy', username: 'dummy', target: { kind: 'website', origin: 'https://example.test' }, secret })
|
|
@@ -58,3 +95,164 @@ it('prevents concurrent brokers from writing the same local vault', async () =>
|
|
|
first.value.close(); await Promise.resolve()
|
|
first.value.close(); await Promise.resolve()
|
|
|
expect(await second.call('status')).toMatchObject({ initialized: true, unlocked: false })
|
|
expect(await second.call('status')).toMatchObject({ initialized: true, unlocked: false })
|
|
|
})
|
|
})
|
|
|
|
|
+
|
|
|
|
|
+it('keeps specified Bot approval across management lock and restart, without exposing secrets, and revokes it explicitly',async()=>{
|
|
|
|
|
+ const ssh=await sshFixture('password'),f=client(),agentId=randomUUID(),owner='dummy-owner'
|
|
|
|
|
+ const controller=new AbortController()
|
|
|
|
|
+ try{
|
|
|
|
|
+ await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ const {hostKey:_hostKey,...target}=ssh.target
|
|
|
|
|
+ const entry=await f.call('add',{name:'Dummy SSH',username:ssh.username,target,secret:ssh.secret,usage:{kind:'ssh.exec',command:'/usr/bin/uptime'}})
|
|
|
|
|
+ await expect(f.call('bot-grant',{credentialRef:entry.id,agentId},owner,'b'.repeat(64))).rejects.toMatchObject({code:'vault_locked'})
|
|
|
|
|
+ await f.call('bot-grant',{credentialRef:entry.id,agentId})
|
|
|
|
|
+ expect(ssh.state.authMethods).toEqual([])
|
|
|
|
|
+ await f.call('lock')
|
|
|
|
|
+ await expect(f.call('bot-grant',{credentialRef:entry.id,agentId})).rejects.toMatchObject({code:'vault_locked'})
|
|
|
|
|
+ const refs=await f.call('bot-refs',{agentId})
|
|
|
|
|
+ expect(refs).toHaveLength(1);expect(refs[0]).toMatchObject({credentialRef:entry.id,agentId,authorized:true,allowedTarget:target})
|
|
|
|
|
+ expect((await f.call('status')).unlocked).toBe(false)
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId:randomUUID()})).toEqual([])
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId},'other-owner')).toEqual([])
|
|
|
|
|
+ const input={credentialRef:entry.id,agentId,workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target,seconds:60}
|
|
|
|
|
+ await expect(f.value.executeBot('other-owner',input,controller.signal)).rejects.toMatchObject({code:'vault_bot_forbidden'})
|
|
|
|
|
+ await expect(f.value.executeBot(owner,{...input,agentId:randomUUID()},controller.signal)).rejects.toMatchObject({code:'vault_bot_forbidden'})
|
|
|
|
|
+ f.value.close();await Promise.resolve();const restarted=client(f.home)
|
|
|
|
|
+ expect(await restarted.call('status')).toMatchObject({unlocked:false,botGrants:[{credentialRef:entry.id,agentId}]})
|
|
|
|
|
+ expect(await restarted.value.executeBot(owner,input,controller.signal)).toEqual({status:'complete',operation:'ssh.exec',exitCode:0,stdout:'DUMMY-private-command-output',stderr:'DUMMY-private-stderr',truncated:false})
|
|
|
|
|
+ expect(ssh.state.commands).toEqual(['/usr/bin/uptime'])
|
|
|
|
|
+ const directory=join(f.home,'credential-vault','bot-access')
|
|
|
|
|
+ const disk=readdirSync(directory).map(n=>readFileSync(join(directory,n),'utf8')).join('')
|
|
|
|
|
+ for(const value of [ssh.secret,ssh.username,password,'Dummy SSH'])expect(disk).not.toContain(value)
|
|
|
|
|
+ const publicData=JSON.stringify([refs,(await restarted.call('status')).botGrants])
|
|
|
|
|
+ for(const value of [ssh.secret,ssh.username,password])expect(publicData).not.toContain(value)
|
|
|
|
|
+ await restarted.call('unlock',{password});await restarted.call('bot-revoke',{credentialRef:entry.id,agentId});await restarted.call('lock')
|
|
|
|
|
+ expect(await restarted.call('bot-refs',{agentId})).toEqual([])
|
|
|
|
|
+ await expect(restarted.value.executeBot(owner,input,controller.signal)).rejects.toMatchObject({code:'vault_bot_forbidden'})
|
|
|
|
|
+ }finally{await ssh.close()}
|
|
|
|
|
+},15000)
|
|
|
|
|
+
|
|
|
|
|
+it('management expiry and editing preserve Bot approval while deletion aborts in-flight use',async()=>{
|
|
|
|
|
+ const ssh=await sshFixture('password'),f=client(),agentId=randomUUID(),owner='dummy-owner'
|
|
|
|
|
+ try{
|
|
|
|
|
+ await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ const entry=await f.call('add',{name:'Dummy SSH',username:ssh.username,target:ssh.target,secret:ssh.secret,usage:{kind:'ssh.exec',command:'/usr/bin/uptime'}})
|
|
|
|
|
+ const grant={credentialRef:entry.id,agentId};await f.call('bot-grant',grant)
|
|
|
|
|
+ const broker=await (f.value as any).broker
|
|
|
|
|
+ const future=vi.spyOn(broker.store,'now').mockReturnValue(Date.now()+301000)
|
|
|
|
|
+ expect(await f.call('status')).toMatchObject({unlocked:false});expect(await f.call('bot-refs',{agentId})).toHaveLength(1);future.mockRestore()
|
|
|
|
|
+ await f.call('unlock',{password})
|
|
|
|
|
+ await f.call('update',{id:entry.id,entry:{name:'Updated',username:ssh.username,target:entry.target,revision:entry.revision}})
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId})).toMatchObject([{name:'Updated',authorized:true}])
|
|
|
|
|
+ await f.call('lock')
|
|
|
|
|
+ ssh.state.delayExec=true
|
|
|
|
|
+ const input={...grant,workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target:ssh.target,seconds:60}
|
|
|
|
|
+ const pending=f.value.executeBot(owner,input,new AbortController().signal),assertion=expect(pending).rejects.toMatchObject({code:'vault_operation_uncertain'})
|
|
|
|
|
+ await ssh.executed;await f.call('unlock',{password});await f.call('remove',{id:entry.id});await assertion
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId})).toEqual([])
|
|
|
|
|
+ }finally{vi.restoreAllMocks();await ssh.close()}
|
|
|
|
|
+},15000)
|
|
|
|
|
+
|
|
|
|
|
+it('keeps two Bots authorized when the SSH port changes offline, uses the new port after restart, and retains a learned pin on later edits',async()=>{
|
|
|
|
|
+ let ssh=await sshFixture('password');const second=await sshFixture('password'),f=client(),owner='dummy-owner',bots=[randomUUID(),randomUUID()]
|
|
|
|
|
+ try{
|
|
|
|
|
+ await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ let entry=await f.call('add',{name:'Dummy SSH',username:ssh.username,target:ssh.target,secret:ssh.secret,usage:{kind:'ssh.exec',command:'/usr/bin/uptime'}})
|
|
|
|
|
+ for(const agentId of bots)await f.call('bot-grant',{credentialRef:entry.id,agentId})
|
|
|
|
|
+ await expect(f.call('update',{id:entry.id,entry:{name:'Conflict',username:ssh.username,target:entry.target,revision:99}})).rejects.toMatchObject({code:'vault_revision_conflict'})
|
|
|
|
|
+ expect(await f.call('bot-refs')).toHaveLength(2)
|
|
|
|
|
+ const newPort=second.target.port;await second.close()
|
|
|
|
|
+ // An editor sends the existing pin; changing the endpoint discards that old pin.
|
|
|
|
|
+ entry=await f.call('update',{id:entry.id,entry:{name:'New port',username:ssh.username,target:{...entry.target,port:newPort},revision:entry.revision}})
|
|
|
|
|
+ expect(entry.target.hostKey).toBeUndefined()
|
|
|
|
|
+ await f.call('lock');f.value.close();await Promise.resolve();const restarted=client(f.home)
|
|
|
|
|
+ const input=(agentId:string,target:any)=>({credentialRef:entry.id,agentId,workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target,seconds:60})
|
|
|
|
|
+ expect((await restarted.call('status')).unlocked).toBe(false);expect((await restarted.call('status')).botGrants).toHaveLength(2)
|
|
|
|
|
+ // Server offline means connection failure, never an empty authorization list.
|
|
|
|
|
+ await expect(restarted.value.executeBot(owner,input(bots[0]!,entry.target),new AbortController().signal)).rejects.toMatchObject({code:'vault_host_probe_failed'})
|
|
|
|
|
+ expect(await restarted.call('bot-refs')).toHaveLength(2)
|
|
|
|
|
+ await ssh.close();ssh=await sshFixture('password',newPort)
|
|
|
|
|
+ for(const agentId of bots)expect(await restarted.value.executeBot(owner,input(agentId,entry.target),new AbortController().signal)).toMatchObject({status:'complete',exitCode:0})
|
|
|
|
|
+ expect(ssh.state.commands).toEqual(['/usr/bin/uptime','/usr/bin/uptime'])
|
|
|
|
|
+ await restarted.call('unlock',{password})
|
|
|
|
|
+ entry=await restarted.call('update',{id:entry.id,entry:{name:'Rename only',username:ssh.username,target:entry.target,revision:entry.revision}})
|
|
|
|
|
+ for(const agentId of bots)expect((await restarted.call('bot-refs',{agentId}))[0].allowedTarget.hostKey).toBe(ssh.target.hostKey)
|
|
|
|
|
+ await restarted.call('lock')
|
|
|
|
|
+ const port=ssh.target.port;await ssh.close();ssh=await sshFixture('password',port)
|
|
|
|
|
+ await expect(restarted.value.executeBot(owner,input(bots[0]!,entry.target),new AbortController().signal)).rejects.toMatchObject({code:'vault_host_key_rejected'})
|
|
|
|
|
+ expect(ssh.state.authMethods).toEqual([]);expect(await restarted.call('bot-refs')).toHaveLength(2)
|
|
|
|
|
+ }finally{await ssh.close()}
|
|
|
|
|
+},15000)
|
|
|
|
|
+
|
|
|
|
|
+it('updates cancel in-flight old operations without dropping approval for the next operation',async()=>{
|
|
|
|
|
+ const ssh=await sshFixture('password'),f=client(),agentId=randomUUID()
|
|
|
|
|
+ try{
|
|
|
|
|
+ await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ const entry=await f.call('add',{name:'Dummy SSH',username:ssh.username,target:ssh.target,secret:ssh.secret,usage:{kind:'ssh.exec',command:'/usr/bin/uptime'}})
|
|
|
|
|
+ await f.call('bot-grant',{credentialRef:entry.id,agentId});await f.call('lock');ssh.state.delayExec=true
|
|
|
|
|
+ const input={credentialRef:entry.id,agentId,workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target:ssh.target,seconds:60}
|
|
|
|
|
+ const pending=f.value.executeBot('dummy-owner',input,new AbortController().signal),assertion=expect(pending).rejects.toMatchObject({code:'vault_operation_uncertain'})
|
|
|
|
|
+ await ssh.executed;await f.call('unlock',{password})
|
|
|
|
|
+ await f.call('update',{id:entry.id,entry:{name:'New operation',username:ssh.username,target:ssh.target,revision:entry.revision,usage:{kind:'ssh.exec',command:'/usr/bin/true'}}})
|
|
|
|
|
+ await assertion;await f.call('lock');ssh.state.delayExec=false
|
|
|
|
|
+ expect(await f.value.executeBot('dummy-owner',input,new AbortController().signal)).toMatchObject({status:'complete',exitCode:0})
|
|
|
|
|
+ expect(ssh.state.commands).toEqual(['/usr/bin/uptime','/usr/bin/true'])
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId})).toMatchObject([{authorized:true,name:'New operation'}])
|
|
|
|
|
+ }finally{await ssh.close()}
|
|
|
|
|
+},15000)
|
|
|
|
|
+
|
|
|
|
|
+it.each(['password','privateKey'] as const)('supports autonomous SSH %s with arguments, pipelines, returned output and credential redaction only for an explicitly approved Bot',async auth=>{
|
|
|
|
|
+ const ssh=await sshFixture(auth),f=client(),ops=randomUUID(),restricted=randomUUID()
|
|
|
|
|
+ try{
|
|
|
|
|
+ await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ const entry=await f.call('add',{name:'SSH operations',username:ssh.username,target:ssh.target,secret:ssh.secret,usage:{kind:'ssh.exec',command:'/usr/bin/uptime'}})
|
|
|
|
|
+ await f.call('bot-grant',{credentialRef:entry.id,agentId:ops});await f.call('lock')
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId:ops})).toMatchObject([{operation:'ssh.exec',allowedUse:{kind:'ssh.exec',mode:'unrestricted'}}])
|
|
|
|
|
+ const input={credentialRef:entry.id,agentId:ops,workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target:ssh.target,command:'uname -s; printf "status\\n" | head -n 1',timeoutSeconds:30,seconds:60}
|
|
|
|
|
+ ssh.state.execReplies.set(input.command,{stdout:'Linux\nstatus\ncredential='+ssh.secret+'\n',stderr:'warning '+ssh.secret,exitCode:3})
|
|
|
|
|
+ await expect(f.value.executeBot('dummy-owner',{...input,agentId:restricted},new AbortController().signal)).rejects.toMatchObject({code:'vault_bot_forbidden'})
|
|
|
|
|
+ await expect(f.value.executeBot('other-owner',input,new AbortController().signal)).rejects.toMatchObject({code:'vault_bot_forbidden'})
|
|
|
|
|
+ expect(ssh.state.commands).toEqual([])
|
|
|
|
|
+ const result=await f.value.executeBot('dummy-owner',input,new AbortController().signal)
|
|
|
|
|
+ expect(result).toEqual({status:'complete',operation:'ssh.exec',exitCode:3,stdout:'Linux\nstatus\ncredential=[REDACTED]\n',stderr:'warning [REDACTED]',truncated:false})
|
|
|
|
|
+ expect(ssh.state.commands).toEqual([input.command]);expect(JSON.stringify(result)).not.toContain(ssh.secret)
|
|
|
|
|
+ const next=(result as any).stdout.includes('Linux')?'df -h /\nfree -m':'df -h /'
|
|
|
|
|
+ ssh.state.execReplies.set(next,{stdout:'Filesystem 40% used\nMem: available 4096\n',stderr:''})
|
|
|
|
|
+ expect(await f.value.executeBot('dummy-owner',{...input,command:next},new AbortController().signal)).toMatchObject({stdout:'Filesystem 40% used\nMem: available 4096\n',exitCode:0})
|
|
|
|
|
+ // Existing approval allows arbitrary commands before and after editing and restart.
|
|
|
|
|
+ await f.call('unlock',{password});await f.call('update',{id:entry.id,entry:{name:'Changed',username:ssh.username,target:ssh.target,revision:entry.revision}})
|
|
|
|
|
+ await f.call('lock');f.value.close();await Promise.resolve();const restarted=client(f.home)
|
|
|
|
|
+ expect(await restarted.call('bot-refs',{agentId:ops})).toMatchObject([{operation:'ssh.exec'}])
|
|
|
|
|
+ expect(await restarted.call('bot-refs',{agentId:restricted})).toEqual([])
|
|
|
|
|
+ expect(await restarted.value.executeBot('dummy-owner',{...input,command:next},new AbortController().signal)).toMatchObject({exitCode:0,stdout:'Filesystem 40% used\nMem: available 4096\n'})
|
|
|
|
|
+ await restarted.call('unlock',{password});await restarted.call('bot-revoke',{credentialRef:entry.id,agentId:ops});await restarted.call('lock')
|
|
|
|
|
+ await expect(restarted.value.executeBot('dummy-owner',input,new AbortController().signal)).rejects.toMatchObject({code:'vault_bot_forbidden'})
|
|
|
|
|
+ }finally{await ssh.close()}
|
|
|
|
|
+},15000)
|
|
|
|
|
+
|
|
|
|
|
+it('permits operations approval without a fixed plan, bounds output and time, and cancels on revocation',async()=>{
|
|
|
|
|
+ const ssh=await sshFixture('password'),f=client(),agentId=randomUUID()
|
|
|
|
|
+ try{
|
|
|
|
|
+ await f.call('initialize',{password});await f.call('unlock',{password})
|
|
|
|
|
+ const {hostKey:_pin,...target}=ssh.target
|
|
|
|
|
+ const entry=await f.call('add',{name:'SSH operations',username:ssh.username,target,secret:ssh.secret})
|
|
|
|
|
+ await f.call('bot-grant',{credentialRef:entry.id,agentId});await f.call('lock')
|
|
|
|
|
+ const input={credentialRef:entry.id,agentId,workId:randomUUID(),runnerId:randomUUID(),runnerInstance:randomUUID(),runnerEpoch:randomUUID(),operation:'ssh.exec',target,command:'cat diagnostic.log',timeoutSeconds:30,seconds:60}
|
|
|
|
|
+ const sensitive='x'.repeat(65530)+ssh.secret+'\n'+'y'.repeat(100000)
|
|
|
|
|
+ ssh.state.execReplies.set(input.command,{stdout:sensitive,stderr:'bounded stderr'})
|
|
|
|
|
+ const result=await f.value.executeBot('dummy-owner',input,new AbortController().signal) as any
|
|
|
|
|
+ expect(result).toMatchObject({status:'complete',truncated:true,exitCode:0});expect(Buffer.byteLength(result.stdout)+Buffer.byteLength(result.stderr)).toBeLessThanOrEqual(65536)
|
|
|
|
|
+ expect(result.stdout).not.toContain(ssh.secret);expect(result.stdout).not.toContain(ssh.secret.slice(0,5))
|
|
|
|
|
+ ssh.state.execReplies.set('unicode diagnostic',{stdout:'汉'.repeat(30000),stderr:''})
|
|
|
|
|
+ const unicode=await f.value.executeBot('dummy-owner',{...input,command:'unicode diagnostic'},new AbortController().signal) as any
|
|
|
|
|
+ expect(Buffer.byteLength(unicode.stdout)+Buffer.byteLength(unicode.stderr)).toBeLessThanOrEqual(65536);expect(unicode.stdout).not.toContain('�');expect(unicode.truncated).toBe(true)
|
|
|
|
|
+ await expect(f.value.executeBot('dummy-owner',{...input,command:'',timeoutSeconds:30},new AbortController().signal)).rejects.toMatchObject({code:'vault_invalid_request'})
|
|
|
|
|
+ await expect(f.value.executeBot('dummy-owner',{...input,timeoutSeconds:601},new AbortController().signal)).rejects.toMatchObject({code:'vault_invalid_request'})
|
|
|
|
|
+ ssh.state.delayExec=true
|
|
|
|
|
+ const timed=f.value.executeBot('dummy-owner',{...input,timeoutSeconds:1},new AbortController().signal)
|
|
|
|
|
+ await expect(timed).rejects.toMatchObject({code:'vault_operation_uncertain'})
|
|
|
|
|
+ const pending=f.value.executeBot('dummy-owner',input,new AbortController().signal),assertion=expect(pending).rejects.toMatchObject({code:'vault_operation_uncertain'})
|
|
|
|
|
+ await vi.waitFor(()=>expect(ssh.state.commands).toHaveLength(4))
|
|
|
|
|
+ await f.call('unlock',{password});await f.call('bot-revoke',{credentialRef:entry.id,agentId});await assertion
|
|
|
|
|
+ expect(await f.call('bot-refs',{agentId})).toEqual([])
|
|
|
|
|
+ }finally{await ssh.close()}
|
|
|
|
|
+},15000)
|