slaunt 0.1.16 → 0.1.18

package/src/full-screen.js

@@ -0,0 +1,88 @@
+'use strict';
+const { COMPACT_WORDMARK } = require('./compact-wordmark');
+
+// Render into the alternate screen using cell-based dimensions. The terminal
+// controls font size; the layout expands and centers within available cells.
+function createFullScreen({output,logo,color,motion}) {
+  const style=(code,text)=>color?`\x1b[${code}m${text}\x1b[0m`:text;
+  const fit=(text,width)=>Array.from(text).slice(0,Math.max(0,width)).join('').padEnd(Math.max(0,width),' ');
+  const logoWidth=Math.max(...logo.map(line=>line.length));
+  let tick=0;
+  const previousAvailability={};
+  const appearedAt={};
+  function render({view,selected,selection,completed,current,failure,clientAvailability={}},clear=false){
+    for(const client of ['codex','claude']){
+      if(clientAvailability[client]==='installed' && previousAvailability[client]!=='installed') appearedAt[client]=tick;
+      previousAvailability[client]=clientAvailability[client];
+    }
+    const cols=Math.max(1,output.columns||80),rows=Math.max(1,output.rows||24);
+    const width=Math.min(116,Math.max(4,cols-4)),inner=width-2;
+    const rich=rows>=31&&cols>=60, spacious=rows>=24&&cols>=50;
+    const contents=[];
+    const add=(text='',tone='normal')=>contents.push({text,tone});
+    add('');
+    add(view==='select'?'   CONNECT YOUR CLIENTS':'   SETTING UP SLAUNT','heading');
+    add('');
+    if(view==='select'){
+      add(cols<52?'   Choose clients':'   Which clients would you like to connect?','title');
+      if(spacious)add('');
+      const entries=[['Codex + Claude Code','Connect both clients in one setup.'],['Codex','Connect Codex.'],['Claude Code','Connect Claude Code.']];
+      entries.forEach(([label,description],i)=>{
+        const marker=i===selected?(motion&&tick%8<4?'●':'◉'):'○';
+        const recommended=i===0&&width>=60?'   RECOMMENDED':'';
+        const client=i===1?'codex':i===2?'claude':null;
+        const status=client && clientAvailability[client];
+        const age=client ? tick-appearedAt[client] : 0;
+        const symbol=motion && age<8 ? ['✧','✦','✧','✓'][Math.floor(age/2)] : '✓';
+        const badge=status==='installed'?(width<42?`  ${symbol}`:`  ${symbol} INSTALLED`):status==='checking'?(width<42?'  …':'  · CHECKING'):status==='missing'?(width<42?'  ×':'  · NOT FOUND'):'';
+        add(`   ${marker}  ${label}${recommended}${badge}`,i===selected?'selected':'normal');
+        if(spacious)add(`      ${description}`,'muted');
+        if(rich&&i<2)add('');
+      });
+      if(spacious)add('');
+      add('   ↑↓ move  ↵ select  esc','muted');
+    } else {
+      add(`   ${selection||'Preparing your setup'}`,'title');
+      add('');
+      for(const item of completed.slice(-4))add(`   ✓  ${item}`,'success');
+      if(current)add(`   ${motion?'⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'[tick%10]:'…'}  ${current}`,'selected');
+      if(failure){add(`   !  ${failure.message}`,'warning');if(failure.detail)add(`      ${failure.detail}`,'muted');}
+      if(!current&&!failure&&completed.length===0)add('   Getting things ready…','muted');
+      if(spacious)add('');
+      add('   Slaunt setup','muted');
+    }
+    if(rich)add('');
+    const borderTop='╭'+'─'.repeat(Math.max(0,inner))+'╮',borderBottom='╰'+'─'.repeat(Math.max(0,inner))+'╯';
+    const panel=[{text:borderTop,tone:'border'},...contents.map(item=>({text:' '+fit(item.text,inner)+' ',tone:item.tone})),{text:borderBottom,tone:'border'}];
+    const compactWidth=Math.max(...COMPACT_WORDMARK.map(line=>line.length));
+    const header=rich ? logo : cols>=compactWidth && rows>=panel.length+COMPACT_WORDMARK.length+2
+      ? COMPACT_WORDMARK : rows>=panel.length+3 ? ['slaunt'] : [];
+    const total=header.length+(header.length?2:0)+panel.length;
+    const start=Math.max(1,Math.floor((rows-total)/2)+1);
+    const left=Math.max(1,Math.floor((cols-width)/2)+1);
+    if(clear)output.write('\x1b[2J');
+    if(header.length){
+      const headerWidth=Math.max(...header.map(line=>line.length));
+      const logoLeft=Math.max(1,Math.floor((cols-headerWidth)/2)+1);
+      header.forEach((line,index)=>{
+        if(start+index>rows)return;
+        let rendered=style(rich ? (motion&&tick%12<6?'36':'96') : '1;97',line);
+        if(rich&&motion&&color){
+          const beam=(tick*3)%(logoWidth+12)-6;let run='',bright=false;rendered='';
+          [...line].forEach((char,x)=>{const next=char!==' '&&Math.abs(x-index*.7-beam)<3;if(run&&next!==bright){rendered+=style(bright?'1;97':'2;36',run);run='';}bright=next;run+=char;});
+          if(run)rendered+=style(bright?'1;97':'2;36',run);
+        }
+        output.write(`\x1b[${start+index};${logoLeft}H${rendered}`);
+      });
+    }
+    const panelTop=start+header.length+(header.length?2:0);
+    panel.forEach(({text,tone},index)=>{
+      const y=panelTop+index;if(y>rows)return;
+      let code=tone==='selected'?'1;96':tone==='title'?'1':tone==='heading'?'1;36':tone==='success'?'32':tone==='warning'?'33':tone==='muted'?'2':tone==='border'?'2;36':'0';
+      output.write(`\x1b[${y};${left}H${style(code,text)}`);
+    });
+    tick++;
+  }
+  return {render};
+}
+module.exports={createFullScreen};

