slaunt 0.1.16 → 0.1.18

package/test/native-claude-connection.test.js

@@ -0,0 +1,17 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {ENDPOINT,authorizedFetch,startNativeClaudeConnection}=require('../src/desktop/native-claude-connection');
+test('broker sends its own credential only to Central and retries one unauthorized response',async()=>{
+ const calls=[];const grantProvider={async getFreshTokens(){return {accessToken:'first'};},async refreshAfterUnauthorized(value){assert.equal(value,'first');return {accessToken:'second'};}};
+ const request=authorizedFetch({grantProvider,fetchImpl:async req=>{calls.push(req);return new Response('',{status:calls.length===1?401:200});}});
+ assert.equal((await request(ENDPOINT,{method:'POST',body:'{}'})).status,200);
+ assert.deepEqual(calls.map(r=>r.headers.get('authorization')),['Bearer first','Bearer second']);
+ assert.ok(calls.every(r=>r.headers.get('x-slaunt-client')==='claude-code'&&r.redirect==='error'));
+ await assert.rejects(request('https://example.com/mcp'),/broker-destination-invalid/);assert.equal(calls.length,2);
+});
+test('connection failure closes resources and does not start a guard',async()=>{
+ let clientClosed=false,transportClosed=false;
+ const grantProvider={async getFreshTokens(){return {accessToken:'token'};},async refreshAfterUnauthorized(){return {accessToken:'token'};}};
+ await assert.rejects(startNativeClaudeConnection({grantProvider,makeClient:()=>({async connect(){throw new Error('offline');},async close(){clientClosed=true;}}),makeTransport:()=>({async close(){transportClosed=true;}})}),/broker-connection-unavailable/);
+ assert.ok(clientClosed&&transportClosed);
+});

package/test/native-claude-hooks.test.js

@@ -0,0 +1,9 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {createClaudeCodeHooks,mergeSlauntHooks}=require('../src/setup/hook-installer');
+test('native Claude hooks connect lifecycle events to the persistent broker and block unavailable guards',()=>{
+ const config=createClaudeCodeHooks({nativeBroker:true,broker:{command:process.execPath,args:['--slaunt-mcp-stdio']}});
+ for(const event of ['SessionStart','UserPromptSubmit','Stop']){const hook=config.hooks[event][0].hooks[0];assert.equal(hook.type,'command');assert.match(hook.command,/broker-hook-command\.js/);assert.equal(hook.onFailure,'block');}
+ const guard=config.hooks.PreToolUse[0].hooks[0];assert.match(guard.command,/tool-guard-command\.js/);assert.equal(guard.onFailure,'block');
+ const merged=mergeSlauntHooks(config,config);assert.equal(merged.hooks.PreToolUse.length,1);assert.equal(merged.hooks.UserPromptSubmit.length,1);
+});

package/test/native-config.test.js

@@ -0,0 +1,3 @@
+'use strict';const test=require('node:test');const assert=require('node:assert/strict');const fs=require('node:fs');const os=require('node:os');const path=require('node:path');const {installNativeConfig,ENDPOINT}=require('../src/native-config');
+test('installs remote config for both clients and preserves unrelated settings',()=>{const home=fs.mkdtempSync(path.join(os.tmpdir(),'slaunt-native-config-'));try{fs.writeFileSync(path.join(home,'.claude.json'),'{"keep":true}');for(const clientId of ['codex-cli','claude-code']){assert.equal(installNativeConfig({clientId,homeDir:home}).status,'installed');assert.equal(installNativeConfig({clientId,homeDir:home}).status,'unchanged');}assert.equal(JSON.parse(fs.readFileSync(path.join(home,'.claude.json'))).keep,true);assert.match(fs.readFileSync(path.join(home,'.codex/config.toml'),'utf8'),new RegExp(ENDPOINT.replace(/[.*+?^${}()|[\]\\]/g,'\\$&')));}finally{fs.rmSync(home,{recursive:true,force:true});}});
+test('refuses an unrelated server under the same name',()=>{const home=fs.mkdtempSync(path.join(os.tmpdir(),'slaunt-native-config-'));try{fs.mkdirSync(path.join(home,'.codex'));fs.writeFileSync(path.join(home,'.codex/config.toml'),'[mcp_servers.slaunt]\ncommand="other"\n');assert.equal(installNativeConfig({clientId:'codex-cli',homeDir:home}).status,'conflict');}finally{fs.rmSync(home,{recursive:true,force:true});}});

