slaunt 0.1.16 → 0.1.18

package/test/full-screen.test.js

@@ -0,0 +1,49 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {Writable,PassThrough}=require('node:stream');
+const {createFullScreen}=require('../src/full-screen');
+const {createTerminal,SPLASH_LOGO}=require('../src/tui');
+const {COMPACT_WORDMARK}=require('../src/compact-wordmark');
+function stream(columns,rows){let text='';const output=new Writable({write(chunk,_encoding,done){text+=chunk;done();}});output.isTTY=true;output.columns=columns;output.rows=rows;return {output,text:()=>text};}
+const initial={view:'select',selected:0,selection:null,completed:[],current:null,failure:null};
+test('large terminal layout centers a wide panel and shows the full logo',()=>{
+ const out=stream(160,60);const screen=createFullScreen({output:out.output,logo:SPLASH_LOGO,color:false,motion:false});screen.render(initial,true);
+ assert.match(out.text(),/\x1b\[\d+;23H╭─{114}╮/);assert.ok(out.text().includes(SPLASH_LOGO[7]));assert.match(out.text(),/Codex \+ Claude Code\s+RECOMMENDED/);
+ assert.doesNotMatch(out.text(),/│/);
+});
+test('selection animation changes frames while reduced motion stays static',()=>{
+ const animated=stream(100,40),still=stream(100,40);const moving=createFullScreen({output:animated.output,logo:SPLASH_LOGO,color:false,motion:true}),fixed=createFullScreen({output:still.output,logo:SPLASH_LOGO,color:false,motion:false});
+ for(let i=0;i<6;i++){moving.render(initial);fixed.render(initial);}
+ assert.match(animated.text(),/●  Codex/);assert.match(animated.text(),/◉  Codex/);assert.doesNotMatch(still.text(),/●  Codex/);
+});
+test('border stays steady across animated frames',()=>{
+ const out=stream(100,40);const screen=createFullScreen({output:out.output,logo:SPLASH_LOGO,color:true,motion:true});
+ for(let i=0;i<12;i++)screen.render(initial);
+ const borders=[...out.text().matchAll(/\x1b\[([\d;]+)m╭─+╮/g)].map(match=>match[1]);
+ assert.equal(borders.length,12);assert.deepEqual(new Set(borders),new Set(['2;36']));
+});
+test('compact screen uses the tight wordmark and a short legend',()=>{
+ const out=stream(50,24);const screen=createFullScreen({output:out.output,logo:SPLASH_LOGO,color:false,motion:false});screen.render(initial,true);
+ assert.ok(out.text().includes(COMPACT_WORDMARK[2]));assert.match(out.text(),/↑↓ move  ↵ select  esc/);assert.ok(!out.text().includes(SPLASH_LOGO[7]));
+});
+test('small terminals keep drawing within the available screen',()=>{
+ const out=stream(30,15);createFullScreen({output:out.output,logo:SPLASH_LOGO,color:false,motion:false}).render(initial,true);
+ for(const match of out.text().matchAll(/\x1b\[(\d+);(\d+)H/g)){assert.ok(+match[1]<=15);assert.ok(+match[2]<=30);}
+ assert.match(out.text(),/Choose clients/);
+});
+test('full screen animation stops after selection and restores the terminal',async()=>{
+ const out=stream(100,40),input=new PassThrough();input.isTTY=true;input.isRaw=false;input.setRawMode=value=>{input.isRaw=value;};
+ const terminal=createTerminal({input,output:out.output,error:out.output,env:{TERM:'xterm',NO_COLOR:'1'}});await terminal.enter();terminal.banner();
+ const selecting=terminal.selectClients();const before=out.text().length;await new Promise(r=>setTimeout(r,270));assert.ok(out.text().length>before);
+ input.emit('keypress','',{name:'return'});assert.equal(await selecting,'both');terminal.close();const end=out.text().length;await new Promise(r=>setTimeout(r,250));assert.equal(out.text().length,end);assert.equal(input.isRaw,false);
+});
+test('detected clients animate briefly and reduced motion remains static',()=>{
+ const moving=stream(100,40),still=stream(100,40);
+ const animated=createFullScreen({output:moving.output,logo:SPLASH_LOGO,color:false,motion:true});
+ const fixed=createFullScreen({output:still.output,logo:SPLASH_LOGO,color:false,motion:false});
+ const state={...initial,clientAvailability:{codex:'installed',claude:'missing'}};
+ for(let i=0;i<12;i++){animated.render(state);fixed.render(state);}
+ assert.match(moving.text(),/Codex  ✧ INSTALLED/);assert.match(moving.text(),/Codex  ✓ INSTALLED/);
+ assert.match(moving.text(),/Claude Code  · NOT FOUND/);assert.doesNotMatch(moving.text(),/Claude Code  [✧✦✓] INSTALLED/);
+ assert.match(still.text(),/Codex  ✓ INSTALLED/);assert.doesNotMatch(still.text(),/[✧✦]/);
+});

package/test/helper-release.test.js

@@ -0,0 +1,22 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
+const {prepareRelease}=require('../src/helper-release');
+const {verifyHelper}=require('../src/killbar-enrollment');
+
+test('packaged helper verifies after archive extraction', {skip:process.platform!=='darwin'||process.arch!=='arm64'}, async()=>{
+ const release=await prepareRelease();
+ try{await verifyHelper(release.app,release.team);}finally{await release.cleanup();}
+});
+test('modified archive is rejected before extraction',async()=>{
+ const dir=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-tampered-release-'));
+ try{
+  await fs.mkdir(path.join(dir,'src'));await fs.mkdir(path.join(dir,'release'));
+  await fs.copyFile(path.join(__dirname,'../src/helper-release.js'),path.join(dir,'src/helper-release.js'));
+  await fs.copyFile(path.join(__dirname,'../release/manifest.json'),path.join(dir,'release/manifest.json'));
+  await fs.writeFile(path.join(dir,'release/SlauntKillBar.zip'),'modified');
+  let executed=false;
+  await assert.rejects(require(path.join(dir,'src/helper-release.js')).prepareRelease({platform:'darwin',arch:'arm64',execute:async()=>{executed=true;}}),/killbar-release-untrusted/);
+  assert.equal(executed,false);
+ }finally{await fs.rm(dir,{recursive:true,force:true});}
+});

package/test/hidden-oauth.test.js

@@ -0,0 +1,44 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { PassThrough } = require('node:stream');
+const { EventEmitter } = require('node:events');
+const { validateRequest, validateCallback, runHiddenLogin } = require('../src/hidden-oauth');
+const issuer = 'https://example.test';
+const request = 'https://example.test/authorize?response_type=code&client_id=test&redirect_uri=http%3A%2F%2F127.0.0.1%3A1234%2Fcallback&state=xyz&code_challenge=abc&code_challenge_method=S256';
+test('validates authorization endpoint, PKCE and loopback callback', () => {
+  const r = validateRequest(request, issuer);
+  assert.equal(validateCallback('http://127.0.0.1:1234/callback?code=ok&state=xyz', r).includes('code=ok'), true);
+  assert.throws(() => validateCallback('http://127.0.0.1:1234/callback?code=ok&state=wrong', r));
+  assert.throws(() => validateRequest(request.replace('example.test','attacker.test'), issuer));
+  assert.throws(() => validateRequest(request.replace('127.0.0.1','example.com'), issuer));
+});
+test('passes a validated callback only to the native client', async () => {
+  const child = new EventEmitter(); child.stdin = new PassThrough(); child.stdout = new PassThrough(); child.stderr = new PassThrough(); child.kill = () => {};
+  let written = ''; child.stdin.on('data', x => { written += x; });
+  child.stdin.on('end', () => child.emit('close',0));
+  const running = runHiddenLogin({executable:'codex',issuer,spawnImpl:()=>child,authorize:async ()=>'http://127.0.0.1:1234/callback?code=ok&state=xyz'});
+  child.stdout.write('Open URL: ' + request + '\n');
+  await running; assert.match(written,/state=xyz/);
+});
+test('uses the detected absolute client path for native login', async () => {
+  const child = new EventEmitter(); child.stdin = new PassThrough(); child.stdout = new PassThrough(); child.stderr = new PassThrough(); child.kill = () => {};
+  child.stdin.on('end', () => child.emit('close',0)); child.stdin.resume();
+  let command;
+  const running=runHiddenLogin({executable:'codex',commandPath:'/Applications/ChatGPT.app/codex',issuer,spawnImpl:(cmd)=>{command=cmd;return child;},authorize:async()=> 'http://127.0.0.1:1234/callback?code=ok&state=xyz'});
+  child.stdout.write(request+'\n');await running;assert.equal(command,'/Applications/ChatGPT.app/codex');
+  await assert.rejects(runHiddenLogin({executable:'codex',commandPath:'../codex',issuer,authorize:async()=>{}}),/invalid-client-path/);
+});
+test('rejects callback with mismatched state', async () => {
+  const child = new EventEmitter(); child.stdin = new PassThrough(); child.stdout = new PassThrough(); child.stderr = new PassThrough(); child.kill = () => {};
+  const running = runHiddenLogin({executable:'claude',issuer,spawnImpl:()=>child,authorize:async ()=>'http://127.0.0.1:1234/callback?code=ok&state=bad'});
+  child.stdout.write(request + '\n');
+  await assert.rejects(running,/authorization-handoff-failed/);
+});
+
+test('does not report success when client exits before callback is supplied', async () => {
+  const child = new EventEmitter(); child.stdin = new PassThrough(); child.stdout = new PassThrough(); child.stderr = new PassThrough(); child.kill = () => {};
+  const running = runHiddenLogin({executable:'codex',issuer,spawnImpl:()=>child,authorize:()=>new Promise(()=>{})});
+  child.stdout.write(request + '\n'); child.emit('close',0);
+  await assert.rejects(running,/login-failed/);
+});

package/test/hook-installer.test.js

@@ -0,0 +1,232 @@
+'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 { onboardingCatalog } = require('../src/discovery/catalog');
+const {
+  SLAUNT_SERVER_NAME,
+  CLIENT_HOOK_TARGETS,
+  createClaudeCodeHooks,
+  createSlauntHooks,
+  installCodexHooks,
+  installClaudeCodeHooks,
+  installHooksForDetectedClients,
+  mergeSlauntHooks
+} = require('../src/setup/hook-installer');
+
+function makeTempHome() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'slaunt-hook-installer-'));
+  const homeDir = path.join(root, 'home');
+  fs.mkdirSync(homeDir);
+  return {
+    root,
+    homeDir,
+    configPath: path.join(homeDir, '.codex', 'hooks.json')
+  };
+}
+
+test('Codex hook payload uses Slaunt MCP and only sends metadata fields', () => {
+  const hooks = createSlauntHooks().hooks;
+  assert.deepEqual(Object.keys(hooks), [
+    'SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse',
+    'SubagentStart', 'SubagentStop', 'PreCompact', 'PostCompact', 'Stop', 'Interrupt'
+  ]);
+
+  const handlers = Object.values(hooks).flatMap((groups) => groups.flatMap((group) => group.hooks));
+  assert.ok(handlers.filter(hook => hook.type === 'mcp_tool').every(hook => hook.server === 'slaunt'));
+  assert.equal(hooks.PreToolUse[0].hooks[0].type, 'mcp_tool');
+  assert.equal(hooks.PreToolUse[0].hooks[0].tool, 'tool_authorize_codex');
+  assert.equal(hooks.PreToolUse[0].matcher, '*');
+  assert.equal(SLAUNT_SERVER_NAME, 'slaunt');
+
+  const inputKeys = handlers.flatMap((hook) => Object.keys(hook.input || {}));
+  assert.ok(!inputKeys.some((key) => /^(prompt|transcript|tool_input|tool_response)$/i.test(key)));
+  assert.ok(handlers.filter(hook => hook.type === 'mcp_tool').every(hook => ['codex_hook_event','tool_authorize_codex'].includes(hook.tool)));
+  assert.deepEqual(hooks.SessionStart[0].hooks[0].input, {
+    event_name: 'SessionStart', session_id: '${session_id}', model: '${model}'
+  });
+  assert.ok(handlers.filter(hook => hook.type === 'mcp_tool').every(hook => hook.input.session_id === '${session_id}'));
+});
+
+test('Claude Code hook payload uses supported metadata fields and avoids unavailable lifecycle events', () => {
+  const hooks = createClaudeCodeHooks().hooks;
+  const handlers = Object.values(hooks).flatMap((groups) => groups.flatMap((group) => group.hooks));
+  const sessionStart = hooks.SessionStart[0];
+
+  assert.equal(sessionStart.matcher, '^(clear|compact)$');
+  assert.ok(!Object.hasOwn(hooks, 'Interrupt'));
+  assert.equal(hooks.PreToolUse[0].hooks[0].onFailure, 'block');
+  assert.equal(createSlauntHooks().hooks.PreToolUse[0].hooks[0].onFailure, undefined);
+  assert.ok(handlers.filter(hook => hook.type === 'mcp_tool').every(hook => hook.server === 'slaunt'));
+  assert.ok(handlers.every((hook) => !Object.hasOwn(hook.input || {}, 'turn_id')));
+  assert.ok(handlers.some((hook) => hook.input?.tool_use_id === '${tool_use_id}'));
+});
+
+test('hook merge preserves unrelated handlers and upgrades prior Slaunt-managed server alias', () => {
+  const unrelated = { type: 'command', command: 'echo keep-me' };
+  const oldManagedHook = {
+    type: 'mcp_tool',
+    server: 'slaunt-2',
+    tool: 'codex_hook_event',
+    input: { event_name: 'Stop' }
+  };
+  const input = {
+    custom: true,
+    hooks: {
+      SessionStart: [{ hooks: [unrelated, {
+        type: 'mcp_tool', server: 'slaunt', tool: 'aki_workspace_context', input: { include_agents: true }
+      }] }],
+      Stop: [{ hooks: [unrelated, oldManagedHook] }]
+    }
+  };
+
+  const once = mergeSlauntHooks(input);
+  const twice = mergeSlauntHooks(once);
+  const allHandlers = Object.values(twice.hooks).flatMap((groups) => groups.flatMap((group) => group.hooks));
+
+  assert.equal(twice.custom, true);
+  assert.ok(allHandlers.includes(unrelated));
+  assert.equal(allHandlers.filter((hook) => hook.server === 'slaunt').length, 10);
+  assert.equal(allHandlers.filter((hook) => hook.tool === 'tool_authorize_codex').length, 1);
+  assert.ok(!allHandlers.some((hook) => hook.server === 'slaunt-2'));
+  assert.ok(!allHandlers.some((hook) => hook.tool === 'aki_workspace_context'));
+  assert.deepEqual(twice, once);
+});
+
+test('installer atomically writes a private Codex hooks file and is idempotent', () => {
+  const { root, homeDir, configPath } = makeTempHome();
+  try {
+    const first = installCodexHooks(homeDir);
+    const second = installCodexHooks(homeDir);
+    const saved = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+    assert.deepEqual(first, { status: 'installed' });
+    assert.deepEqual(second, { status: 'unchanged' });
+    assert.equal(fs.statSync(configPath).mode & 0o777, 0o600);
+    assert.equal(saved.hooks.SessionStart[0].hooks[0].server, 'slaunt');
+    assert.deepEqual(fs.readdirSync(path.dirname(configPath)), ['hooks.json']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('hook adapters use only the documented fixed config paths', () => {
+  assert.deepEqual(CLIENT_HOOK_TARGETS, {
+    'codex-mcp-tool': { directory: '.codex', file: 'hooks.json' },
+    'claude-mcp-tool': { directory: '.claude', file: 'settings.json' }
+  });
+});
+
+test('Claude Code hooks merge into user settings and report the lifecycle coverage as partial', () => {
+  const { root, homeDir } = makeTempHome();
+  const claudeConfig = path.join(homeDir, '.claude', 'settings.json');
+  fs.mkdirSync(path.dirname(claudeConfig), { recursive: true });
+  fs.writeFileSync(claudeConfig, JSON.stringify({ theme: 'dark', hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{type:'command',command:'echo keep'}] }] } }));
+  try {
+    const result = installClaudeCodeHooks(homeDir, fs, {versionProbe:()=>({status:0,stdout:'2.1.295 (Claude Code)'})});
+    const saved = JSON.parse(fs.readFileSync(claudeConfig, 'utf8'));
+    const handler = saved.hooks.SessionStart[0].hooks[0];
+
+    assert.deepEqual(result, { status: 'partial', reason: 'claude-lifecycle-differences' });
+    assert.equal(saved.theme, 'dark');
+    assert.equal(handler.server, 'slaunt');
+    assert.equal(handler.tool, 'slaunt_hook_event');
+    assert.equal(saved.hooks.PreToolUse[0].hooks[0].command, 'echo keep');
+    assert.equal(saved.hooks.PreToolUse[1].hooks[0].onFailure, 'block');
+    installClaudeCodeHooks(homeDir, fs, {versionProbe:()=>({status:0,stdout:'2.1.295 (Claude Code)'})});
+    assert.deepEqual(JSON.parse(fs.readFileSync(claudeConfig, 'utf8')),saved);
+    assert.equal(fs.statSync(claudeConfig).mode & 0o777, 0o600);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('older Claude versions are rejected before configuration changes', () => {
+  const {root,homeDir}=makeTempHome();
+  try {
+    assert.throws(()=>installClaudeCodeHooks(homeDir,fs,{versionProbe:()=>({status:0,stdout:'2.1.294 (Claude Code)'})}),/claude-version-unsupported/);
+    assert.equal(fs.existsSync(path.join(homeDir,'.claude')),false);
+  } finally { fs.rmSync(root,{recursive:true,force:true}); }
+});
+
+test('setup hooks target only Claude Code and Codex', () => {
+  const { root, homeDir, configPath } = makeTempHome();
+  try {
+    const detected = [
+      { id: 'codex-cli', surface: 'cli' },
+      { id: 'claude-code', surface: 'cli' },
+      { id: 'gemini-cli', surface: 'cli' },
+      { id: 'opencode', surface: 'cli' }
+    ];
+    const result = installHooksForDetectedClients({ clients: detected, homeDir, versionProbe:()=>({status:0,stdout:'2.1.295 (Claude Code)'}) });
+
+    assert.equal(result.serverName, 'slaunt');
+    assert.deepEqual(result.results.map(({ id, status }) => [id, status]), [
+      ['codex-cli', 'installed'],
+      ['claude-code', 'partial']
+    ]);
+    assert.equal(result.summary.detected, 2);
+    assert.equal(result.summary.installed, 1);
+    assert.equal(result.summary.partial, 1);
+    assert.equal(result.summary.unsupported, 0);
+    assert.ok(fs.existsSync(configPath));
+    assert.ok(fs.existsSync(path.join(homeDir, '.claude', 'settings.json')));
+    assert.deepEqual(fs.readdirSync(homeDir).sort(), ['.claude', '.codex']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('invalid existing config is preserved and reported rather than overwritten', () => {
+  const { root, homeDir, configPath } = makeTempHome();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, '{ invalid json');
+
+  try {
+    const result = installHooksForDetectedClients({
+      clients: [{ id: 'codex-cli', surface: 'cli' }],
+      homeDir
+    });
+
+    assert.equal(result.results[0].status, 'error');
+    assert.equal(result.results[0].reason, 'invalid-config-json');
+    assert.equal(fs.readFileSync(configPath, 'utf8'), '{ invalid json');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('symlinked Codex hook targets are rejected without modifying their destinations', () => {
+  const { root, homeDir, configPath } = makeTempHome();
+  const outsideConfig = path.join(root, 'outside-hooks.json');
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(outsideConfig, '{"keep":true}\n');
+  fs.symlinkSync(outsideConfig, configPath);
+
+  try {
+    const result = installHooksForDetectedClients({
+      clients: [{ id: 'codex-cli', surface: 'cli' }],
+      homeDir
+    });
+
+    assert.equal(result.results[0].status, 'error');
+    assert.equal(result.results[0].reason, 'unsafe-config-file');
+    assert.equal(fs.readFileSync(outsideConfig, 'utf8'), '{"keep":true}\n');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('clients outside the release catalog are ignored', () => {
+  const result = installHooksForDetectedClients({
+    clients: [{ id: 'unknown', surface: 'desktop' }],
+    homeDir: os.tmpdir()
+  });
+  assert.deepEqual(result.results, []);
+  assert.equal(result.summary.detected, 0);
+  assert.ok(onboardingCatalog.some((client) => client.id === 'codex-cli'));
+});

package/test/independent-grants.test.js

@@ -0,0 +1,16 @@
+'use strict';
+const test=require('node:test');const assert=require('node:assert/strict');const {createIndependentGrants}=require('../src/independent-grants');
+// Serializing test store only. A production store must be durable and encrypted.
+function makeStore(){let tail=Promise.resolve();const record={accessToken:'upstream-access',upstreamRefreshToken:'upstream-refresh',expiresAt:120000,grants:{}};return {transact:(_id,fn)=>{const next=tail.then(()=>fn(record));tail=next.catch(()=>{});return next;}};}
+test('independent client refresh grants survive concurrent refresh and rotate separately',async()=>{
+ let calls=0;let time=1000;const service=createIndependentGrants({store:makeStore(),now:()=>time,refreshUpstream:async value=>{calls++;assert.equal(value,'upstream-refresh');return {accessToken:'new-access',refreshToken:'new-upstream',expiresAt:180000};}});
+ const a=await service.issue({sessionId:'session',clientId:'codex'});const b=await service.issue({sessionId:'session',clientId:'claude'});assert.notEqual(a.refreshToken,b.refreshToken);
+ time=61000;const [aa,bb]=await Promise.all([service.refresh({sessionId:'session',clientId:'codex',refreshToken:a.refreshToken}),service.refresh({sessionId:'session',clientId:'claude',refreshToken:b.refreshToken})]);
+ assert.equal(calls,1);assert.notEqual(aa.refreshToken,bb.refreshToken);assert.equal(aa.accessToken,'new-access');assert.equal(bb.accessToken,'new-access');
+ await assert.rejects(service.refresh({sessionId:'session',clientId:'codex',refreshToken:a.refreshToken}),/invalid-grant/);
+ await assert.rejects(service.refresh({sessionId:'session',clientId:'codex',refreshToken:bb.refreshToken}),/invalid-grant/);
+});
+test('failed upstream refresh does not rotate downstream grant',async()=>{
+ let fail=true;let time=1000;const service=createIndependentGrants({store:makeStore(),now:()=>time,refreshUpstream:async()=>{if(fail)throw new Error('unavailable');return {accessToken:'a',refreshToken:'b',expiresAt:120000};}});
+ const grant=await service.issue({sessionId:'session',clientId:'codex'});time=61000;await assert.rejects(service.refresh({sessionId:'session',clientId:'codex',refreshToken:grant.refreshToken}));fail=false;assert.ok(await service.refresh({sessionId:'session',clientId:'codex',refreshToken:grant.refreshToken}));
+});

package/test/install-flow.test.js

@@ -0,0 +1,24 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {installFlow}=require('../src/install-flow');
+const identity={orgId:'11111111-1111-4111-8111-111111111111',projectId:'22222222-2222-4222-8222-222222222222'};
+function fixture() {
+ const events=[];
+ return {events,options:{clients:['codex','claude'],executablePaths:{codex:'/app/codex',claude:'/app/claude'},home:'/tmp',terminal:{progress(){},done(){}},release:()=>({app:'/tmp/SlauntKillBar.app',team:'ABCDEF1234',broker:{command:'/app/broker',args:['--slaunt-mcp-stdio']}}),verify:async()=>events.push('verify'),configure:({clientId})=>{events.push(clientId);return {status:'installed'};},enrollment:()=>async input=>{events.push('enroll');assert.deepEqual(input.identity,identity);return {enrolled:true};},keychain:()=>({async save(){events.push('grant');}}),startBroker:async()=>{events.push('broker');return {registered:true};},setup:async ({killbarEnrollment,brokerGrantSink})=>{events.push('oauth');await killbarEnrollment({accessToken:'secret',identity});await brokerGrantSink.save({});},readStatus:async()=>({enrolled:true,org_id:identity.orgId,project_id:identity.projectId}),background:async ({verifyEnrollment})=>{events.push('startup');assert.equal(await verifyEnrollment('/tmp/SlauntKillBar.app'),true);return {registered:true};},installHooks:()=>{events.push('hooks');return {summary:{detected:2,failed:0},results:[{status:'installed'},{status:'partial'}]};}}};
+}
+test('orchestrates verified helper, client setup, OAuth, enrollment, startup and hooks',async()=>{
+ const {options,events}=fixture();assert.deepEqual(await installFlow(options),{installed:true});assert.deepEqual(events,['verify','codex-cli','claude-code','oauth','enroll','grant','startup','broker','hooks']);
+});
+test('never reports success when startup fails',async()=>{
+ const {options,events}=fixture();options.background=async()=>{throw new Error('startup-failed');};
+ await assert.rejects(installFlow(options),error=>error.message==='startup-failed'&&error.setupMayHaveChanged);assert.ok(!events.includes('hooks'));
+});
+test('does not install hooks if the broker fails to start',async()=>{
+ const {options,events}=fixture();options.startBroker=async()=>{throw new Error('broker-start-unverified');};
+ await assert.rejects(installFlow(options),/broker-start-unverified/);assert.ok(!events.includes('hooks'));
+});
+test('identifies a client configuration conflict without exposing configuration contents',async()=>{
+ const {options,events}=fixture();options.configure=()=>({status:'conflict',reason:'server-name-conflict'});
+ await assert.rejects(installFlow(options),error=>error.message==='client-configuration-conflict'&&error.setupClient==='codex'&&!error.setupMayHaveChanged);
+ assert.ok(!events.includes('oauth'));
+});

package/test/killbar-background-install.test.js

@@ -0,0 +1,15 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
+const {installBackground}=require('../src/killbar-background-install');
+test('installer requires verified identity before any installation',async()=>{
+ const home=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-service-test-'));
+ try{await assert.rejects(installBackground({sourceApp:'/tmp/SlauntKillBar.app',home,platform:'darwin',verify:async()=>{}}),/identity-check-required/);assert.deepEqual(await fs.readdir(home),[]);}finally{await fs.rm(home,{recursive:true,force:true});}
+});
+test('installer preserves existing installation and does not start launchd',async()=>{
+ const home=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-service-test-'));let calls=[];
+ try{
+  await fs.mkdir(path.join(home,'Library/Application Support/Slaunt/KillBar'),{recursive:true,mode:0o700});
+  await assert.rejects(installBackground({sourceApp:'/tmp/SlauntKillBar.app',home,platform:'darwin',team:'ABCDEF1234',verify:async()=>{},verifyEnrollment:async()=>true,execute:async(command,args)=>{calls.push([command,args]);}}),/existing-install/);
+  assert.ok(!calls.some(([cmd])=>cmd==='/bin/launchctl'));
+ }finally{await fs.rm(home,{recursive:true,force:true});}
+});

package/test/killbar-enrollment.test.js

@@ -0,0 +1,115 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {createKillbarEnrollment}=require('../src/killbar-enrollment');
+const {runSetupFlow}=require('../src/setup-flow');
+const withLock=fn=>fn();
+const identity={orgId:'11111111-1111-4111-8111-111111111111',projectId:'22222222-2222-4222-8222-222222222222'};
+const identityResponse=()=>Response.json({org_id:identity.orgId,project_id:identity.projectId});
+test('verifies helper before handing off the access token',async()=>{
+ const events=[];let enrolled=false;const enroll=createKillbarEnrollment({withLock,app:'/a/SlauntKillBar.app',team:'ABCDEF1234',verify:async()=>events.push('verify'),readStatus:async()=>{events.push('status');return {enrolled,org_id:identity.orgId,project_id:identity.projectId};},invoke:async(binary,token)=>{events.push([binary,token]);enrolled=true;}});
+ assert.deepEqual(await enroll({accessToken:'access',identity}),{enrolled:true});assert.deepEqual(events,['verify','status',['/a/SlauntKillBar.app/Contents/MacOS/SlauntKillBar','access'],'status']);
+});
+test('rejects a persisted enrollment for another workspace',async()=>{
+ let reads=0;const enroll=createKillbarEnrollment({withLock,app:'/a/SlauntKillBar.app',verify:async()=>{},readStatus:async()=>++reads===1?{enrolled:false}:{enrolled:true,org_id:identity.orgId,project_id:'33333333-3333-4333-8333-333333333333'},invoke:async()=>{}});
+ await assert.rejects(enroll({accessToken:'access',identity}),/killbar-enrollment-unverified/);
+});
+test('a successful helper command without persistent enrollment is rejected',async()=>{
+ const enroll=createKillbarEnrollment({withLock,app:'/a/SlauntKillBar.app',team:'ABCDEF1234',verify:async()=>{},readStatus:async()=>({enrolled:false}),invoke:async()=>{}});
+ await assert.rejects(enroll({accessToken:'access',identity}),/killbar-enrollment-unverified/);
+});
+test('untrusted helper stops before token handoff',async()=>{
+ let called=false;const enroll=createKillbarEnrollment({withLock,verify:async()=>{throw new Error('untrusted');},invoke:async()=>{called=true;}});
+ await assert.rejects(enroll({accessToken:'access',identity}),/untrusted/);assert.equal(called,false);
+});
+test('one Slaunt sign-in enrolls KillBar and approves the native client cohort',async()=>{
+ const events=[];
+ await runSetupFlow({clients:['codex','claude'],issuer:'https://example.test',authenticate:async({sessionSink})=>{events.push('sign-in');await sessionSink.save({accessToken:'test-access',refreshToken:'test-refresh',setupTicket:'test-ticket'});},killbarEnrollment:async({accessToken})=>{assert.equal(accessToken,'test-access');events.push('enroll');return {enrolled:true};},login:async({executable,authorize})=>{const cb=await authorize({client:executable,authorizationUrl:'request'});assert.equal(cb,'callback');events.push(executable);},fetchImpl:async url=>{if(new URL(url).pathname==='/api/desktop/session')return identityResponse();events.push('approve');return new Response(JSON.stringify({callbacks:{codex:'callback',claude:'callback'}}),{status:200});}});
+ assert.deepEqual(events.slice(0,3),['sign-in','enroll','approve']);assert.deepEqual(events.slice(3).sort(),['claude','codex']);
+});
+test('missing or unconfirmed helper enrollment never approves client grants',async()=>{
+ let calls=0;
+ await assert.rejects(runSetupFlow({clients:['codex']}),/killbar-enrollment-required/);
+ await assert.rejects(runSetupFlow({clients:['codex'],issuer:'https://example.test',authenticate:async({sessionSink})=>sessionSink.save({accessToken:'a'}),killbarEnrollment:async()=>({enrolled:false}),login:async({authorize})=>authorize({client:'codex',authorizationUrl:'request'}),fetchImpl:async url=>{if(new URL(url).pathname==='/api/desktop/session')return identityResponse();calls++;}}),/cohort-failed/);
+ assert.equal(calls,0);
+});
+test('Claude broker grant is saved before the native callback is released',async()=>{
+ const events=[];let received;
+ await runSetupFlow({clients:['claude'],issuer:'https://example.test',authenticate:async({sessionSink})=>sessionSink.save({accessToken:'test-access',refreshToken:'test-refresh',setupTicket:'test-ticket'}),killbarEnrollment:async()=>({enrolled:true}),brokerGrantSink:{async save(grant){received=grant;events.push('saved');}},login:async({authorize})=>{await authorize({client:'claude',authorizationUrl:'request'});events.push('callback');},fetchImpl:async(url,options)=>{if(new URL(url).pathname==='/api/desktop/session')return identityResponse();assert.equal(JSON.parse(options.body).request_broker,true);return Response.json({callbacks:{claude:'callback'},broker:{access_token:'bg1.abc',refresh_token:'sg1.'+'a'.repeat(43),scope:'slaunt:guard',token_type:'Bearer',expires_in:300}});}});
+ assert.deepEqual(events,['saved','callback']);assert.equal(received.accessToken,'bg1.abc');
+});
+test('setup handoff retries an uncertain response with the same approval and requests',async()=>{
+ const bodies=[];
+ await runSetupFlow({clients:['codex'],issuer:'https://example.test',authenticate:async({sessionSink})=>sessionSink.save({accessToken:'access',refreshToken:'refresh',setupTicket:'ticket'}),killbarEnrollment:async()=>({enrolled:true}),login:async({authorize})=>authorize({client:'codex',authorizationUrl:'request'}),fetchImpl:async(url,options)=>{
+  if(new URL(url).pathname==='/api/desktop/session')return identityResponse();bodies.push(options.body);if(bodies.length===1)throw new Error('connection lost');return Response.json({callbacks:{codex:'callback'}});
+ }});
+ assert.equal(bodies.length,2);assert.equal(bodies[0],bodies[1]);
+});
+test('failed KillBar enrollment prevents native authorization',async()=>{
+ let calls=0;await assert.rejects(runSetupFlow({clients:['codex'],issuer:'https://example.test',authenticate:async({sessionSink})=>sessionSink.save({accessToken:'a'}),killbarEnrollment:async()=>{throw new Error('enrollment-failed');},login:async({authorize})=>authorize({client:'codex',authorizationUrl:'request'}),fetchImpl:async url=>{if(new URL(url).pathname==='/api/desktop/session')return identityResponse();calls++;}}),/cohort-failed/);assert.equal(calls,0);
+});
+test('missing authenticated workspace scope stops before helper enrollment',async()=>{
+ let enrolled=false,approvals=0;
+ await assert.rejects(runSetupFlow({clients:['codex'],issuer:'https://example.test',authenticate:async({sessionSink})=>sessionSink.save({accessToken:'a'}),killbarEnrollment:async()=>{enrolled=true;},login:async({authorize})=>authorize({client:'codex',authorizationUrl:'request'}),fetchImpl:async url=>{if(new URL(url).pathname==='/api/desktop/session')return Response.json({org_id:identity.orgId});approvals++;return Response.json({});}}),/cohort-failed/);
+ assert.equal(enrolled,false);assert.equal(approvals,0);
+});
+test('helper enrollment sends credentials only over stdin',async()=>{
+ const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');const {invokeHelper}=require('../src/killbar-enrollment');
+ const dir=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-enroll-test-'));const script=path.join(dir,'helper');
+ try{
+  await fs.writeFile(script,`#!/bin/sh\n[ "$1" = "--desktop-enroll-stdin" ] || exit 1\n[ "$#" = 1 ] || exit 1\nread -r input\n[ "$input" = '{"access_token":"test-token","org_id":"11111111-1111-4111-8111-111111111111","project_id":"22222222-2222-4222-8222-222222222222"}' ] || exit 1\nprintf '{"protocol_version":1,"enrolled":true}'\n`,{mode:0o700});
+  await invokeHelper(script,'test-token',identity);
+ }finally{await fs.rm(dir,{recursive:true,force:true});}
+});
+
+test('existing credentials or an old reporter prevent re-enrollment',async()=>{
+ for(const state of [{enrolled:true},{enrolled:false,requires_restart:true}]){
+  let called=false;const enroll=createKillbarEnrollment({withLock,app:'/a/SlauntKillBar.app',verify:async()=>{},readStatus:async()=>state,invoke:async()=>{called=true;}});
+  await assert.rejects(enroll({accessToken:'access',identity}),/killbar-(already-enrolled|restart-required)/);assert.equal(called,false);
+ }
+});
+test('unavailable status blocks token handoff',async()=>{
+ let called=false;const enroll=createKillbarEnrollment({withLock,app:'/a/SlauntKillBar.app',verify:async()=>{},readStatus:async()=>{throw new Error('killbar-status-unavailable');},invoke:async()=>{called=true;}});
+ await assert.rejects(enroll({accessToken:'access',identity}),/killbar-status-unavailable/);assert.equal(called,false);
+});
+
+test('concurrent CLI enrollments cannot both enter the critical section',async()=>{
+ const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');const {withEnrollmentLock}=require('../src/killbar-enrollment');
+ const home=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-lock-test-'));let release;let entered;const started=new Promise(r=>{entered=r;});
+ try{
+  const first=withEnrollmentLock(async()=>{entered();await new Promise(r=>{release=r;});},{home});await started;
+  await assert.rejects(withEnrollmentLock(async()=>{}, {home}),/killbar-enrollment-busy/);release();await first;
+  await withEnrollmentLock(async()=>{}, {home});
+ }finally{await fs.rm(home,{recursive:true,force:true});}
+});
+test('enrollment refuses a symlink lock directory',async()=>{
+ const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');const {withEnrollmentLock}=require('../src/killbar-enrollment');
+ const home=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-lock-test-'));
+ try{await fs.symlink(os.tmpdir(),path.join(home,'.slaunt'));await assert.rejects(withEnrollmentLock(async()=>{}, {home}),/killbar-lock-unavailable/);}
+ finally{await fs.rm(home,{recursive:true,force:true});}
+});
+test('enrollment lock excludes a separate process',async()=>{
+ const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path'),{spawn}=require('node:child_process');
+ const home=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-lock-process-'));
+ const modulePath=require.resolve('../src/killbar-enrollment');
+ const worker=`const {withEnrollmentLock}=require(process.argv[1]);withEnrollmentLock(async()=>{process.stdout.write('ready\\n');await new Promise(r=>process.stdin.once('data',r));},{home:process.argv[2]}).catch(()=>process.exit(1));`;
+ const child=spawn(process.execPath,['-e',worker,modulePath,home],{stdio:['pipe','pipe','ignore']});
+ try{
+  await new Promise((resolve,reject)=>{const timeout=setTimeout(()=>reject(new Error('worker timeout')),5000);child.once('error',reject);child.stdout.once('data',()=>{clearTimeout(timeout);resolve();});});
+  const {withEnrollmentLock}=require('../src/killbar-enrollment');
+  await assert.rejects(withEnrollmentLock(async()=>{}, {home}),/killbar-enrollment-busy/);
+  const exited=new Promise(resolve=>child.once('close',resolve));child.stdin.end('x');assert.equal(await exited,0);
+  await withEnrollmentLock(async()=>{}, {home});
+ }finally{child.kill();await fs.rm(home,{recursive:true,force:true});}
+});
+
+test('setup failures report only an allowlisted stage and never the underlying secret',async()=>{
+ for(const stage of ['sign-in','workspace','enrollment','client-grants']) {
+  const secret='private-token-should-not-appear';
+  await assert.rejects(runSetupFlow({clients:['codex'],issuer:'https://example.test',
+   authenticate:async({sessionSink})=>{if(stage==='sign-in')throw new Error(secret);await sessionSink.save({accessToken:'a'});},
+   killbarEnrollment:async()=>{if(stage==='enrollment')throw new Error(secret);return {enrolled:true};},
+   login:async({authorize})=>authorize({client:'codex',authorizationUrl:'request'}),
+   fetchImpl:async url=>{if(new URL(url).pathname==='/api/desktop/session'){if(stage==='workspace')throw new Error(secret);return identityResponse();}throw new Error(secret);}
+  }),error=>error.message==='cohort-failed'&&error.setupDetail===stage&&!JSON.stringify(error).includes(secret));
+ }
+});

package/test/killbar-launch-agent.test.js

@@ -0,0 +1,12 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {createLaunchAgentPlist,LABEL}=require('../src/killbar-launch-agent');
+test('launch agent starts the managed helper at login and restarts it on exit',()=>{
+ const xml=createLaunchAgentPlist({app:'/private/a & b/SlauntKillBar.app'});
+ assert.match(xml,new RegExp(`<key>Label</key><string>${LABEL}</string>`));
+ assert.match(xml,/<key>RunAtLoad<\/key><true\/>/);assert.match(xml,/<key>KeepAlive<\/key><true\/>/);
+ assert.match(xml,/a &amp; b\/SlauntKillBar.app\/Contents\/MacOS\/SlauntKillBar/);assert.match(xml,/<string>--desktop-managed<\/string>/);
+});
+test('launch agent rejects invalid paths and control characters',()=>{
+ for(const app of ['relative/SlauntKillBar.app','/tmp/other.app','/tmp/\n/SlauntKillBar.app'])assert.throws(()=>createLaunchAgentPlist({app}),/invalid-killbar-app/);
+});

package/test/killbar-portability.test.js

@@ -0,0 +1,17 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {test:probe,parseArgs}=require('../scripts/killbar-portability-check');
+test('portability probe requires absolute app path and explicit trusted team',()=>{
+ assert.throws(()=>parseArgs(['--app','relative','--team','ABCDEF1234']));
+ assert.throws(()=>parseArgs(['--app','/some/app','--team','invalid']));
+ assert.deepEqual(parseArgs(['--app','/some/app','--team','ABCDEF1234']),{app:'/some/app',team:'ABCDEF1234'});
+});
+test('portability probe refuses unsupported platforms',()=>{
+ const checks=probe({app:'/some/app',team:'ABCDEF1234'},{platform:'linux'});
+ assert.deepEqual(checks,[{name:'macOS platform',result:'FAIL'}]);
+});
+test('failed signature prevents execution and never reports overall success',()=>{
+ let calls=0;const checks=probe({app:'/some/app',team:'ABCDEF1234'},{platform:'darwin',runCommand(){calls++;throw new Error('untrusted');}});
+ assert.equal(calls,1);assert.equal(checks[0].result,'FAIL');
+ assert.ok(checks.some(c=>c.name==='Service starts after logout/login or restart'&&c.result==='NOT VERIFIED'));
+});

package/test/managed-policy.test.js

@@ -0,0 +1,18 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {parse}=require('smol-toml');
+const {createManagedPolicies,createCodexManagedPolicy}=require('../src/setup/managed-policy');
+const {claudeSupportsBlocking}=require('../src/setup/hook-installer');
+test('managed policies configure all-tool guards and block Claude hook failures',()=>{
+ const {codex,claude}=createManagedPolicies({managedDir:'/opt/slaunt/hooks',guardPath:'/opt/slaunt/hooks/guard',supervisorPath:'/opt/slaunt/hooks/supervisor.js',nodePath:'/usr/local/bin/node'});
+ const config=parse(codex);assert.equal(config.features.hooks,true);assert.equal(config.hooks.PreToolUse[0].matcher,'.*');assert.equal(config.hooks.PreToolUse[0].hooks[0].type,'mcp_tool');assert.equal(config.hooks.PreToolUse[0].hooks[0].tool,'tool_authorize_codex');
+ assert.deepEqual(parse(createCodexManagedPolicy()),config);
+ assert.equal(claude.hooks.PreToolUse[0].hooks[0].onFailure,'block');assert.equal(claude.hooks.PreToolUse[0].hooks[0].type,'command');
+});
+test('managed guard path cannot escape its administrator-protected directory',()=>{
+ for(const guardPath of ['/opt/slaunt/hooks/../evil','/tmp/evil','guard','/opt/slaunt/hooks2/guard','/opt/slaunt/hooks/x\nfoo']) assert.throws(()=>createManagedPolicies({managedDir:'/opt/slaunt/hooks',guardPath}),/invalid-managed-guard-path/);
+});
+test('Claude must support onFailure block',()=>{
+ for(const v of ['2.1.294 (Claude Code)','1.99.999','invalid',''])assert.equal(claudeSupportsBlocking(v),false);
+ for(const v of ['2.1.295 (Claude Code)','2.1.311 (Claude Code)','3.0.0'])assert.equal(claudeSupportsBlocking(v),true);
+});

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

@@ -0,0 +1,19 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
+const {createNativeClaudeBroker}=require('../src/desktop/native-claude-broker');
+const {authorizeHook}=require('../src/desktop/tool-guard');
+const input={hook_event_name:'PreToolUse',session_id:'session',tool_name:'Bash',tool_use_id:'call',tool_input:{command:'true'}};
+test('Claude broker forwards a bound allow and fails closed after stop or upstream denial',async()=>{
+ const root=await fs.mkdtemp('/tmp/sg-');let allow=true;
+ const client={async callTool({name,arguments:args}){if(name==='tool_authorize')return {structuredContent:{decision:allow?'allow':'deny',...Object.fromEntries(['request_id','tool_use_id','tool_name','input_sha256'].map(k=>[k,args[k]]))}};return {content:[]};}};
+ const broker=createNativeClaudeBroker({client,root});
+ try{
+  await broker.event({event_name:'UserPromptSubmit',session_id:'session'});
+  let result=await authorizeHook({input,clientKey:'claude-code',root});assert.equal(result.hookSpecificOutput.permissionDecision,undefined);
+  allow=false;result=await authorizeHook({input,clientKey:'claude-code',root});assert.equal(result.hookSpecificOutput.permissionDecision,'deny');
+  allow=true;await broker.event({event_name:'Stop',session_id:'session'});
+  result=await authorizeHook({input,clientKey:'claude-code',root});assert.equal(result.hookSpecificOutput.permissionDecision,'deny');
+ }finally{broker.close();await fs.rm(root,{recursive:true,force:true});}
+});
+test('broker requires a client connection',()=>assert.throws(()=>createNativeClaudeBroker(),/broker-connection-required/));