slaunt 0.1.17 → 0.1.19

package/src/setup/mcp-config-installer.js

@@ -0,0 +1,204 @@
+'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 } = require('../mcp-identity');
+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 matchesBrokerEntry(existing, broker) {
+  return Boolean(existing
+    && typeof existing === 'object'
+    && !Array.isArray(existing)
+    && existing.command === broker.command
+    && Array.isArray(existing.args)
+    && existing.args.length === broker.args.length
+    && existing.args.every((argument, index) => argument === broker.args[index]));
+}
+
+function matchesPriorBrokerEntry(existing, broker) {
+  const args = broker.args.filter(argument => !argument.startsWith('--slaunt-client='));
+  return args.length === broker.args.length - 1 && matchesBrokerEntry(existing, { ...broker, args });
+}
+
+function updateClaudeConfig(previous, broker) {
+  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)) {
+    if (matchesBrokerEntry(servers[SLAUNT_SERVER_NAME], broker)) return { status: 'unchanged' };
+    if (!matchesPriorBrokerEntry(servers[SLAUNT_SERVER_NAME], broker)) throw new Error('server-name-conflict');
+    servers[SLAUNT_SERVER_NAME] = { ...servers[SLAUNT_SERVER_NAME], args: broker.args };
+    return { status: 'installed', content: `${JSON.stringify(config, null, 2)}\n` };
+  }
+  config.mcpServers = {
+    ...servers,
+    [SLAUNT_SERVER_NAME]: { command: broker.command, args: broker.args }
+  };
+  return { status: 'installed', content: `${JSON.stringify(config, null, 2)}\n` };
+}
+
+function updateCodexConfig(previous, broker) {
+  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)) {
+    if (matchesBrokerEntry(servers[SLAUNT_SERVER_NAME], broker)) return { status: 'unchanged' };
+    if (!matchesPriorBrokerEntry(servers[SLAUNT_SERVER_NAME], broker)) throw new Error('server-name-conflict');
+    // Upgrade only our generated simple args line, preserving all surrounding TOML.
+    const section = /(^\[mcp_servers\.slaunt\][ \t]*(?:#[^\n]*)?\r?\n)([\s\S]*?)(?=^\[|(?![\s\S]))/m;
+    const match = section.exec(source);
+    if (!match || !/^args[ \t]*=[ \t]*\[[^\n]*\][ \t]*$/m.test(match[2])) throw new Error('server-name-conflict');
+    const body = match[2].replace(/^args[ \t]*=[ \t]*\[[^\n]*\][ \t]*$/m, () => `args = ${JSON.stringify(broker.args)}`);
+    const content = source.slice(0, match.index) + match[1] + body + source.slice(match.index + match[0].length);
+    const updated = parseToml(content);
+    if (!matchesBrokerEntry(updated.mcp_servers?.[SLAUNT_SERVER_NAME], broker)) throw new Error('server-name-conflict');
+    return { status: 'installed', content };
+  }
+
+  const separator = source.length === 0 || source.endsWith('\n\n') ? '' : source.endsWith('\n') ? '\n' : '\n\n';
+  const content = `${source}${separator}[mcp_servers.${SLAUNT_SERVER_NAME}]\nenabled = true\ncommand = ${JSON.stringify(broker.command)}\nargs = ${JSON.stringify(broker.args)}\n`;
+  // Parse the complete result before it can reach the user's config file.
+  parseToml(content);
+  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 installMcpConfigForClient({ clientId, homeDir, broker } = {}) {
+  const target = CLIENT_TARGETS[clientId];
+  if (!target) return { status: 'unsupported', reason: 'adapter-unavailable' };
+  if (!path.isAbsolute(homeDir || '') || !broker || !path.isAbsolute(broker.command)
+      || !Array.isArray(broker.args) || broker.args.length > 4
+      || broker.args.some((argument) => typeof argument !== 'string' || argument.length > 512)) {
+    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, broker)
+      : updateCodexConfig(previous, broker);
+    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 = {
+  SLAUNT_SERVER_NAME,
+  CLIENT_TARGETS,
+  installMcpConfigForClient
+};

package/src/setup-flow.js

@@ -0,0 +1,66 @@
+'use strict';
+const {spawn}=require('node:child_process');
+const {authorizeCohort}=require('./oauth-cohort');
+const {startOAuthFlow}=require('./cli-auth');
+const {readJson}=require('./read-json');
+const ISSUER='https://central-mcp-ccr-production.up.railway.app';
+async function openBrowser(url) {
+  const command=process.platform==='darwin'?'open':'xdg-open';
+  await new Promise((resolve,reject)=>{const child=spawn(command,[url],{stdio:'ignore'});child.on('error',reject);child.on('close',code=>code===0?resolve():reject(new Error('browser-unavailable')));});
+}
+async function runSetupFlow({clients,issuer=ISSUER,fetchImpl=fetch,shell={openExternal:openBrowser},login,executablePaths,killbarEnrollment,brokerGrantSink,authenticate=startOAuthFlow}={}) {
+  // The client grants must never be issued without enrolling the helper that
+  // supplies the local control boundary for this setup.
+  if(typeof killbarEnrollment !== 'function') throw new Error('killbar-enrollment-required');
+  const origin=new URL(issuer);
+  if(origin.protocol!=='https:' && !(origin.protocol==='http:' && ['127.0.0.1','localhost','[::1]'].includes(origin.hostname)))throw new Error('unsafe-issuer');
+  let session=null;
+  try {
+    await authorizeCohort({clients,issuer,executablePaths,timeoutMs:360000,...(login?{login}:{}),approve:async inputs=>{
+      const requests=inputs.map(({client,authorizationUrl})=>({client,authorization_url:authorizationUrl}));
+      let diagnosticStage='sign-in';
+      try {
+      await authenticate({shell,issuer,fetchImpl,requests,sessionSink:{async save(value){session=value;}}});
+      if(!session)throw new Error('authentication-required');
+      diagnosticStage='workspace';
+      const identityResponse=await fetchImpl(new URL('/api/desktop/session',origin),{method:'GET',redirect:'error',signal:AbortSignal.timeout(15000),headers:{authorization:`Bearer ${session.accessToken}`}});
+      if(!identityResponse.ok)throw new Error('workspace-identity-unavailable');
+      const identity=await readJson(identityResponse,32768);
+      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?.org_id || '') || !uuid.test(identity?.project_id || ''))throw new Error('workspace-identity-invalid');
+      // Enrollment shares the same authenticated Slaunt sign-in. The helper
+      // performs its own device challenge and stores its own credentials.
+      diagnosticStage='enrollment';
+      const enrollment = await killbarEnrollment({accessToken:session.accessToken,identity:{orgId:identity.org_id,projectId:identity.project_id}});
+      if(enrollment?.enrolled !== true) throw new Error('killbar-enrollment-unverified');
+      diagnosticStage='client-grants';
+      const requestBroker=clients.includes('claude') && Boolean(brokerGrantSink);
+      if(requestBroker && typeof brokerGrantSink.save!=='function')throw new Error('broker-grant-store-unavailable');
+      const requestBody=JSON.stringify({refresh_token:session.refreshToken,setup_ticket:session.setupTicket,requests,...(requestBroker?{request_broker:true}:{})});
+      let payload;
+      for(let attempt=0;attempt<3;attempt++){
+        try{
+          const response=await fetchImpl(new URL('/authorize/cli',origin),{method:'POST',redirect:'error',signal:AbortSignal.timeout(45000),headers:{'content-type':'application/json',authorization:`Bearer ${session.accessToken}`},body:requestBody});
+          if(!response.ok && response.status<500)throw new Error('setup-authorization-rejected');
+          if(!response.ok)throw new Error('setup-authorization-failed');
+          payload=await readJson(response,262144);break;
+        }catch(error){if(error?.message==='setup-authorization-rejected'||attempt===2)throw new Error('setup-authorization-failed');}
+      }
+      if(!payload||typeof payload.callbacks!=='object')throw new Error('setup-response-invalid');
+      if(requestBroker){
+        const grant=payload.broker,lifetime=Number(grant?.expires_in);
+        if(!/^bg1\.[A-Za-z0-9_-]+$/.test(grant?.access_token||'') || grant.access_token.length>131072 || !/^sg1\.[A-Za-z0-9_-]{43}$/.test(grant?.refresh_token||'') || grant.scope!=='slaunt:guard' || String(grant.token_type||'').toLowerCase()!=='bearer' || !Number.isSafeInteger(lifetime) || lifetime<1 || lifetime>300)throw new Error('broker-grant-invalid');
+        try {await brokerGrantSink.save({accessToken:grant.access_token,refreshToken:grant.refresh_token,expiresAt:Date.now()+lifetime*1000});}
+        catch {
+          // Best-effort cleanup; never hand native callbacks to clients after
+          // failing to persist the broker grant.
+          try {await fetchImpl(new URL('/revoke',origin),{method:'POST',redirect:'error',signal:AbortSignal.timeout(10000),headers:{'content-type':'application/x-www-form-urlencoded'},body:new URLSearchParams({client_id:'ai.slaunt.claude-broker',token:grant.refresh_token})});}catch{}
+          throw new Error('broker-grant-store-unavailable');
+        }
+      }
+      return payload.callbacks;
+      } catch { const error=new Error('setup-step-failed'); error.setupDetail=diagnosticStage; throw error; }
+    }});
+  } finally {session=null;}
+}
+module.exports={runSetupFlow,ISSUER};

package/src/tui.js

@@ -0,0 +1,205 @@
+'use strict';
+const readline = require('node:readline');
+const { createFullScreen } = require('./full-screen');
+const { COMPACT_WORDMARK } = require('./compact-wordmark');
+
+// Terminal conventions follow guided setup CLIs: a recommended first choice,
+// one question at a time, visible completed steps, and a clear terminal result.
+const FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+const SPLASH_LOGO = String.raw`           /$$                                 /$$
+          | $$                                | $$
+  /$$$$$$$| $$  /$$$$$$  /$$   /$$ /$$$$$$$  /$$$$$$
+ /$$_____/| $$ |____  $$| $$  | $$| $$__  $$|_  $$_/
+|  $$$$$$ | $$  /$$$$$$$| $$  | $$| $$  \ $$  | $$
+ \____  $$| $$ /$$__  $$| $$  | $$| $$  | $$  | $$ /$$
+ /$$$$$$$/| $$|  $$$$$$$|  $$$$$$/| $$  | $$  |  $$$$/
+|_______/ |__/ \_______/ \______/ |__/  |__/   \___/`.split('\n');
+const SPLASH_WIDTH = Math.max(...SPLASH_LOGO.map(line => line.length));
+const COMPACT_WIDTH = Math.max(...COMPACT_WORDMARK.map(line => line.length));
+const CLIENTS = [
+  { value: 'both', label: 'Codex + Claude Code', hint: 'recommended' },
+  { value: 'codex', label: 'Codex' },
+  { value: 'claude', label: 'Claude Code' }
+];
+
+function createTerminal({ input = process.stdin, output = process.stdout, error = process.stderr, env = process.env } = {}) {
+  const tty = Boolean(input.isTTY && output.isTTY && env.TERM !== 'dumb');
+  const interactive = tty && !env.CI && typeof input.setRawMode === 'function';
+  const color = tty && !Object.hasOwn(env, 'NO_COLOR');
+  const motion = interactive && env.SLAUNT_REDUCED_MOTION !== '1';
+  const style = (code, value) => color ? `\x1b[${code}m${value}\x1b[0m` : value;
+  const dim = value => style('2', value);
+  const accent = value => style('36', value);
+  const bold = value => style('1', value);
+  let timer = null;
+  let progressLine = false;
+  let ended = false;
+  let screenActive = false;
+  let finalMessage = null;
+  let rawModeActive = false;
+  let originalRawMode = false;
+  let screen = null;
+  const screenState = {view:'status',selected:0,selection:null,completed:[],current:null,failure:null,clientAvailability:{codex:'unknown',claude:'unknown'}};
+  const onScreenResize = () => { if(screenActive&&screen)screen.render(screenState,true); };
+  async function enter() {
+    if (!interactive) return;
+    screenActive = true;
+    output.write('\x1b[?1049h\x1b[2J\x1b[H\x1b[?25l');
+    let lastSize = '';
+    const drawSplash = shimmer => {
+      const width = Math.max(1, output.columns || 80);
+      const height = Math.max(1, output.rows || 24);
+      const lines = width >= SPLASH_WIDTH && height >= SPLASH_LOGO.length + 3 ? SPLASH_LOGO
+        : width >= COMPACT_WIDTH && height >= COMPACT_WORDMARK.length + 3 ? COMPACT_WORDMARK : ['SLAUNT'];
+      const lineWidth = Math.max(...lines.map(line => line.length));
+      const row = Math.max(1, Math.floor((height - lines.length - 1) / 2) + 1);
+      const column = Math.max(1, Math.floor((width - lineWidth) / 2) + 1);
+      const size = `${width}:${height}`;
+      if (size !== lastSize) { output.write('\x1b[2J'); lastSize = size; }
+      for (const [index, line] of lines.entries()) {
+        let rendered = '';
+        if (shimmer === null || !color) rendered = color ? accent(line) : line;
+        else {
+          let group = '', highlight = false;
+          for (const [columnIndex, char] of [...line].entries()) {
+            const nextHighlight = Math.abs(columnIndex - index * 0.7 - shimmer) <= 3 && char !== ' ';
+            if (group && nextHighlight !== highlight) { rendered += style(highlight ? '1;97' : '2;36', group); group = ''; }
+            highlight = nextHighlight; group += char;
+          }
+          if (group) rendered += style(highlight ? '1;97' : '2;36', group);
+        }
+        output.write(`\x1b[${row + index};${column}H${rendered}`);
+      }
+      if (height >= lines.length + 3 && width >= 24) output.write(`\x1b[${row + lines.length + 1};${Math.max(1, Math.floor((width - 15) / 2) + 1)}H${dim('Preparing setup')}`);
+    };
+    if (motion && color) {
+      for (let offset = -6; offset <= SPLASH_WIDTH + 6; offset += 6) {
+        if (!screenActive) return;
+        drawSplash(offset);
+        await new Promise(resolve => setTimeout(resolve, 65));
+      }
+    } else {
+      drawSplash(null);
+      await new Promise(resolve => setTimeout(resolve, 250));
+    }
+    if (screenActive) {
+      output.write('\x1b[2J\x1b[H\x1b[?25l');
+      screen=createFullScreen({output,logo:SPLASH_LOGO,color,motion});
+      output.on('resize',onScreenResize);
+    }
+  }
+  function close() {
+    stop();
+    if (rawModeActive) { input.setRawMode(originalRawMode); rawModeActive = false; }
+    if (!screenActive) return;
+    screenActive = false;
+    output.removeListener('resize',onScreenResize);
+    output.write('\x1b[?25h\x1b[?1049l');
+    if (finalMessage) output.write(`\nSlaunt: ${finalMessage.message}\n${finalMessage.detail ? `${finalMessage.detail}\n` : ''}`);
+  }
+  function stop() {
+    if (timer) { clearInterval(timer); timer = null; }
+    if (progressLine) { output.write('\r\x1b[2K'); progressLine = false; }
+  }
+  function banner() {
+    if (screenActive && screen) { screen.render(screenState,true); return; }
+    output.write(`\n${accent('┌')}  ${bold('Slaunt setup')}\n${dim('│')}\n`);
+  }
+  function setClientAvailability(client,status) {
+    if (!Object.hasOwn(screenState.clientAvailability,client)) return;
+    screenState.clientAvailability[client]=status;
+    if(screenActive&&screen&&screenState.view==='select')screen.render(screenState);
+  }
+  function setSelection(value) {
+    const choice=CLIENTS.find(item=>item.value===value);
+    screenState.selection=choice?choice.label:null;
+    if(screenActive&&screen)screen.render(screenState,true);
+  }
+  function progress(label) {
+    stop();
+    if(screenActive&&screen){
+      screenState.current=label;screen.render(screenState,true);
+      if(motion){timer=setInterval(()=>screen.render(screenState),100);timer.unref?.();}
+      return;
+    }
+    if (!motion) { output.write(`${dim('│')}  ${label}…\n`); return; }
+    let frame = 0;
+    const render = () => { output.write(`\r\x1b[2K${accent(FRAMES[frame++ % FRAMES.length])}  ${label}`); progressLine = true; };
+    render(); timer = setInterval(render, 80); timer.unref?.();
+  }
+  function done(label) {
+    stop();
+    if(screenActive&&screen){screenState.current=null;screenState.completed.push(label);screen.render(screenState,true);return;}
+    output.write(`${accent('◇')}  ${label}\n${dim('│')}\n`);
+  }
+  function fail(message, detail) {
+    stop();
+    if (ended) return;
+    ended = true;
+    finalMessage = { message, detail };
+    if(screenActive&&screen){screenState.view='status';screenState.current=null;screenState.failure=finalMessage;screen.render(screenState,true);return;}
+    const dest = tty ? output : error;
+    dest.write(`${style('33', '▲')}  ${bold(message)}\n${detail ? `${dim('│')}  ${detail}\n` : ''}${dim('└')}  Setup stopped\n\n`);
+  }
+  function success(message, detail) {
+    stop();
+    if (ended) return;
+    ended = true;
+    finalMessage = { message, detail };
+    if (screenActive && screen) { screenState.current=null; screenState.completed.push(message); screen.render(screenState,true); return; }
+    output.write(`${accent('◇')}  ${bold(message)}\n${detail ? `${dim('│')}  ${detail}\n` : ''}${dim('└')}\n`);
+  }
+  async function selectClients() {
+    if (!interactive) return 'both';
+    let selected = 0;
+    const screenWasActive = screenActive;
+    const compact = () => (output.columns || 80) < 52;
+    const question = () => compact() ? 'Choose clients' : 'Which clients would you like to connect?';
+    const rows = () => [
+      `${accent('◆')}  ${bold(question())}`,
+      ...CLIENTS.map((item, index) => `${dim('│')}  ${index === selected ? accent('●') : dim('○')} ${item.label}${item.hint && (output.columns || 80) >= 50 ? ` ${dim(`(${item.hint})`)}` : ''}`),
+      `${dim('│')}  ${dim(compact() ? '↑/↓ · Enter' : '↑/↓ to navigate · Enter to confirm')}`,
+      dim('└')
+    ];
+    function draw(clear=false) { if(screenWasActive&&screenActive&&screen){screenState.view='select';screenState.selected=selected;screen.render(screenState,clear);}else output.write(`${rows().join('\n')}\n`); }
+    function erase() { if(!screenWasActive)output.write(`\x1b[${rows().length}A\r\x1b[J`); }
+    output.write('\x1b[?25l');
+    draw(true);
+    if(screenWasActive&&motion){timer=setInterval(()=>draw(),120);timer.unref?.();}
+    readline.emitKeypressEvents(input);
+    const wasRaw = Boolean(input.isRaw);
+    try {
+      input.setRawMode(true); originalRawMode = wasRaw; rawModeActive = true; input.resume();
+      return await new Promise(resolve => {
+        let settled = false;
+        const finish = value => {
+          if (settled) return;
+          settled = true;
+          input.removeListener('keypress', onKey);
+          input.removeListener('end', onEnd);
+          input.removeListener('error', onEnd);
+          stop();
+          if (!screenWasActive || screenActive) {
+            erase();
+            if (value && screenWasActive) {screenState.view='status';screenState.selection=CLIENTS[selected].label;screen.render(screenState,true);}
+            else if (value) output.write(`${accent('◇')}  ${question()}\n${dim('│')}  ${CLIENTS[selected].label}\n${dim('│')}\n`);
+          }
+          resolve(value);
+        };
+        const onEnd = () => finish(null);
+        const onKey = (_text, key = {}) => {
+          if ((key.ctrl && ['c','d'].includes(key.name)) || key.name === 'escape') return finish(null);
+          if (key.name === 'up' || key.name === 'k') { selected = (selected + CLIENTS.length - 1) % CLIENTS.length; erase(); draw(); }
+          else if (key.name === 'down' || key.name === 'j') { selected = (selected + 1) % CLIENTS.length; erase(); draw(); }
+          else if (key.name === 'return' || key.name === 'enter') finish(CLIENTS[selected].value);
+        };
+        input.on('keypress', onKey); input.once('end', onEnd); input.once('error', onEnd);
+      });
+    } finally {
+      if (rawModeActive) { input.setRawMode(wasRaw); rawModeActive = false; }
+      input.pause(); output.write(screenActive ? '\x1b[?25l' : '\x1b[?25h');
+    }
+  }
+  return { enter, close, banner, progress, done, fail, success, stop, selectClients, setSelection, setClientAvailability, tty, interactive };
+}
+module.exports = { createTerminal, SPLASH_LOGO };

package/test/approval-manager.test.js

@@ -0,0 +1,27 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {createApprovalManager} = require('../src/approval-manager');
+const makeReq = (name,state) => ({client:name, authorizationUrl:`https://example.test/authorize?response_type=code&client_id=${name}&redirect_uri=http%3A%2F%2F127.0.0.1%3A1234%2Fcallback&state=${state}&code_challenge=abc&code_challenge_method=S256`});
+const requests = [makeReq('codex','codex-state'),makeReq('claude','claude-state')];
+const manager = options => createApprovalManager({issuer:'https://example.test',validateClient:async()=>true,issueCallback:async({request})=>{let u=new URL(request.searchParams.get('redirect_uri'));u.searchParams.set('code','test');u.searchParams.set('state',request.searchParams.get('state'));return u.toString();},...options});
+test('one approval yields callbacks bound to each request and rejects replay',async()=>{
+ let issued=[]; const m=manager({issueCallback:async({client,request,principal})=>{issued.push([client,principal]);let u=new URL(request.searchParams.get('redirect_uri'));u.searchParams.set('code',client);u.searchParams.set('state',request.searchParams.get('state'));return u.toString();}});
+ const session=await m.create(requests);assert.deepEqual(m.approve({...session,principal:'user',accepted:true}).clients,['codex','claude']);
+ const cb=await m.redeem(session);assert.match(cb.codex,/codex-state/);assert.match(cb.claude,/claude-state/);assert.deepEqual(issued,[['codex','user'],['claude','user']]);await assert.rejects(m.redeem(session));
+});
+test('rejects invalid approval, wrong redemption proof and denial',async()=>{
+ const m=manager();const s=await m.create(requests);assert.throws(()=>m.approve({...s,approveSecret:'wrong',principal:'user',accepted:true}));m.approve({...s,principal:'user',accepted:true});await assert.rejects(m.redeem({...s,redeemSecret:'wrong'}));assert.ok(await m.redeem(s));
+ const d=await m.create(requests);assert.equal(m.approve({...d,principal:'user',accepted:false}).approved,false);await assert.rejects(m.redeem(d));
+});
+test('rejects unregistered clients and expired approval',async()=>{
+ const m=manager({validateClient:async()=>false});await assert.rejects(m.create(requests));
+ let time=0;const exp=manager({now:()=>time,ttlMs:10});const s=await exp.create(requests);time=11;assert.throws(()=>exp.approve({...s,principal:'user',accepted:true}));
+});
+test('only one concurrent redemption can claim an approved batch',async()=>{
+ let issued=0;const m=manager({issueCallback:async({request})=>{issued++;await new Promise(resolve=>setTimeout(resolve,5));const u=new URL(request.searchParams.get('redirect_uri'));u.searchParams.set('code','test');u.searchParams.set('state',request.searchParams.get('state'));return u.toString();}});
+ const s=await m.create(requests);m.approve({...s,principal:'user',accepted:true});const results=await Promise.allSettled([m.redeem(s),m.redeem(s)]);assert.deepEqual(results.map(x=>x.status).sort(),['fulfilled','rejected']);assert.equal(issued,2);
+});
+test('a failed issuer consumes the approval and prevents replay',async()=>{
+ const m=manager({issueCallback:async()=>{throw new Error('issuer unavailable');}});const s=await m.create(requests);m.approve({...s,principal:'user',accepted:true});await assert.rejects(m.redeem(s));await assert.rejects(m.redeem(s),/invalid-redemption/);
+});

package/test/broker-grants.test.js

@@ -0,0 +1,14 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {createBrokerGrantProvider,CLIENT_ID}=require('../src/desktop/broker-grants');
+test('refreshes and commits a separate guard-scoped grant',async()=>{
+ let saved={accessToken:'expired',refreshToken:'previous',expiresAt:1},calls=0;
+ const store={async get(){return saved;},async update(fn){saved=await fn(saved);return saved;}};
+ const provider=createBrokerGrantProvider({store,now:()=>100000,fetchImpl:async(url,options)=>{calls++;assert.equal(options.body.get('client_id'),CLIENT_ID);assert.equal(options.body.get('refresh_token'),'previous');return new Response(JSON.stringify({token_type:'Bearer',scope:'slaunt:guard',access_token:'fresh',refresh_token:'next',expires_in:3600}));}});
+ assert.equal((await provider.getFreshTokens()).accessToken,'fresh');assert.equal(saved.refreshToken,'next');assert.equal((await provider.getFreshTokens()).accessToken,'fresh');assert.equal(calls,1);
+});
+test('rejects a general-purpose or malformed grant without saving it',async()=>{
+ let saved={accessToken:'expired',refreshToken:'old',expiresAt:1};const store={async get(){return saved;},async update(fn){saved=await fn(saved);return saved;}};
+ const provider=createBrokerGrantProvider({store,now:()=>100000,fetchImpl:async()=>new Response(JSON.stringify({token_type:'Bearer',scope:'mcp:tools',access_token:'fresh',refresh_token:'next',expires_in:3600}))});
+ await assert.rejects(provider.getFreshTokens(),/broker-refresh-invalid/);assert.equal(saved.refreshToken,'old');
+});

package/test/broker-keychain.test.js

@@ -0,0 +1,14 @@
+'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 {createBrokerKeychain}=require('../src/desktop/broker-keychain');
+test('grant bridge sends data over stdin and serializes updates',async()=>{
+ const dir=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-broker-store-test-')),app=path.join(dir,'SlauntKillBar.app'),binary=path.join(app,'Contents/MacOS/SlauntKillBar'),data=path.join(dir,'fixture.json');
+ try{
+  await fs.mkdir(path.dirname(binary),{recursive:true});
+  await fs.writeFile(binary,`#!/bin/sh\ncase "$1" in\n--broker-grant-read) cat '${data}';;\n--broker-grant-create-stdin|--broker-grant-update-stdin) cat > '${data}';;\n*) exit 1;;\nesac\n`,{mode:0o700});
+  const store=createBrokerKeychain({app,verify:async()=>{}});await store.save({count:0});
+  await Promise.all([store.update(async x=>({count:x.count+1})),store.update(async x=>({count:x.count+1}))]);
+  assert.equal((await store.get()).count,2);
+ }finally{await fs.rm(dir,{recursive:true,force:true});}
+});

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

@@ -0,0 +1,15 @@
+'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 {installBrokerLaunchAgent,brokerPlist}=require('../src/desktop/broker-launch-agent');
+test('launch agent registers the broker and checks its private socket',async()=>{
+ const home=await fs.mkdtemp(path.join(os.tmpdir(),'slaunt-launch-')),calls=[];
+ try{
+  await fs.mkdir(path.join(home,'Library/LaunchAgents'),{recursive:true,mode:0o700});
+  const result=await installBrokerLaunchAgent({home,platform:'darwin',exec:async(command,args)=>calls.push([command,args]),check:async()=>true});
+  assert.equal(result.registered,true);assert.ok(calls.some(([,args])=>args[0]==='bootstrap'));
+  const plist=await fs.readFile(path.join(home,'Library/LaunchAgents/ai.slaunt.claude-broker.plist'),'utf8');assert.match(plist,/broker-daemon\.js/);assert.match(plist,/<key>KeepAlive<\/key><true\/>/);
+  await assert.rejects(installBrokerLaunchAgent({home,platform:'darwin',exec:async()=>{},check:async()=>true}),/broker-existing-install/);
+ }finally{await fs.rm(home,{recursive:true,force:true});}
+});
+test('launch plist escapes arguments',()=>assert.match(brokerPlist({node:'/tmp/node&x',script:'/tmp/script'}),/node&amp;x/));

package/test/broker-service.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const fs=require('node:fs/promises');
+const {startBrokerService}=require('../src/desktop/broker-service');
+const {sendLifecycle}=require('../src/desktop/broker-hook-command');
+const {createNativeClaudeBroker}=require('../src/desktop/native-claude-broker');
+const {authorizeHook}=require('../src/desktop/tool-guard');
+const {health}=require('../src/desktop/broker-launch-agent');
+const path=require('node:path');
+test('persistent service creates isolated session connections and closes them on stop',async()=>{
+ const root=await fs.mkdtemp('/tmp/sb-'),events=[];
+ const service=await startBrokerService({root,grantProvider:{},connect:async()=>({async event(input){events.push(input);},async close(){events.push('closed');}})});
+ try{
+  await sendLifecycle({hook_event_name:'UserPromptSubmit',session_id:'one',prompt:'not sent'},{root});
+  await sendLifecycle({hook_event_name:'UserPromptSubmit',session_id:'two'},{root});
+  await sendLifecycle({hook_event_name:'Stop',session_id:'one'},{root});
+  assert.deepEqual(events,[{event_name:'UserPromptSubmit',session_id:'one'},{event_name:'UserPromptSubmit',session_id:'two'},{event_name:'Stop',session_id:'one'},'closed']);
+  await assert.rejects(startBrokerService({root,grantProvider:{}}),/broker-already-running/);
+ }finally{await service.close();await fs.rm(root,{recursive:true,force:true});}
+});
+test('service readiness waits for credential initialization',async()=>{
+ const root=await fs.mkdtemp('/tmp/sb-');let release;const waiting=new Promise(resolve=>{release=resolve;});
+ const started=startBrokerService({root,grantProvider:{},initialize:()=>waiting});
+ try{
+  let exists=false;for(let i=0;i<30;i++){try{await fs.lstat(path.join(root,'control.sock'));exists=true;break;}catch{await new Promise(r=>setTimeout(r,5));}}
+  assert.equal(exists,true);let result;const pending=health(path.join(root,'control.sock')).then(value=>{result=value;});
+  await new Promise(r=>setTimeout(r,30));assert.equal(result,undefined);release();const service=await started;await pending;assert.equal(result,true);await service.close();
+ }finally{release?.();await fs.rm(root,{recursive:true,force:true});}
+});
+test('lifecycle delivery binds a guard that enforces upstream allow and deny',async()=>{
+ const root=await fs.mkdtemp('/tmp/sb-'),guardRoot=await fs.mkdtemp('/tmp/sg-');let allow=true;
+ const client={async callTool({name,arguments:args}){return name==='tool_authorize'?{structuredContent:{decision:allow?'allow':'deny',...Object.fromEntries(['request_id','tool_use_id','tool_name','input_sha256'].map(k=>[k,args[k]]))}}:{content:[]};}};
+ const service=await startBrokerService({root,grantProvider:{},connect:async()=>{const broker=createNativeClaudeBroker({client,root:guardRoot});return {event:broker.event,async close(){broker.close();}};}});
+ const input={hook_event_name:'PreToolUse',session_id:'session',tool_name:'Bash',tool_use_id:'call',tool_input:{command:'true'}};
+ try{
+  await sendLifecycle({hook_event_name:'UserPromptSubmit',session_id:'session'},{root});
+  assert.equal((await authorizeHook({input,clientKey:'claude-code',root:guardRoot})).hookSpecificOutput.permissionDecision,undefined);
+  allow=false;assert.equal((await authorizeHook({input,clientKey:'claude-code',root:guardRoot})).hookSpecificOutput.permissionDecision,'deny');
+  await sendLifecycle({hook_event_name:'Stop',session_id:'session'},{root});
+  assert.equal((await authorizeHook({input,clientKey:'claude-code',root:guardRoot})).hookSpecificOutput.permissionDecision,'deny');
+ }finally{await service.close();await fs.rm(root,{recursive:true,force:true});await fs.rm(guardRoot,{recursive:true,force:true});}
+});

package/test/cli-auth-recovery.test.js

@@ -0,0 +1,15 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const {exchangeAuthorizationCode}=require('../src/cli-auth');
+test('retries an interrupted token response with the same code and PKCE verifier',async()=>{
+ const calls=[];let saved;
+ await exchangeAuthorizationCode({code:'test-code',codeVerifier:'test-verifier',sessionSink:{async save(value){saved=value;}},fetchImpl:async(_url,options)=>{
+  calls.push(options.body.toString());
+  if(calls.length===1)throw new Error('connection lost');
+  return Response.json({access_token:'access',refresh_token:'refresh',setup_ticket:'sat1.'+'a'.repeat(43),token_type:'Bearer',expires_in:3600,scope:'mcp:tools'});
+ }});
+ assert.equal(calls.length,2);assert.equal(calls[0],calls[1]);assert.equal(saved.accessToken,'access');
+});
+test('does not retry an explicit invalid-grant response',async()=>{
+ let calls=0;await assert.rejects(exchangeAuthorizationCode({code:'code',codeVerifier:'verifier',sessionSink:{async save(){}},fetchImpl:async()=>{calls++;return new Response('{}',{status:400});}}),/oauth-token-exchange-failed/);assert.equal(calls,1);
+});

package/test/codex-guard-supervisor.test.js

@@ -0,0 +1,25 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict');
+const fs=require('node:fs'),os=require('node:os'),path=require('node:path'),{spawnSync}=require('node:child_process');
+const supervisor=path.resolve(__dirname,'../src/setup/codex-guard-supervisor.js');
+function run(script) {
+ const dir=fs.mkdtempSync(path.join(os.tmpdir(),'slaunt-guard-'));
+ try { const file=path.join(dir,'guard');fs.writeFileSync(file,`#!/bin/sh\n${script}\n`,{mode:0o700});
+  const result=spawnSync(process.execPath,[supervisor,file],{input:'{"hook_event_name":"PreToolUse"}',encoding:'utf8',timeout:12000});
+  assert.equal(result.status,0);return JSON.parse(result.stdout).hookSpecificOutput;
+ } finally {fs.rmSync(dir,{recursive:true,force:true});}
+}
+test('supervisor forwards a valid guard permit and denial',()=>{
+ assert.deepEqual(run(`printf '%s' '{"hookSpecificOutput":{"hookEventName":"PreToolUse"}}'`),{hookEventName:'PreToolUse'});
+ assert.equal(run(`printf '%s' '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"blocked"}}'`).permissionDecision,'deny');
+});
+test('supervisor denies on crash, malformed output and unexpected permission decision',()=>{
+ for(const script of ['exit 1',`printf '%s' '{bad'`,`printf '%s' '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'`]) assert.equal(run(script).permissionDecision,'deny');
+});
+test('supervisor denies when guard cannot start',()=>{
+ const result=spawnSync(process.execPath,[supervisor,'/does-not-exist/slaunt-guard'],{input:'{}',encoding:'utf8',timeout:2000});
+ assert.equal(result.status,0);assert.equal(JSON.parse(result.stdout).hookSpecificOutput.permissionDecision,'deny');
+});
+test('supervisor denies when guard exceeds its own deadline',{timeout:13000},()=>{
+ assert.equal(run('exec sleep 30').permissionDecision,'deny');
+});