package/test/native-integration.cjs

@@ -0,0 +1,29 @@
+'use strict';
+const http=require('node:http'),fs=require('node:fs'),os=require('node:os'),path=require('node:path'),cp=require('node:child_process'),crypto=require('node:crypto');
+const {runHiddenLogin}=require('../src/hidden-oauth');
+const {authorizeCohort}=require('../src/oauth-cohort');
+const {createApprovalManager}=require('../src/approval-manager');
+(async()=>{
+ const root=fs.mkdtempSync(path.join(os.tmpdir(),'slaunt-oauth-integration-'));
+ const expected=new Map();
+ const server=http.createServer(async(req,res)=>{
+  const base=`http://127.0.0.1:${server.address().port}`;
+  const json=(code,data)=>{res.writeHead(code,{'content-type':'application/json'});res.end(JSON.stringify(data));};
+  if(req.method==='GET'&&req.url.startsWith('/.well-known/oauth-protected-resource'))return json(200,{resource:base+'/mcp',authorization_servers:[base]});
+  if(req.method==='GET'&&(req.url.startsWith('/.well-known/oauth-authorization-server')||req.url.startsWith('/.well-known/openid-configuration')))return json(200,{issuer:base,authorization_endpoint:base+'/authorize',token_endpoint:base+'/token',registration_endpoint:base+'/register',response_types_supported:['code'],grant_types_supported:['authorization_code','refresh_token'],code_challenge_methods_supported:['S256'],token_endpoint_auth_methods_supported:['none'],scopes_supported:['mcp:tools']});
+  if(req.method==='POST'&&req.url==='/register'){let s='';for await(const c of req)s+=c;let j=JSON.parse(s);return json(201,{client_id:'test-client',redirect_uris:j.redirect_uris,token_endpoint_auth_method:'none'});}
+  if(req.method==='POST'&&req.url==='/token'){let s='';for await(const c of req)s+=c;let f=new URLSearchParams(s);let got=crypto.createHash('sha256').update(f.get('code_verifier')||'').digest('base64url');if(expected.get(f.get('code'))!==got)return json(400,{error:'invalid_grant'});expected.delete(f.get('code'));return json(200,{access_token:'test-access',refresh_token:crypto.randomBytes(24).toString('hex'),token_type:'Bearer',expires_in:3600,scope:'mcp:tools'});}
+  res.writeHead(401,{'www-authenticate':`Bearer resource_metadata="${base}/.well-known/oauth-protected-resource/mcp"`});res.end();
+ });
+ await new Promise(r=>server.listen(0,'127.0.0.1',r));const base=`http://127.0.0.1:${server.address().port}`;
+ const env={...process.env,CODEX_HOME:root+'/codex',HOME:root,CLAUDE_CONFIG_DIR:root+'/claude'};fs.mkdirSync(env.CODEX_HOME);fs.writeFileSync(env.CODEX_HOME+'/config.toml',`[mcp_servers.slaunt]\nurl = "${base}/mcp"\n`);
+ const add=cp.spawnSync('claude',['mcp','add','--scope','user','--transport','http','slaunt',base+'/mcp'],{env,stdio:'ignore',timeout:15000});
+ let failures=0, approvals=0;
+ if(add.status!==0){console.log('claude: configuration failed');failures++;}
+ else {
+  const manager=createApprovalManager({issuer:base,validateClient:async()=>true,issueCallback:async({request})=>{const code=crypto.randomBytes(18).toString('hex');expected.set(code,request.searchParams.get('code_challenge'));const cb=new URL(request.searchParams.get('redirect_uri'));cb.searchParams.set('code',code);cb.searchParams.set('state',request.searchParams.get('state'));return cb.toString();}});
+  try { await authorizeCohort({clients:['codex','claude'],issuer:base,timeoutMs:20000,login:opts=>runHiddenLogin({...opts,spawnImpl:(cmd,args,options)=>cp.spawn(cmd,args,{...options,env})}),approve:async requests=>{approvals++;const approval=await manager.create(requests);manager.approve({...approval,principal:'test-user',accepted:true});return manager.redeem(approval);}}); if(approvals!==1)throw new Error('approval-count');console.log('codex and claude: complete after one simulated approval'); }
+  catch(e){console.log('cohort: '+e.message);failures++;}
+ }
+ server.close();fs.rmSync(root,{recursive:true,force:true}); if (failures) process.exitCode=1;
+})().catch(()=>{console.error('integration test failed');process.exitCode=1});