package/src/helper-release.js

@@ -0,0 +1,27 @@
+'use strict';
+const fs=require('node:fs/promises');
+const os=require('node:os');
+const path=require('node:path');
+const crypto=require('node:crypto');
+const {execFile}=require('node:child_process');
+const {promisify}=require('node:util');
+const exec=promisify(execFile);
+
+async function prepareRelease({platform=process.platform,arch=process.arch,execute=exec}={}) {
+  let manifest;
+  try {manifest=require('../release/manifest.json');} catch {throw new Error('killbar-release-missing');}
+  if(platform!=='darwin'||arch!==manifest.arch)throw new Error('killbar-platform-unsupported');
+  if(manifest.format!==1||manifest.signing!=='adhoc'||!/^[a-f0-9]{64}$/.test(manifest.sha256||'')||!/^[a-f0-9]{40}$/.test(manifest.cdhash||''))throw new Error('killbar-release-unavailable');
+  const archive=path.resolve(__dirname,'../release/SlauntKillBar.zip');
+  let bytes;try{bytes=await fs.readFile(archive);}catch{throw new Error('killbar-release-missing');}
+  if(crypto.createHash('sha256').update(bytes).digest('hex')!==manifest.sha256)throw new Error('killbar-release-untrusted');
+  const dir=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-helper-'));
+  try {
+    // Extract the bytes we actually verified, from an owner-only directory.
+    const copy=path.join(dir,'helper.zip');await fs.writeFile(copy,bytes,{mode:0o600,flag:'wx'});
+    await execute('/usr/bin/ditto',['-x','-k',copy,dir],{timeout:60000});
+    await fs.unlink(copy);
+    return {app:path.join(dir,'SlauntKillBar.app'),team:{mode:'adhoc',cdhash:manifest.cdhash},cleanup:()=>fs.rm(dir,{recursive:true,force:true})};
+  } catch {await fs.rm(dir,{recursive:true,force:true});throw new Error('killbar-release-untrusted');}
+}
+module.exports={prepareRelease};

package/src/hidden-oauth.js

@@ -0,0 +1,70 @@
+'use strict';
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const MAX_OUTPUT = 65536;
+function validateRequest(raw, issuer) {
+  const url = new URL(raw);
+  const expected = new URL('/authorize', issuer);
+  if (expected.protocol !== 'https:' && !(expected.protocol === 'http:' && ['127.0.0.1','localhost','[::1]'].includes(expected.hostname))) throw new Error('unsafe-issuer');
+  if (url.origin !== expected.origin || url.pathname !== expected.pathname || url.username || url.password || url.hash) throw new Error('unexpected-authorization-endpoint');
+  for (const name of ['state','client_id','redirect_uri','code_challenge','code_challenge_method','response_type']) {
+    if (url.searchParams.getAll(name).length !== 1 || !url.searchParams.get(name)) throw new Error('invalid-authorization-request');
+  }
+  if (url.searchParams.get('code_challenge_method') !== 'S256' || url.searchParams.get('response_type') !== 'code') throw new Error('invalid-authorization-request');
+  const redirect = new URL(url.searchParams.get('redirect_uri'));
+  if (redirect.protocol !== 'http:' || !['127.0.0.1','localhost','[::1]'].includes(redirect.hostname) || redirect.username || redirect.password || redirect.hash) throw new Error('unsafe-redirect');
+  return { url, redirect, state: url.searchParams.get('state') };
+}
+function validateCallback(raw, request) {
+  const url = new URL(raw);
+  const expected = request.redirect;
+  if (url.origin !== expected.origin || url.pathname !== expected.pathname || url.hash || url.username || url.password) throw new Error('callback-mismatch');
+  for (const [key,value] of expected.searchParams) if (url.searchParams.getAll(key).length !== 1 || url.searchParams.get(key) !== value) throw new Error('callback-mismatch');
+  if (url.searchParams.getAll('state').length !== 1 || url.searchParams.get('state') !== request.state || url.searchParams.getAll('code').length !== 1 || !url.searchParams.get('code') || url.searchParams.has('error')) throw new Error('invalid-callback');
+  return url.toString();
+}
+async function runHiddenLogin({ executable, commandPath = executable, issuer, authorize, timeoutMs = 120000, spawnImpl = spawn, signal }) {
+  if (!['codex','claude'].includes(executable) || typeof authorize !== 'function') throw new Error('invalid-client');
+  if (typeof commandPath !== 'string' || !commandPath || /[\x00-\x1f\x7f]/.test(commandPath) || (commandPath !== executable && !path.isAbsolute(commandPath))) throw new Error('invalid-client-path');
+  const args = ['mcp','login','slaunt','--no-browser'];
+  // Claude requires an interactive terminal even when the callback is supplied programmatically.
+  const command = executable === 'claude' ? 'python3' : commandPath;
+  const commandArgs = executable === 'claude' ? [path.join(__dirname, 'pty-wrapper.py'), commandPath, ...args] : args;
+  const child = spawnImpl(command, commandArgs, { stdio:['pipe','pipe','pipe'] });
+  let settled = false, text = '', found = false, submitted = false, timer;
+  const result = new Promise((resolve, reject) => {
+    const onAbort = () => finish(new Error('login-cancelled'));
+    const finish = (err) => { if (settled) return; settled = true; clearTimeout(timer); signal?.removeEventListener('abort', onAbort); if (err) { child.kill(); reject(err); } else resolve(); };
+    if (signal?.aborted) { finish(new Error('login-cancelled')); return; }
+    signal?.addEventListener('abort', onAbort, { once: true });
+    child.stdin.on('error', () => finish(new Error('login-input-failed')));
+    timer = setTimeout(() => finish(new Error('login-timeout')), timeoutMs);
+    child.on('error', () => finish(new Error('client-start-failed')));
+    child.on('close', code => finish(code === 0 && submitted ? null : new Error('login-failed')));
+    const receive = chunk => {
+      if (settled || found) return;
+      text += chunk.toString('utf8');
+      if (Buffer.byteLength(text) > MAX_OUTPUT) return finish(new Error('client-output-too-large'));
+      // Wait for a line terminator so partial stream chunks cannot truncate a URL.
+      const lines = text.split(/\r?\n/); text = lines.pop();
+      for (const line of lines) {
+        const candidate = line.match(/https?:\/\/[^\s<>"'\x00-\x1f\x7f]+/)?.[0];
+        if (!candidate) continue;
+        let request;
+        try { request = validateRequest(candidate, issuer); } catch { continue; }
+        found = true;
+        Promise.resolve().then(() => authorize({client: executable, authorizationUrl: request.url.toString()})).then(callback => {
+          if (settled) return;
+          const validated = validateCallback(callback, request);
+          submitted = true;
+          child.stdin.write(validated + '\n');
+          child.stdin.end();
+        }).catch(() => finish(new Error('authorization-handoff-failed')));
+        break;
+      }
+    };
+    child.stdout.on('data', receive); child.stderr.on('data', receive);
+  });
+  return result;
+}
+module.exports = { validateRequest, validateCallback, runHiddenLogin };

package/src/independent-grants.js

@@ -0,0 +1,38 @@
+'use strict';
+const crypto = require('node:crypto');
+const digest = value => crypto.createHash('sha256').update(value).digest('hex');
+const newToken = () => crypto.randomBytes(32).toString('base64url');
+// Models independent downstream refresh grants backed by a shared upstream
+// OAuth session. store.transact MUST serialize per upstream session and commit
+// atomically across processes; the production store/issuer is not implemented.
+function createIndependentGrants({store, refreshUpstream, now = Date.now}) {
+  if (!store || typeof store.transact !== 'function' || typeof refreshUpstream !== 'function') throw new Error('grant-dependencies-required');
+  async function freshen(session) {
+    if (session.expiresAt > now() + 60000) return;
+    const fresh=await refreshUpstream(session.upstreamRefreshToken);
+    if (!fresh || typeof fresh.accessToken !== 'string' || !fresh.accessToken || typeof fresh.refreshToken !== 'string' || !fresh.refreshToken || !Number.isSafeInteger(fresh.expiresAt) || fresh.expiresAt <= now()) throw new Error('upstream-refresh-failed');
+    session.accessToken=fresh.accessToken;session.upstreamRefreshToken=fresh.refreshToken;session.expiresAt=fresh.expiresAt;
+  }
+  async function issue({sessionId, clientId}) {
+    if (typeof clientId !== 'string' || !clientId || clientId.length > 128) throw new Error('invalid-client');
+    return store.transact(sessionId, async session => {
+      if (!session || session.revoked) throw new Error('invalid-session');
+      await freshen(session);
+      const raw=newToken();
+      session.grants[digest(raw)]={clientId};
+      return {refreshToken:raw,accessToken:session.accessToken,expiresAt:session.expiresAt};
+    });
+  }
+  async function refresh({sessionId, clientId, refreshToken}) {
+    if (typeof refreshToken !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(refreshToken) || typeof clientId !== 'string') throw new Error('invalid-grant');
+    return store.transact(sessionId, async session => {
+      const key=digest(refreshToken);const grant=session?.grants?.[key];
+      if (!session || session.revoked || !grant || grant.clientId !== clientId) throw new Error('invalid-grant');
+      await freshen(session);
+      delete session.grants[key];const next=newToken();session.grants[digest(next)]={clientId};
+      return {refreshToken:next,accessToken:session.accessToken,expiresAt:session.expiresAt};
+    });
+  }
+  return {issue,refresh};
+}
+module.exports={createIndependentGrants};

package/src/install-flow.js

@@ -0,0 +1,71 @@
+'use strict';
+const os=require('node:os');
+const path=require('node:path');
+const {spawnSync}=require('node:child_process');
+const {installNativeConfig}=require('./native-config');
+const {runSetupFlow}=require('./setup-flow');
+const {createKillbarEnrollment,verifyHelper,readHelperStatus}=require('./killbar-enrollment');
+const {installBackground}=require('./killbar-background-install');
+const {installHooksForDetectedClients}=require('./setup/hook-installer');
+const {prepareRelease}=require('./helper-release');
+const {createBrokerKeychain}=require('./desktop/broker-keychain');
+const {installBrokerLaunchAgent}=require('./desktop/broker-launch-agent');
+
+// The release metadata is shipped with the helper, never taken from the user's
+// environment. No credentials are sent until the helper has been verified.
+async function installFlow({clients,executablePaths,terminal,fetchImpl,home=os.homedir(),release=prepareRelease,
+  verify=verifyHelper,configure=installNativeConfig,setup=runSetupFlow,enrollment=createKillbarEnrollment,
+  background=installBackground,installHooks=installHooksForDetectedClients,readStatus=readHelperStatus,keychain=createBrokerKeychain,startBroker=installBrokerLaunchAgent}={}) {
+  const artifact=await release();
+  let changed=false;
+  try {
+    await verify(artifact.app,artifact.team);
+    const nativeClaude=clients.includes('claude');
+    const broker=nativeClaude?{command:process.execPath,args:['--slaunt-mcp-stdio']}:undefined;
+    const brokerGrantSink=nativeClaude?keychain({app:artifact.app,trust:artifact.team}):undefined;
+    for (const client of clients) {
+      terminal.progress(`Configuring ${client === 'codex' ? 'Codex' : 'Claude Code'}`);
+      const result=configure({clientId:client==='codex'?'codex-cli':'claude-code',homeDir:home});
+      if (!['installed','unchanged'].includes(result.status)) {
+        const error=new Error(result.status==='conflict'?'client-configuration-conflict':'client-configuration-failed');
+        error.setupClient=client;
+        throw error;
+      }
+      changed ||= result.status==='installed';
+      terminal.done(`${client === 'codex' ? 'Codex' : 'Claude Code'} configured`);
+    }
+    let identity;
+    const enroll=enrollment({app:artifact.app,team:artifact.team});
+    terminal.progress('Signing in and connecting clients');
+    changed=true; // OAuth or enrollment can change state before a failure.
+    await setup({clients,executablePaths,fetchImpl,brokerGrantSink,killbarEnrollment:async input=>{
+      const result=await enroll(input); identity=input.identity; return result;
+    }});
+    if (!identity) throw new Error('killbar-enrollment-unverified');
+    terminal.done('Clients signed in and KillBar enrolled');
+    terminal.progress('Starting KillBar');
+    const started=await background({sourceApp:artifact.app,team:artifact.team,home,verifyEnrollment:async app=>{
+      const status=await readStatus(path.join(app,'Contents/MacOS/SlauntKillBar'));
+      return status.enrolled===true && !status.requires_restart &&
+        status.org_id?.toLowerCase()===identity.orgId.toLowerCase() &&
+        status.project_id?.toLowerCase()===identity.projectId.toLowerCase();
+    }});
+    if (started?.registered!==true) throw new Error('killbar-background-unverified');
+    terminal.done('KillBar startup registered');
+    if(nativeClaude){
+      terminal.progress('Starting Claude authorization broker');
+      const launched=await startBroker({home});
+      if(launched?.registered!==true)throw new Error('broker-start-unverified');
+      terminal.done('Claude authorization broker started');
+    }
+    terminal.progress('Installing Slaunt hooks');
+    const hooks=installHooks({homeDir:home,broker,nativeBroker:nativeClaude,versionProbe:()=>spawnSync(executablePaths.claude||'claude',['--version'],{encoding:'utf8',timeout:10000,stdio:['ignore','pipe','ignore']}),clients:clients.map(client=>({id:client==='codex'?'codex-cli':'claude-code',surface:'cli'}))});
+    if (hooks.summary.detected!==clients.length || hooks.summary.failed || hooks.results.some(x=>!['installed','unchanged','partial'].includes(x.status))) throw new Error('hook-installation-failed');
+    terminal.done('Slaunt hooks installed');
+    return {installed:true};
+  } catch (error) {
+    error.setupMayHaveChanged=changed;
+    throw error;
+  } finally {await artifact.cleanup?.();}
+}
+module.exports={installFlow};

package/src/killbar-background-install.js

@@ -0,0 +1,47 @@
+'use strict';
+const fs=require('node:fs/promises');
+const path=require('node:path');
+const os=require('node:os');
+const {execFile}=require('node:child_process');
+const {promisify}=require('node:util');
+const {createLaunchAgentPlist,LABEL}=require('./killbar-launch-agent');
+const {verifyHelper}=require('./killbar-enrollment');
+const exec=promisify(execFile);
+async function ownedDirectory(dir){
+ try{await fs.mkdir(dir,{mode:0o700});}catch(e){if(e.code!=='EEXIST')throw new Error('killbar-directory-unavailable');}
+ const s=await fs.lstat(dir);
+ if(!s.isDirectory()||s.isSymbolicLink()||(typeof process.getuid==='function'&&s.uid!==process.getuid())||(s.mode&0o022))throw new Error('killbar-directory-unsafe');
+}
+async function absent(p){try{await fs.lstat(p);return false;}catch(e){if(e.code==='ENOENT')return true;throw e;}}
+async function installBackground({sourceApp,team,verifyEnrollment,home=os.homedir(),platform=process.platform,verify=verifyHelper,execute=exec}={}){
+ if(platform!=='darwin'||!path.isAbsolute(home)||!path.isAbsolute(sourceApp||'')||typeof process.getuid!=='function')throw new Error('killbar-background-unavailable');
+ if(typeof verifyEnrollment!=='function')throw new Error('killbar-identity-check-required');
+ await verify(sourceApp,team);
+ // Developer ID releases retain Gatekeeper assessment. Ad hoc packages are
+ // verified against the package's pinned digest and code-directory hash.
+ if(team?.mode!=='adhoc')try{await execute('/usr/sbin/spctl',['--assess','--type','execute',sourceApp],{timeout:15000});await execute('/usr/bin/xcrun',['stapler','validate',sourceApp],{timeout:15000});}catch{throw new Error('killbar-release-untrusted');}
+ if(await verifyEnrollment(sourceApp)!==true)throw new Error('killbar-identity-unverified');
+ const library=path.join(home,'Library'),support=path.join(library,'Application Support'),root=path.join(support,'Slaunt'),agents=path.join(library,'LaunchAgents');
+ for(const dir of [library,support,root,agents])await ownedDirectory(dir);
+ const installRoot=path.join(root,'KillBar'),app=path.join(installRoot,'SlauntKillBar.app'),plist=path.join(agents,`${LABEL}.plist`);
+ if(!(await absent(installRoot))||!(await absent(plist)))throw new Error('killbar-existing-install');
+ const domain=`gui/${process.getuid()}`;
+ try{await execute('/bin/launchctl',['print',domain],{timeout:10000});}catch{throw new Error('killbar-login-session-unavailable');}
+ // The new install directory is exclusively created; never replace another app.
+ try{await fs.mkdir(installRoot,{mode:0o700});}catch{throw new Error('killbar-existing-install');}
+ let plistCreated=false,bootstrapAttempted=false;
+ try{
+  await execute('/usr/bin/ditto',[sourceApp,app],{timeout:60000});
+  await verify(app,team);
+  await fs.writeFile(plist,createLaunchAgentPlist({app}),{mode:0o600,flag:'wx'});plistCreated=true;
+  bootstrapAttempted=true;
+  await execute('/bin/launchctl',['bootstrap',domain,plist],{timeout:15000});
+  await execute('/bin/launchctl',['print',`${domain}/${LABEL}`],{timeout:10000});
+  return {registered:true};
+ }catch{
+  // After bootstrap, state may be ambiguous; preserve artifacts for recovery.
+  if(!bootstrapAttempted){if(plistCreated)await fs.unlink(plist).catch(()=>{});await fs.rm(installRoot,{recursive:true,force:true});}
+  throw new Error(bootstrapAttempted?'killbar-background-state-unknown':'killbar-background-install-failed');
+ }
+}
+module.exports={installBackground};

package/src/killbar-enrollment.js

@@ -0,0 +1,74 @@
+'use strict';
+const path=require('node:path');
+const fs=require('node:fs/promises');
+const os=require('node:os');
+const {execFile,spawn}=require('node:child_process');
+const {promisify}=require('node:util');
+const exec=promisify(execFile);
+
+async function verifyHelper(app,team){
+  if(team && typeof team==='object' && team.mode==='adhoc') {
+    if(process.platform!=='darwin'||!path.isAbsolute(app)||!app.endsWith('/SlauntKillBar.app')||!/^[a-f0-9]{40}$/.test(team.cdhash||''))throw new Error('killbar-helper-unavailable');
+    try {
+      await exec('/usr/bin/codesign',['--verify','--deep','--strict',app],{timeout:15000,maxBuffer:8192});
+      const info=await exec('/usr/bin/codesign',['-dv','--verbose=4',app],{timeout:15000,maxBuffer:16384});
+      const output=`${info.stdout}\n${info.stderr}`;
+      if(!/^Identifier=ai\.slaunt\.killbar$/m.test(output)||!output.includes(`CDHash=${team.cdhash}`)||!/^Signature=adhoc$/m.test(output))throw new Error('signature-mismatch');
+      return;
+    } catch {throw new Error('killbar-helper-untrusted');}
+  }
+  if(process.platform!=='darwin'||!path.isAbsolute(app)||!app.endsWith('/SlauntKillBar.app')||!/^[A-Z0-9]{10}$/.test(team||'')) throw new Error('killbar-helper-unavailable');
+  const requirement=`=identifier "ai.slaunt.killbar" and anchor apple generic and certificate leaf[subject.OU] = "${team}"`;
+  try {await exec('/usr/bin/codesign',['--verify','--deep','--strict','-R',requirement,app],{timeout:15000,maxBuffer:8192});}
+  catch {throw new Error('killbar-helper-untrusted');}
+}
+function invokeHelper(binary,token,identity){
+  return new Promise((resolve,reject)=>{
+    const child=spawn(binary,['--desktop-enroll-stdin'],{stdio:['pipe','pipe','ignore'],env:{HOME:process.env.HOME,PATH:'/usr/bin:/bin',TMPDIR:process.env.TMPDIR}});
+    let output='',finished=false;
+    const finish=(error)=>{if(finished)return;finished=true;clearTimeout(timer);error?reject(new Error('killbar-enrollment-failed')):resolve();};
+    const timer=setTimeout(()=>{child.kill('SIGKILL');finish(true);},60000);
+    child.stdout.on('data',chunk=>{output+=chunk;if(Buffer.byteLength(output)>8192){child.kill('SIGKILL');finish(true);}});
+    child.stdin.on('error',()=>finish(true));
+    child.on('error',()=>finish(true));
+    child.on('close',code=>{try{const result=JSON.parse(output);finish(code!==0||result.protocol_version!==1||result.enrolled!==true);}catch{finish(true);}});
+    child.stdin.end(JSON.stringify({access_token:token,org_id:identity.orgId,project_id:identity.projectId}));
+  });
+}
+async function readHelperStatus(binary){
+  let stdout;
+  try {({stdout}=await exec(binary,['--desktop-control-status'],{timeout:15000,maxBuffer:8192,env:{HOME:process.env.HOME,PATH:'/usr/bin:/bin',TMPDIR:process.env.TMPDIR}}));}
+  catch {throw new Error('killbar-status-unavailable');}
+  let status;try{status=JSON.parse(stdout);}catch{throw new Error('killbar-status-invalid');}
+  if(status?.protocol_version!==1||typeof status.enrolled!=='boolean'||(status.requires_restart!==undefined&&typeof status.requires_restart!=='boolean')) throw new Error('killbar-status-invalid');
+  return status;
+}
+async function withEnrollmentLock(operation,{home=os.homedir()}={}){
+  const dir=path.join(home,'.slaunt');
+  try {await fs.mkdir(dir,{mode:0o700});}catch(error){if(error.code!=='EEXIST')throw new Error('killbar-lock-unavailable');}
+  let stat;try{stat=await fs.lstat(dir);}catch{throw new Error('killbar-lock-unavailable');}
+  if(!stat.isDirectory()||stat.isSymbolicLink()||(typeof process.getuid==='function'&&stat.uid!==process.getuid())||(stat.mode&0o077)!==0)throw new Error('killbar-lock-unavailable');
+  const lock=path.join(dir,'killbar-enrollment.lock');
+  try {await fs.mkdir(lock,{mode:0o700});}catch(error){throw new Error(error.code==='EEXIST'?'killbar-enrollment-busy':'killbar-lock-unavailable');}
+  try{return await operation();}finally{await fs.rmdir(lock);}
+}
+function createKillbarEnrollment({app,team,verify=verifyHelper,readStatus=readHelperStatus,invoke=invokeHelper,withLock=withEnrollmentLock}={}){
+  return async ({accessToken,identity}={})=>{
+    await verify(app,team);
+    if(typeof accessToken!=='string'||accessToken.length<1||accessToken.length>16384||/[\u0000-\u001f\u007f]/.test(accessToken))throw new Error('killbar-authentication-failed');
+    const uuid=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if(!uuid.test(identity?.orgId || '') || !uuid.test(identity?.projectId || ''))throw new Error('killbar-identity-invalid');
+    return withLock(async()=>{
+    const binary=path.join(app,'Contents/MacOS/SlauntKillBar');
+    const status=await readStatus(binary);
+    if(status.requires_restart)throw new Error('killbar-restart-required');
+    // Existing device credentials may belong to a different workspace.
+    if(status.enrolled)throw new Error('killbar-already-enrolled');
+    await invoke(binary,accessToken,identity);
+    const confirmed=await readStatus(binary);
+    if(confirmed.enrolled!==true || confirmed.requires_restart || typeof confirmed.org_id!=='string' || typeof confirmed.project_id!=='string' || confirmed.org_id.toLowerCase()!==identity.orgId.toLowerCase() || confirmed.project_id.toLowerCase()!==identity.projectId.toLowerCase())throw new Error('killbar-enrollment-unverified');
+    return {enrolled:true};
+    });
+  };
+}
+module.exports={createKillbarEnrollment,verifyHelper,invokeHelper,readHelperStatus,withEnrollmentLock};

package/src/killbar-launch-agent.js

@@ -0,0 +1,10 @@
+'use strict';
+const path=require('node:path');
+const LABEL='ai.slaunt.killbar.cli';
+const xml=value=>value.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,'&apos;');
+function createLaunchAgentPlist({app}) {
+  if(typeof app!=='string'||!path.isAbsolute(app)||!app.endsWith('/SlauntKillBar.app')||/[\u0000-\u001f\u007f]/.test(app))throw new Error('invalid-killbar-app');
+  const executable=path.join(app,'Contents/MacOS/SlauntKillBar');
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>\n<key>Label</key><string>${LABEL}</string>\n<key>ProgramArguments</key><array><string>${xml(executable)}</string><string>--desktop-managed</string></array>\n<key>RunAtLoad</key><true/>\n<key>KeepAlive</key><true/>\n<key>ThrottleInterval</key><integer>30</integer>\n<key>ProcessType</key><string>Background</string>\n</dict></plist>\n`;
+}
+module.exports={createLaunchAgentPlist,LABEL};

package/src/mcp-identity.js

@@ -0,0 +1,6 @@
+'use strict';
+
+// Client config keys and hook server references must match exactly.
+const SLAUNT_SERVER_NAME = 'slaunt';
+
+module.exports = { SLAUNT_SERVER_NAME };

package/src/native-config.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { parse: parseToml } = require('smol-toml');
+
+const SLAUNT_SERVER_NAME = 'slaunt';
+const ENDPOINT = 'https://central-mcp-ccr-production.up.railway.app/mcp';
+const MAX_CONFIG_BYTES = 5 * 1024 * 1024;
+const CLIENT_TARGETS = Object.freeze({
+  'claude-code': Object.freeze({ directory: null, file: '.claude.json', format: 'json' }),
+  'codex-cli': Object.freeze({ directory: '.codex', file: 'config.toml', format: 'toml' })
+});
+
+function ensureDirectory(homeDir, directoryName) {
+  const target = directoryName ? path.join(homeDir, directoryName) : homeDir;
+  try {
+    const stats = fs.lstatSync(target);
+    if (stats.isSymbolicLink() || !stats.isDirectory()) throw new Error('unsafe-config-directory');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+    fs.mkdirSync(target, { mode: 0o700 });
+  }
+  const stats = fs.lstatSync(target);
+  if (stats.isSymbolicLink() || !stats.isDirectory()) throw new Error('unsafe-config-directory');
+  return target;
+}
+
+function readExistingConfig(filePath) {
+  let descriptor;
+  try {
+    descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+    const stats = fs.fstatSync(descriptor);
+    if (!stats.isFile()) throw new Error('unsafe-config-file');
+    if (stats.size > MAX_CONFIG_BYTES) throw new Error('config-file-too-large');
+    return {
+      content: fs.readFileSync(descriptor, 'utf8'),
+      identity: { dev: stats.dev, ino: stats.ino, size: stats.size, mtimeMs: stats.mtimeMs }
+    };
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    if (error?.code === 'ELOOP') throw new Error('unsafe-config-file');
+    if (error?.message?.startsWith('unsafe-') || error?.message === 'config-file-too-large') throw error;
+    throw new Error('config-read-failed');
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+  }
+}
+
+function assertUnchanged(filePath, previous) {
+  try {
+    const current = fs.lstatSync(filePath);
+    if (current.isSymbolicLink() || !current.isFile()) throw new Error('unsafe-config-file');
+    if (!previous
+        || current.dev !== previous.identity.dev
+        || current.ino !== previous.identity.ino
+        || current.size !== previous.identity.size
+        || current.mtimeMs !== previous.identity.mtimeMs) {
+      throw new Error('config-changed-during-setup');
+    }
+  } catch (error) {
+    if (error?.code === 'ENOENT' && !previous) return;
+    if (error?.code === 'ENOENT' || error?.message?.startsWith('unsafe-')) throw error;
+    throw new Error('config-changed-during-setup');
+  }
+}
+
+function writeConfigAtomically(filePath, directory, serialized, previous) {
+  const temporaryPath = path.join(
+    directory,
+    `.slaunt-${process.pid}-${crypto.randomBytes(10).toString('hex')}.tmp`
+  );
+  let descriptor;
+  try {
+    descriptor = fs.openSync(temporaryPath, 'wx', 0o600);
+    fs.writeFileSync(descriptor, serialized, 'utf8');
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = undefined;
+
+    assertUnchanged(filePath, previous);
+    fs.renameSync(temporaryPath, filePath);
+    fs.chmodSync(filePath, 0o600);
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+    try {
+      fs.unlinkSync(temporaryPath);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+function updateClaudeConfig(previous) {
+  const config=previous?.content?.trim()?JSON.parse(previous.content):{};
+  if(!config||typeof config!=='object'||Array.isArray(config))throw new Error('invalid-config-root');
+  if(config.mcpServers!==undefined&&(!config.mcpServers||typeof config.mcpServers!=='object'||Array.isArray(config.mcpServers)))throw new Error('invalid-mcp-servers');
+  const servers=config.mcpServers||{};
+  if(Object.hasOwn(servers,SLAUNT_SERVER_NAME)){
+    const entry=servers[SLAUNT_SERVER_NAME];
+    if(!entry||entry.type!=='http'||entry.url!==ENDPOINT||Object.keys(entry).some(k=>!['type','url'].includes(k)))throw new Error('server-name-conflict');
+    return {status:'unchanged'};
+  }
+  config.mcpServers={...servers,[SLAUNT_SERVER_NAME]:{type:'http',url:ENDPOINT}};
+  return {status:'installed',content:`${JSON.stringify(config,null,2)}\n`};
+}
+function updateCodexConfig(previous) {
+  const source=previous?.content||'';const parsed=source.trim()?parseToml(source):{};
+  if(parsed.mcp_servers!==undefined&&(!parsed.mcp_servers||typeof parsed.mcp_servers!=='object'||Array.isArray(parsed.mcp_servers)))throw new Error('invalid-mcp-servers');
+  const servers=parsed.mcp_servers||{};
+  if(Object.hasOwn(servers,SLAUNT_SERVER_NAME)){
+    const entry=servers[SLAUNT_SERVER_NAME];
+    if(!entry||entry.url!==ENDPOINT||entry.enabled===false||Object.keys(entry).some(k=>!['url','enabled'].includes(k)))throw new Error('server-name-conflict');
+    return {status:'unchanged'};
+  }
+  const separator=source.length===0||source.endsWith('\n\n')?'':source.endsWith('\n')?'\n':'\n\n';
+  const content=`${source}${separator}[mcp_servers.slaunt]\nurl = ${JSON.stringify(ENDPOINT)}\n`;
+  const updated=parseToml(content);if(updated.mcp_servers?.slaunt?.url!==ENDPOINT)throw new Error('invalid-mcp-servers');
+  return {status:'installed',content};
+}
+
+function safeReason(error) {
+  const known = new Set([
+    'unsafe-config-directory',
+    'unsafe-config-file',
+    'config-file-too-large',
+    'config-read-failed',
+    'config-changed-during-setup',
+    'invalid-config-root',
+    'invalid-mcp-servers',
+    'server-name-conflict'
+  ]);
+  if (known.has(error?.message)) return error.message;
+  if (error?.code === 'EACCES' || error?.code === 'EPERM') return 'permission-denied';
+  if (error?.code === 'ENOSPC') return 'insufficient-storage';
+  return 'config-write-failed';
+}
+
+function installNativeConfig({clientId,homeDir}={}) {
+  const target=CLIENT_TARGETS[clientId];
+  if(!target||!path.isAbsolute(homeDir||''))return {status:'error',reason:'invalid-install-request'};
+  try {
+    const directory=ensureDirectory(homeDir,target.directory);const filePath=path.join(directory,target.file);const previous=readExistingConfig(filePath);
+    const updated=target.format==='json'?updateClaudeConfig(previous):updateCodexConfig(previous);
+    if(updated.status==='unchanged')return {status:'unchanged',reason:null};
+    writeConfigAtomically(filePath,directory,updated.content,previous);return {status:'installed',reason:null};
+  }catch(error){return {status:error?.message==='server-name-conflict'?'conflict':'error',reason:safeReason(error)};}
+}
+module.exports={installNativeConfig,ENDPOINT};

package/src/native-oauth.js

@@ -0,0 +1,33 @@
+'use strict';
+const { spawnSync } = require('node:child_process');
+const ENDPOINT = 'https://central-mcp-ccr-production.up.railway.app/mcp';
+const NAME = 'slaunt';
+function installOAuth({ clients, run = spawnSync, output = console } = {}) {
+  const results = [];
+  for (const client of clients) {
+    const executable = client === 'codex' ? 'codex' : 'claude';
+    const inspect = run(executable, client === 'codex' ? ['mcp', 'get', NAME, '--json'] : ['mcp', 'get', NAME], { encoding: 'utf8', timeout: 30000 });
+    if (inspect.error) { output.error(`${executable} is unavailable.`); results.push({ client, status: 'error' }); continue; }
+    if (inspect.status === 0) {
+      let matches = false;
+      if (client === 'codex') {
+        try { const entry = JSON.parse(inspect.stdout); matches = entry.transport?.type === 'streamable_http' && entry.transport.url === ENDPOINT; } catch {}
+      } else {
+        // The command may return secrets in other fields; inspect locally and never print it.
+        matches = (inspect.stdout || '').split(/\r?\n/).some(line => /^\s*URL:\s*https:\/\/central-mcp-ccr-production\.up\.railway\.app\/mcp\s*$/.test(line));
+      }
+      if (!matches) { output.error(`${executable}: existing slaunt server conflicts or could not be verified; preserved.`); results.push({client, status:'conflict'}); continue; }
+    } else {
+      const args = client === 'codex' ? ['mcp','add',NAME,'--url',ENDPOINT] : ['mcp','add','--scope','user','--transport','http',NAME,ENDPOINT];
+      const added = run(executable, args, { stdio: 'inherit', timeout: 30000 });
+      if (added.error || added.status !== 0) { output.error(`${executable}: server configuration failed.`); results.push({client,status:'error'}); continue; }
+    }
+    output.log(`${executable}: complete Slaunt OAuth sign-in in your browser.`);
+    const login = run(executable, ['mcp','login',NAME], { stdio:'inherit', timeout: 315000 });
+    const status = !login.error && login.status === 0 ? 'authenticated' : 'authentication-failed';
+    results.push({client,status});
+    if (status !== 'authenticated') output.error(`${executable}: sign-in did not complete; its server configuration remains for retry.`);
+  }
+  return results;
+}
+module.exports = { installOAuth, ENDPOINT };