package/test/native-oauth.test.js

@@ -0,0 +1,23 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { installOAuth, ENDPOINT } = require('../src/native-oauth');
+const output = { log(){}, error(){} };
+test('adds and authenticates each client through native OAuth', () => {
+  const calls=[];
+  const run=(exe,args) => { calls.push([exe,...args]); if(args[1]==='get') return {status:1}; return {status:0}; };
+  const results=installOAuth({clients:['codex','claude'],run,output});
+  assert.deepEqual(results.map(x=>x.status),['authenticated','authenticated']);
+  assert.ok(calls.some(x=>x.join(' ')===`codex mcp add slaunt --url ${ENDPOINT}`));
+  assert.ok(calls.some(x=>x.join(' ')==='claude mcp login slaunt'));
+});
+test('preserves a conflicting server and does not log in', () => {
+  const calls=[];
+  const run=(exe,args) => { calls.push(args); return {status:0,stdout:JSON.stringify({transport:{type:'stdio',command:'example'}})}; };
+  const results=installOAuth({clients:['codex'],run,output});
+  assert.equal(results[0].status,'conflict'); assert.equal(calls.length,1);
+});
+test('reuses a matching remote server and reports failed OAuth', () => {
+  const run=(exe,args) => args[1]==='get' ? {status:0,stdout:JSON.stringify({transport:{type:'streamable_http',url:ENDPOINT}})} : {status:1};
+  assert.equal(installOAuth({clients:['codex'],run,output})[0].status,'authentication-failed');
+});

package/test/oauth-cohort.test.js

@@ -0,0 +1,26 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { authorizeCohort } = require('../src/oauth-cohort');
+test('collects both client requests and asks for approval once', async () => {
+  let approvals = 0; const completed = [];
+  const login = async ({executable,authorize}) => { const cb = await authorize({client:executable,authorizationUrl:`request-${executable}`}); completed.push([executable,cb]); };
+  await authorizeCohort({clients:['codex','claude'],issuer:'https://example.test',login,approve:async requests => { approvals++; assert.deepEqual(requests.map(x=>x.client),['codex','claude']); return {codex:'callback-codex',claude:'callback-claude'}; }});
+  assert.equal(approvals,1); assert.deepEqual(completed,[['codex','callback-codex'],['claude','callback-claude']]);
+});
+test('rejects when approval is denied and does not complete either client', async () => {
+  let completed=0;
+  const login=async ({executable,authorize})=>{await authorize({client:executable,authorizationUrl:`request-${executable}`});completed++;};
+  await assert.rejects(authorizeCohort({clients:['codex','claude'],issuer:'https://example.test',login,approve:async()=>{throw new Error('denied');}}),/cohort-failed/);
+  assert.equal(completed,0);
+});
+test('fails closed if one client never produces a request', async () => {
+  let approvals=0;
+  const login=({executable,authorize})=>executable==='codex'?authorize({client:executable,authorizationUrl:'x'}):new Promise(()=>{});
+  await assert.rejects(authorizeCohort({clients:['codex','claude'],issuer:'https://example.test',login,timeoutMs:20,approve:async()=>{approvals++;}}),/cohort-failed/);
+  assert.equal(approvals,0);
+});
+test('identifies the failed native client without exposing its error text', async () => {
+  const login=async ({executable})=>{if(executable==='codex') throw new Error('sensitive details'); return new Promise(()=>{});};
+  await assert.rejects(authorizeCohort({clients:['codex','claude'],issuer:'https://example.test',login,approve:async()=>({})}),error=>error.message==='cohort-failed'&&error.setupStage==='native-login'&&error.setupClient==='codex'&&!JSON.stringify(error).includes('sensitive details'));
+});

package/test/tui.test.js

@@ -0,0 +1,100 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {PassThrough,Writable}=require('node:stream');
+const {createTerminal,SPLASH_LOGO}=require('../src/tui');
+const {COMPACT_WORDMARK}=require('../src/compact-wordmark');
+const {main}=require('../bin/slaunt-hooks');
+function stream(tty=false){let text='';const output=new Writable({write(chunk,_encoding,done){text+=chunk;done();}});output.isTTY=tty;return {output,text:()=>text};}
+function ttyInput(){const input=new PassThrough();input.isTTY=true;input.isRaw=false;input.setRawMode=value=>{input.isRaw=value;};return input;}
+test('interactive selector supports keyboard selection and restores terminal mode',async()=>{
+ const input=ttyInput(),out=stream(true);const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',NO_COLOR:'1',SLAUNT_REDUCED_MOTION:'1'}});
+ const selection=terminal.selectClients();input.emit('keypress','',{name:'down'});input.emit('keypress','',{name:'return'});assert.equal(await selection,'codex');assert.equal(input.isRaw,false);assert.match(out.text(),/Codex \+ Claude Code \(recommended\)/);assert.match(out.text(),/◇  Which clients/);assert.match(out.text(),/\x1b\[\?25h/);
+});
+test('CI defaults without prompting and reduced motion disables the spinner',async()=>{
+ const input=ttyInput(),out=stream(true);const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',CI:'1',NO_COLOR:'1'}});assert.equal(await terminal.selectClients(),'both');terminal.progress('Checking');terminal.done('Checked');assert.doesNotMatch(out.text(),/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);assert.equal(input.isRaw,false);
+});
+test('interactive selector cancels with control-c and restores terminal mode',async()=>{
+ const input=ttyInput(),out=stream(true);const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm'}});const selection=terminal.selectClients();input.emit('keypress','',{name:'c',ctrl:true});assert.equal(await selection,null);assert.equal(input.isRaw,false);
+});
+test('noninteractive terminal avoids control sequences',async()=>{
+ const out=stream(),err=stream();const terminal=createTerminal({input:new PassThrough(),output:out.output,error:err.output,env:{TERM:'dumb'}});await terminal.enter();terminal.banner();terminal.progress('Checking Slaunt');terminal.fail('Not ready','No settings changed.');terminal.close();assert.equal(await terminal.selectClients(),'both');assert.doesNotMatch(out.text()+err.text(),/\x1b/);
+});
+test('full screen uses alternate buffer, restores it and leaves a readable result',async()=>{
+ const input=ttyInput(),out=stream(true);const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',NO_COLOR:'1',SLAUNT_REDUCED_MOTION:'1'}});
+ await terminal.enter();terminal.banner();terminal.fail('Not ready','No settings changed.');terminal.close();terminal.close();
+ assert.match(out.text(),/\x1b\[\?1049h/);assert.match(out.text(),/\x1b\[\?1049l/);assert.match(out.text(),/Slaunt: Not ready\nNo settings changed/);assert.equal((out.text().match(/\x1b\[\?1049l/g)||[]).length,1);
+});
+test('splash uses the supplied ASCII art and animates a moving highlight',async()=>{
+ const input=ttyInput(),out=stream(true);out.output.columns=80;out.output.rows=24;
+ const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm'}});await terminal.enter();terminal.close();
+ assert.equal(SPLASH_LOGO.length,8);assert.equal(SPLASH_LOGO[0].trim(),' /$$                                 /$$'.trim());
+ assert.equal(SPLASH_LOGO[7],String.raw`|_______/ |__/ \_______/ \______/ |__/  |__/   \___/`);
+ assert.match(out.text(),/\x1b\[1;97m/);assert.ok((out.text().match(/\x1b\[1;97m/g)||[]).length>8);
+});
+test('reduced motion shows a static logo and small terminals use a compact fallback',async()=>{
+ const input=ttyInput(),out=stream(true);out.output.columns=80;out.output.rows=24;
+ const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',SLAUNT_REDUCED_MOTION:'1'}});await terminal.enter();terminal.close();
+ assert.ok(out.text().includes(SPLASH_LOGO[7]));assert.doesNotMatch(out.text(),/\x1b\[1;97m/);
+ const small=stream(true);small.output.columns=30;small.output.rows=12;
+ const compact=createTerminal({input:ttyInput(),output:small.output,error:small.output,env:{TERM:'xterm',SLAUNT_REDUCED_MOTION:'1'}});await compact.enter();compact.close();assert.match(small.text(),/SLAUNT/);assert.ok(!small.text().includes(SPLASH_LOGO[7]));
+ const medium=stream(true);medium.output.columns=45;medium.output.rows=20;
+ const tight=createTerminal({input:ttyInput(),output:medium.output,error:medium.output,env:{TERM:'xterm',SLAUNT_REDUCED_MOTION:'1'}});await tight.enter();tight.close();assert.ok(medium.text().includes(COMPACT_WORDMARK[2]));assert.ok(!medium.text().includes(SPLASH_LOGO[7]));
+});
+test('closing the full screen while selecting restores the raw terminal',async()=>{
+ const input=ttyInput(),out=stream(true);const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',SLAUNT_REDUCED_MOTION:'1'}});
+ await terminal.enter();const selection=terminal.selectClients();assert.equal(input.isRaw,true);terminal.close();assert.equal(input.isRaw,false);input.emit('keypress','',{name:'escape'});assert.equal(await selection,null);
+});
+test('resizing redraws the picker and keeps the selection',async()=>{
+ const input=ttyInput(),out=stream(true);out.output.columns=80;
+ const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',NO_COLOR:'1',SLAUNT_REDUCED_MOTION:'1'}});
+ await terminal.enter();const selection=terminal.selectClients();input.emit('keypress','',{name:'down'});out.output.columns=40;out.output.emit('resize');input.emit('keypress','',{name:'return'});
+ assert.equal(await selection,'codex');assert.match(out.text(),/Choose clients/);terminal.close();
+});
+test('installer restores the terminal when a client check throws',async()=>{
+ const input=ttyInput(),out=stream(true);const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',SLAUNT_REDUCED_MOTION:'1'}});
+ await assert.rejects(main(['install','--client','codex'],{terminal,env:{},probe:async()=>{throw new Error('probe failed');}}),/probe failed/);assert.match(out.text(),/\x1b\[\?1049l/);
+});
+test('installer shows unavailable status and never claims completion',async()=>{
+ const events=[];const terminal={banner(){events.push('banner');},progress(x){events.push(x);},done(x){events.push(x);},fail(x,d){events.push(x,d);},stop(){events.push('stop');},async selectClients(){return 'both';}};
+ const code=await main(['install'],{terminal,env:{},probe:async()=>true,fetch:async()=>new Response(JSON.stringify({issuer:'https://central-mcp-ccr-production.up.railway.app',slaunt_cli_setup_supported:false}),{status:200})});
+ assert.equal(code,1);assert.ok(events.includes('Setup is not yet enabled on Slaunt.'));assert.ok(events.includes('No client settings were changed.'));assert.ok(!events.some(x=>/installed|signed in/i.test(x)));
+});
+test('installer reports cancellation without checking clients or server',async()=>{
+ let calls=0;const terminal={banner(){},fail(){},async selectClients(){return null;}};
+ assert.equal(await main(['install'],{terminal,env:{},probe:async()=>{calls++;},fetch:async()=>{calls++;}}),130);assert.equal(calls,0);
+});
+test('explicit client invokes the installer with the resolved executable',async()=>{
+ const checked=[],events=[];const terminal={banner(){},progress(){},done(x){events.push(x);},fail(x){events.push(x);},stop(){},selectClients(){throw new Error('unexpected prompt');}};
+ let options;
+ const code=await main(['install','--client','codex'],{terminal,env:{},probe:async client=>{checked.push(client);return '/app/codex';},fetch:async()=>new Response(JSON.stringify({issuer:'https://central-mcp-ccr-production.up.railway.app',slaunt_cli_setup_supported:true}),{status:200}),installFlow:async input=>{options=input;return {installed:true};}});
+ assert.equal(code,0);assert.deepEqual(checked,['codex']);assert.deepEqual(options.clients,['codex']);assert.equal(options.executablePaths.codex,'/app/codex');
+});
+test('installer reports a missing packaged helper instead of success',async()=>{
+ const events=[];const terminal={banner(){},progress(){},done(){},fail(message){events.push(message);},stop(){}};
+ const code=await main(['install','--client','codex'],{terminal,env:{},probe:async()=>true,fetch:async()=>new Response(JSON.stringify({issuer:'https://central-mcp-ccr-production.up.railway.app',slaunt_cli_setup_supported:true})),installFlow:async()=>{throw new Error('killbar-release-missing');}});
+ assert.equal(code,1);assert.ok(events.includes('KillBar is missing from this installer.'));
+});
+test('picker discovers clients asynchronously and reuses selected checks',async()=>{
+ const events=[],calls=[];let select,resolveCodex,resolveClaude;
+ const terminal={interactive:true,banner(){},progress(){},done(){},fail(){},stop(){},close(){},setClientAvailability(client,state){events.push([client,state]);},selectClients(){return new Promise(r=>{select=r;});}};
+ const probe=client=>{calls.push(client);return new Promise(r=>{if(client==='codex')resolveCodex=r;else resolveClaude=r;});};
+ const run=main(['install'],{terminal,env:{},probe,fetch:async()=>new Response(JSON.stringify({issuer:'https://central-mcp-ccr-production.up.railway.app',slaunt_cli_setup_supported:false}))});
+ await new Promise(r=>setImmediate(r));assert.deepEqual(calls,['codex','claude']);assert.equal(typeof select,'function');
+ resolveCodex(true);resolveClaude(false);await new Promise(r=>setImmediate(r));
+ assert.ok(events.some(([c,s])=>c==='codex'&&s==='installed'));assert.ok(events.some(([c,s])=>c==='claude'&&s==='missing'));
+ select('codex');assert.equal(await run,1);assert.deepEqual(calls,['codex','claude']);
+});
+test('detects bundled macOS Codex when the terminal PATH does not include it',async()=>{
+ const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
+ const {checkClient,resolveClient}=require('../bin/slaunt-hooks');const dir=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-codex-probe-'));
+ try{
+  const bundled=path.join(dir,'codex');await fs.writeFile(bundled,'#!/bin/sh\nexit 0\n',{mode:0o700});
+  const options={env:{PATH:dir+'/empty'},platform:'darwin',appCodexPath:bundled};
+  assert.equal(await checkClient('codex',options),true);
+  assert.equal(await resolveClient('codex',options),bundled);
+  assert.equal(await checkClient('claude',options),false);
+  assert.equal(await checkClient('codex',{...options,platform:'linux'}),false);
+  await fs.writeFile(bundled,'#!/bin/sh\nexit 1\n',{mode:0o700});
+  assert.equal(await checkClient('codex',options),false);
+ }finally{await fs.rm(dir,{recursive:true,force:true});}
+});

package/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/dist/audit/risk-engine.d.ts

@@ -1,4 +0,0 @@
-import type { AuditSummary, ClassifiedTool, Finding, ServerConfig } from '../types.js';
-export declare function analyzeRisks(servers: ServerConfig[], tools: ClassifiedTool[]): Finding[];
-export declare function summarizeAudit(clientCount: number, serverCount: number, tools: ClassifiedTool[], findings: Finding[], serverBindings?: number): AuditSummary;
-//# sourceMappingURL=risk-engine.d.ts.map

package/dist/audit/risk-engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"risk-engine.d.ts","sourceRoot":"","sources":["../../src/audit/risk-engine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EAEZ,cAAc,EACd,OAAO,EACP,YAAY,EAEb,MAAM,aAAa,CAAC;AA8BrB,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,GAAG,OAAO,EAAE,CA8IxF;AAED,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,cAAc,EAAE,EACvB,QAAQ,EAAE,OAAO,EAAE,EACnB,cAAc,SAAc,GAC3B,YAAY,CAcd"}

package/dist/audit/risk-engine.js

@@ -1,174 +0,0 @@
-import { basename } from 'node:path';
-const SEVERITY_ORDER = { critical: 5, high: 4, medium: 3, low: 2, info: 1 };
-const SECRET_NAME = /(token|secret|password|private[_-]?key|credential|api[_-]?key)/i;
-function unique(items) {
-    return [...new Set(items)];
-}
-function toolCapabilities(tools) {
-    return new Set(tools.flatMap((tool) => tool.classification.capabilities));
-}
-function finding(partial) {
-    const id = `${partial.severity}:${partial.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')}`;
-    return { id, ...partial };
-}
-function isLocalHost(hostname) {
-    return ['localhost', '127.0.0.1', '::1'].includes(hostname);
-}
-function packageIsPinned(argument) {
-    const packagePart = argument.startsWith('@') ? argument.slice(argument.indexOf('/') + 1) : argument;
-    const at = packagePart.lastIndexOf('@');
-    if (at < 0)
-        return false;
-    const version = packagePart.slice(at + 1);
-    return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.test(version);
-}
-export function analyzeRisks(servers, tools) {
-    const findings = [];
-    for (const tool of tools.filter((item) => item.classification.capabilities.includes('deploy-production'))) {
-        findings.push(finding({
-            severity: 'critical',
-            title: `${tool.clientLabel} can deploy without an external approval boundary`,
-            serverNames: [tool.serverName],
-            toolNames: [tool.name],
-            access: ['Trigger production deployments'],
-            why: 'A production-changing capability is directly exposed to the agent.',
-            recommendation: 'Require a human approval policy and restrict deployment scope by environment.',
-            clients: [tool.client],
-        }));
-    }
-    for (const client of unique(tools.map((tool) => tool.client))) {
-        const clientTools = tools.filter((tool) => tool.client === client);
-        const capabilities = toolCapabilities(clientTools);
-        if (capabilities.has('execute-shell') && capabilities.has('read-secrets')) {
-            const label = clientTools[0]?.clientLabel || client;
-            findings.push(finding({
-                severity: 'high',
-                title: `${label} can execute shell commands and access secrets`,
-                serverNames: unique(clientTools
-                    .filter((tool) => tool.classification.capabilities.some((capability) => ['execute-shell', 'read-secrets'].includes(capability)))
-                    .map((tool) => tool.serverName)),
-                toolNames: unique(clientTools
-                    .filter((tool) => tool.classification.capabilities.some((capability) => ['execute-shell', 'read-secrets'].includes(capability)))
-                    .map((tool) => tool.name)),
-                access: ['Read credentials', 'Execute commands'],
-                why: 'These capabilities can be chained to disclose or misuse credentials.',
-                recommendation: 'Separate secret access from command execution and require approval for either boundary.',
-                clients: [client],
-            }));
-        }
-    }
-    const githubByClient = new Map();
-    for (const tool of tools.filter((item) => /github/i.test(item.serverName))) {
-        const list = githubByClient.get(tool.client) || [];
-        list.push(tool);
-        githubByClient.set(tool.client, list);
-    }
-    const broadGithubClients = [...githubByClient.entries()].filter(([, clientTools]) => {
-        const capabilities = toolCapabilities(clientTools);
-        return capabilities.has('edit-code') && capabilities.has('merge-pull-request');
-    });
-    if (broadGithubClients.length >= 2) {
-        findings.push(finding({
-            severity: 'high',
-            title: 'Detected clients share broad GitHub permissions',
-            serverNames: unique(broadGithubClients.flatMap(([, clientTools]) => clientTools.map((tool) => tool.serverName))),
-            toolNames: unique(broadGithubClients.flatMap(([, clientTools]) => clientTools.map((tool) => tool.name))),
-            access: ['Edit code', 'Create pull requests', 'Merge pull requests', 'Delete branches or files'],
-            why: 'Shared credentials erase role separation between agents.',
-            recommendation: 'Assign repository permissions and credentials by agent role.',
-            clients: broadGithubClients.map(([client]) => client),
-        }));
-    }
-    for (const server of servers) {
-        if (server.url) {
-            try {
-                const url = new URL(server.url);
-                if (url.protocol === 'http:' && !isLocalHost(url.hostname)) {
-                    findings.push(finding({
-                        severity: 'critical',
-                        title: `${server.clientLabel} sends MCP traffic over cleartext HTTP`,
-                        serverNames: [server.name],
-                        toolNames: [],
-                        access: ['MCP requests and responses can cross the network unencrypted'],
-                        why: 'A network observer could read or alter agent traffic.',
-                        recommendation: 'Use HTTPS with certificate verification before enabling this server.',
-                        clients: [server.client],
-                    }));
-                }
-            }
-            catch {
-                findings.push(finding({
-                    severity: 'high',
-                    title: `${server.clientLabel} has an invalid MCP server URL`,
-                    serverNames: [server.name],
-                    toolNames: [],
-                    access: [],
-                    why: 'The configured endpoint cannot be safely interpreted.',
-                    recommendation: 'Replace the endpoint with a reviewed HTTPS URL.',
-                    clients: [server.client],
-                }));
-            }
-        }
-        const inlineSecretKeys = server.envKeys.filter((key) => SECRET_NAME.test(key) && !/^\$\{.+\}$/u.test(server.env[key] || ''));
-        const hasSecretArgument = server.args.some((arg, index) => SECRET_NAME.test(arg) && (/[=:]/u.test(arg) || Boolean(server.args[index + 1] && !server.args[index + 1].startsWith('-'))));
-        if (inlineSecretKeys.length > 0 || hasSecretArgument) {
-            findings.push(finding({
-                severity: 'high',
-                title: `${server.clientLabel} stores credential material in an MCP configuration`,
-                serverNames: [server.name],
-                toolNames: [],
-                access: [...inlineSecretKeys.map((key) => `Environment key: ${key}`), ...(hasSecretArgument ? ['Credential-like command argument'] : [])],
-                why: 'Plaintext configuration values are exposed to local file readers and backups.',
-                recommendation: 'Reference a protected environment variable or operating-system credential store.',
-                clients: [server.client],
-            }));
-        }
-        const command = server.command ? basename(server.command).toLowerCase() : '';
-        if (['npx', 'pnpx', 'bunx'].includes(command)) {
-            const packageArg = server.args.find((arg) => !arg.startsWith('-'));
-            if (packageArg && !packageIsPinned(packageArg)) {
-                findings.push(finding({
-                    severity: 'medium',
-                    title: `${server.name} can resolve an unpinned package at startup`,
-                    serverNames: [server.name],
-                    toolNames: [],
-                    access: ['Execute package registry code'],
-                    why: 'The code executed by this server can change without a configuration change.',
-                    recommendation: 'Pin the package to an exact reviewed version and preserve the package-manager lock or integrity data.',
-                    clients: [server.client],
-                }));
-            }
-        }
-    }
-    const suspiciousUnknowns = tools.filter((item) => item.classification.source === 'unknown' && /admin|execute|trigger|workflow|sync/i.test(item.name));
-    if (suspiciousUnknowns.length > 0) {
-        findings.push(finding({
-            severity: 'medium',
-            title: `${suspiciousUnknowns.length} unclassified tools appear state-changing`,
-            serverNames: unique(suspiciousUnknowns.map((tool) => tool.serverName)),
-            toolNames: unique(suspiciousUnknowns.map((tool) => tool.name)),
-            access: ['Potential administrative or execution capability'],
-            why: 'No trusted rule explains tools whose names suggest privileged behavior.',
-            recommendation: 'Review and classify these tools before leaving them exposed to an agent.',
-            clients: unique(suspiciousUnknowns.map((tool) => tool.client)),
-        }));
-    }
-    const deduplicated = [...new Map(findings.map((item) => [`${item.id}:${item.clients.join(',')}:${item.serverNames.join(',')}`, item])).values()];
-    return deduplicated.sort((a, b) => SEVERITY_ORDER[b.severity] - SEVERITY_ORDER[a.severity] || a.title.localeCompare(b.title));
-}
-export function summarizeAudit(clientCount, serverCount, tools, findings, serverBindings = serverCount) {
-    const highRiskFindings = findings.filter((item) => item.severity === 'critical' || item.severity === 'high').length;
-    const penalty = findings.reduce((total, item) => total + ({ critical: 22, high: 12, medium: 5, low: 2, info: 0 }[item.severity]), 0);
-    return {
-        clientsDetected: clientCount,
-        servers: serverCount,
-        serverBindings,
-        tools: tools.length,
-        classified: tools.filter((tool) => tool.classification.source !== 'unknown').length,
-        sensitiveCapabilities: tools.filter((tool) => tool.classification.sensitive).length,
-        highRiskFindings,
-        unclassified: tools.filter((tool) => tool.classification.source === 'unknown').length,
-        postureScore: Math.max(0, 100 - penalty),
-    };
-}
-//# sourceMappingURL=risk-engine.js.map