sekura 0.1.1 → 0.2.0

package/README.md

@@ -6,25 +6,36 @@ Connect your coding tool to [Sekura](https://sekura.ai) in one command.
 npx sekura@latest init
 ```
 
-Sekura is an AI red team as a service: it scans a GitHub repository you have granted it, exploits what it finds to prove each finding, and delivers a report. Its MCP server is remote, at `https://sekura.ai/mcp`, so this package runs no server and holds no credential. It writes that address into the coding tools on your machine, installs a skill that teaches the agent the quote-then-confirm rule, and gets out of the way.
+Sekura is an AI red team as a service: it scans a GitHub repository you have granted it, exploits what it finds to prove each finding, and delivers a report. Its MCP server is remote, at `https://sekura.ai/mcp`, so this package runs no server. It writes that address into the coding tools on your machine and installs a skill that teaches the agent the quote-then-confirm rule. Then it finishes getting started right in the terminal: it signs you in once, helps you install the GitHub App, and lets you pick a repository. When you open your coding tool, Sekura already works.
 
 ## What `init` does
 
 1. **Detects** the tools on this machine: Claude Code, Cursor, GitHub Copilot in VS Code, OpenAI Codex, Kiro, Cline, Zed, Antigravity, OpenCode, JetBrains Junie, Factory Droid, Tabnine, Devin and Goose.
 2. **Asks** which to connect, and whether for every project (your user configuration) or this project only.
-3. **Shows the plan** before anything is written: each file and the exact entry, or the tool's own command.
-4. **Applies** it, one step at a time, and says what each did. Files that are not plain JSON (Zed's `settings.json` with comments, for one) are never rewritten; you are shown the lines to add instead.
-5. **Checks** that the Sekura server answers, and tells you how to sign in from each tool.
-
-Signing in happens in the tool: the first time it uses Sekura, a sekura.ai page opens in your browser. Sign in with GitHub and approve. Nothing to copy.
+3. **Signs you in** once, in your browser. You sign in with GitHub on sekura.ai and approve, and the CLI receives a Sekura key and gives it to each tool, so none of them asks you to sign in. Codex and Devin can't take a key in their configuration, so the CLI runs their own `mcp login` for you; since your browser is already signed in, that's one click.
+4. **Shows the plan** before anything is written: each file and the exact entry (with the key shown as `sek_live_…abcd`), or the tool's own command.
+5. **Applies** it, one step at a time, and says what each did. Files that are not plain JSON (Zed's `settings.json` with comments, for one) are never rewritten; you are shown the lines to add instead.
+6. **Checks** that the Sekura server answers.
+7. **Gets you to a first scan**:
+   - It says what your account still needs (the Terms, or email verification).
+   - It offers to install the Sekura GitHub App when nothing can be scanned yet, or when the repository in the current folder isn't covered.
+   - It lets you pick a repository, with the current folder's first.
+   - If your free first scan is still available, it opens sekura.ai so you can start it there.
+8. **Tells you what to type** in each tool, such as `/sekura scan owner/repo` in Claude Code (`/sekura help` lists every command).
+
+Skip the sign-in with `--no-login`; each tool then opens a sekura.ai sign-in page the first time it uses Sekura. Project scope never writes the key, because project files get committed.
 
 ```bash
 npx sekura@latest init --yes            # every detected tool, user scope, with the skill, no questions
 npx sekura@latest init --dry-run        # show the plan and change nothing
 npx sekura@latest init --scope project  # this project only: .mcp.json, .cursor/mcp.json, AGENTS.md …
 npx sekura@latest init --tools claude,cursor --no-skill
-npx sekura@latest status                # what is connected
-npx sekura@latest uninstall             # remove the entries, the skill and the guidance block
+npx sekura@latest init --no-login       # no sign-in here; each tool signs in on first use
+npx sekura@latest login                 # sign in again, give connected tools the key, pick a repository
+npx sekura@latest status                # what is connected, and who is signed in
+npx sekura@latest logout                # forget the saved key
+npx sekura@latest uninstall             # remove the entries, the skill, the guidance block and the saved key
+SEKURA_API_KEY=sek_live_… npx sekura@latest init --yes   # unattended, with a key from Settings
 ```
 
 ## What it writes
@@ -49,8 +60,11 @@ The skill goes to `~/.agents/skills/sekura/SKILL.md` and, when Claude Code is pr
 ## What stays untouched
 
 - Every other server, setting and file. The installer sets one key, `sekura`, and reads nothing else.
-- Your source code. Nothing is read, uploaded or committed.
-- Your credentials. There is no login step and no token on disk; the sign-in is the tool's own OAuth flow with sekura.ai.
+- Your source code isn't read or uploaded by this installer.
+
+## Your key
+
+Signing in creates one Sekura key, named "Sekura CLI (your computer's name)". You can see it and revoke it at [sekura.ai/app/settings](https://sekura.ai/app/settings) → Agents and API keys. The CLI saves it in `~/.config/sekura/credentials.json`, readable by you only, and writes it as an `Authorization: Bearer` header into each tool's user configuration. `sekura uninstall` removes both, and `sekura logout` removes the saved copy. Revoking the key in Settings ends it everywhere; run `sekura login` to get a new one.
 
 Review before running: the source is this repository, the package is [`sekura` on npm](https://www.npmjs.com/package/sekura), and `--dry-run` prints every write the wizard would make.
 

package/dist/api.js

@@ -0,0 +1,42 @@
+// The few Sekura tools the CLI calls itself, over the same MCP endpoint the
+// coding tools use. The server is stateless JSON-RPC over POST and answers
+// in plain JSON, so no session and no MCP library: one request per call.
+// Only tools that read are called here; every scan is still quoted and
+// agreed in the coding tool, or started by the person on sekura.ai.
+import { ENDPOINT } from './catalogue.js';
+export class SignedOut extends Error {
+    constructor(detail) { super(detail); this.name = 'SignedOut'; }
+}
+let nextId = 1;
+export async function callTool(key, name, args = {}) {
+    const r = await fetch(ENDPOINT, {
+        method: 'POST',
+        headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json', accept: 'application/json, text/event-stream' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: nextId++, method: 'tools/call', params: { name, arguments: args } }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    const body = (await r.json().catch(() => null));
+    if (r.status === 401)
+        throw new SignedOut(body?.error_description || 'the key is no longer valid');
+    if (!r.ok || !body)
+        throw new Error(`Sekura answered ${r.status} to ${name}${body?.error_description ? `: ${body.error_description}` : ''}`);
+    if (body.error)
+        throw new Error(`Sekura ${name}: ${body.error.message ?? JSON.stringify(body.error)}`);
+    const result = body.result ?? {};
+    if (result.isError)
+        throw new Error(`Sekura ${name}: ${result.content?.[0]?.text ?? 'failed'}`);
+    if (result.structuredContent)
+        return result.structuredContent;
+    // Older answers carry the data as JSON in the second text block.
+    for (const c of result.content ?? []) {
+        if (c?.type !== 'text')
+            continue;
+        try {
+            return JSON.parse(c.text);
+        }
+        catch { /* the prose block */ }
+    }
+    throw new Error(`Sekura ${name}: no data in the answer`);
+}
+export const getAccount = (key) => callTool(key, 'getAccount');
+export const listRepositories = (key) => callTool(key, 'listRepositories');

package/dist/auth.js

@@ -0,0 +1,172 @@
+// Signing in to Sekura from the terminal, once, so the tools do not have to.
+//
+// OAuth 2.1 against sekura.ai, the way the tools themselves do it: a client
+// registered on the spot (public, no secret), PKCE S256, and a loopback
+// redirect on a port picked per run (RFC 8252; sekura.ai accepts any port
+// on 127.0.0.1 for a client that registered a loopback URI). What comes back
+// is an ordinary `sek_live_` key with no expiry, listed and revocable under
+// Settings → Agents and API keys, bound to the MCP address (RFC 8707).
+//
+// The key is kept in ~/.config/sekura/credentials.json, readable by the
+// person only, so a rerun of `init` or `login` does not sign in again.
+// SEKURA_API_KEY in the environment wins over the file.
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { hostname, platform } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { ENDPOINT, home } from './catalogue.js';
+export const ISSUER = new URL(ENDPOINT).origin;
+export const credentialsPath = () => join(process.env.XDG_CONFIG_HOME || join(home(), '.config'), 'sekura', 'credentials.json');
+export function readKey() {
+    const env = process.env.SEKURA_API_KEY?.trim();
+    if (env)
+        return env;
+    try {
+        const c = JSON.parse(readFileSync(credentialsPath(), 'utf8'));
+        return typeof c.key === 'string' && c.key ? c.key : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveKey(key, email) {
+    const p = credentialsPath();
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify({ key, ...(email ? { email } : {}), createdAt: new Date().toISOString() }, null, 2) + '\n', { mode: 0o600 });
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch { /* Windows */ }
+    return p;
+}
+export function forgetKey() {
+    const p = credentialsPath();
+    if (!existsSync(p))
+        return false;
+    rmSync(p);
+    return true;
+}
+/** A key as it may be shown: the prefix and the last four characters. */
+export function redact(key) {
+    const m = /^(sek_[a-z]+_)/.exec(key);
+    return `${m ? m[1] : ''}…${key.slice(-4)}`;
+}
+/** Every key in a piece of text, redacted. */
+export const redactAll = (s) => s.replace(/sek_[a-z]+_[A-Za-z0-9]+/g, (k) => redact(k));
+// ── PKCE ───────────────────────────────────────────────────────────────────
+const b64url = (b) => b.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+export function pkce() {
+    const verifier = b64url(randomBytes(32));
+    return { verifier, challenge: b64url(createHash('sha256').update(verifier).digest()) };
+}
+// ── the browser ────────────────────────────────────────────────────────────
+/** Opens a URL in the default browser; false when there is none to ask. */
+export function openBrowser(url) {
+    const [cmd, args] = platform() === 'darwin' ? ['open', [url]]
+        : platform() === 'win32' ? ['cmd', ['/c', 'start', '""', url.replace(/&/g, '^&')]]
+            : ['xdg-open', [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── the loopback callback ──────────────────────────────────────────────────
+const PAGE = (title, body) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font:16px system-ui;max-width:32em;margin:4em auto;padding:0 1em"><h1 style="font-size:1.4em">${title}</h1><p>${body}</p>`;
+/** What one request to the callback means, given the state this run sent. */
+export function readCallback(url, state) {
+    if (url.pathname !== '/callback')
+        return null;
+    if (url.searchParams.get('state') !== state)
+        return { error: 'the sign-in came back with another state; start again' };
+    const iss = url.searchParams.get('iss');
+    if (iss !== null && iss !== ISSUER)
+        return { error: `the sign-in came back from ${iss}, not ${ISSUER}` };
+    const err = url.searchParams.get('error');
+    if (err)
+        return { error: url.searchParams.get('error_description') || err };
+    const code = url.searchParams.get('code');
+    return code ? { code } : { error: 'the sign-in came back without a code' };
+}
+/** Listens on 127.0.0.1, on a port the system picks, for one callback. */
+export async function listen(state, timeoutMs) {
+    let settle;
+    const result = new Promise((r) => { settle = r; });
+    const server = createServer((req, res) => {
+        const r = readCallback(new URL(req.url ?? '/', 'http://127.0.0.1'), state);
+        if (!r) {
+            res.writeHead(404).end();
+            return;
+        }
+        res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+        res.end('code' in r
+            ? PAGE('Signed in to Sekura', 'You can close this tab and go back to the terminal.')
+            : PAGE('Sekura could not sign you in', r.error.replace(/</g, '&lt;')));
+        settle(r);
+    });
+    await new Promise((ok, fail) => { server.once('error', fail); server.listen(0, '127.0.0.1', () => ok()); });
+    const port = server.address().port;
+    const timer = setTimeout(() => settle({ error: 'no answer from the browser in time' }), timeoutMs);
+    timer.unref();
+    const close = () => { clearTimeout(timer); server.close(); server.closeAllConnections?.(); };
+    return { redirectUri: `http://127.0.0.1:${port}/callback`, result, close };
+}
+// ── the flow ───────────────────────────────────────────────────────────────
+async function post(path, body, type) {
+    const r = await fetch(`${ISSUER}${path}`, { method: 'POST', headers: { 'content-type': type, accept: 'application/json' }, body });
+    const data = (await r.json().catch(() => ({})));
+    if (!r.ok)
+        throw new Error(`sekura.ai refused the sign-in (${path}): ${data.error_description || data.error || r.status}`);
+    return data;
+}
+/**
+ * Signs in in the browser and returns the key. `onUrl` is told the address
+ * before the browser is asked to open it, so it can be printed for a machine
+ * with no browser to open.
+ */
+export async function signIn(opts = {}) {
+    const state = b64url(randomBytes(16));
+    const { verifier, challenge } = pkce();
+    const cb = await listen(state, opts.timeoutMs ?? 300_000);
+    try {
+        const reg = await post('/oauth/register', JSON.stringify({
+            client_name: `Sekura CLI (${hostname().slice(0, 60)})`,
+            redirect_uris: ['http://127.0.0.1/callback'],
+            token_endpoint_auth_method: 'none',
+            grant_types: ['authorization_code'],
+            response_types: ['code'],
+        }), 'application/json');
+        const clientId = String(reg.client_id ?? '');
+        if (!clientId)
+            throw new Error('sekura.ai did not register the CLI');
+        const url = new URL(`${ISSUER}/oauth/authorize`);
+        for (const [k, v] of Object.entries({
+            response_type: 'code', client_id: clientId, redirect_uri: cb.redirectUri, state,
+            code_challenge: challenge, code_challenge_method: 'S256', scope: 'read write', resource: ENDPOINT,
+        }))
+            url.searchParams.set(k, v);
+        opts.onUrl?.(url.href);
+        if (opts.open !== false)
+            openBrowser(url.href);
+        const r = await cb.result;
+        if ('error' in r)
+            throw new Error(`Sekura sign-in: ${r.error}`);
+        const tok = await post('/oauth/token', new URLSearchParams({
+            grant_type: 'authorization_code', code: r.code, code_verifier: verifier,
+            client_id: clientId, redirect_uri: cb.redirectUri, resource: ENDPOINT,
+        }).toString(), 'application/x-www-form-urlencoded');
+        const key = String(tok.access_token ?? '');
+        if (!key)
+            throw new Error('sekura.ai answered without a key');
+        return key;
+    }
+    finally {
+        cb.close();
+    }
+}

package/dist/catalogue.js

@@ -69,13 +69,17 @@ export function onPath(bin) {
 const SIGN_IN = 'the first time the tool uses Sekura, a sekura.ai page opens in your browser: sign in with GitHub and approve.';
 const url = { url: ENDPOINT };
 const http = { type: 'http', url: ENDPOINT };
+/** The header a key is sent in, as JSON configurations spell it. */
+const auth = (key) => (key ? { headers: { Authorization: `Bearer ${key}` } } : {});
+/** True when a target sends a key, so its tool needs no sign-in. */
+export const carriesKey = (t) => JSON.stringify(t).includes('Bearer sek_');
 export const TOOLS = [
     {
         id: 'tools-claude', name: 'Claude Code',
         detect: (h) => existsSync(join(h, '.claude')) || existsSync(join(h, '.claude.json')) || onPath('claude'),
-        user: (h) => [
-            { kind: 'command', bin: 'claude', add: ['mcp', 'add', '--transport', 'http', '-s', 'user', SERVER_NAME, ENDPOINT], remove: ['mcp', 'remove', '-s', 'user', SERVER_NAME], get: ['mcp', 'get', SERVER_NAME] },
-            { kind: 'json', path: join(h, '.claude.json'), key: 'mcpServers', entry: http },
+        user: (h, key) => [
+            { kind: 'command', bin: 'claude', add: ['mcp', 'add', '--transport', 'http', '-s', 'user', SERVER_NAME, ENDPOINT, ...(key ? ['--header', `Authorization: Bearer ${key}`] : [])], remove: ['mcp', 'remove', '-s', 'user', SERVER_NAME], get: ['mcp', 'get', SERVER_NAME] },
+            { kind: 'json', path: join(h, '.claude.json'), key: 'mcpServers', entry: { ...http, ...auth(key) } },
         ],
         project: (cwd) => [{ kind: 'json', path: join(cwd, '.mcp.json'), key: 'mcpServers', entry: http }],
         signIn: `type /mcp in Claude Code, choose ${SERVER_NAME}, and sign in with GitHub.`,
@@ -83,14 +87,14 @@ export const TOOLS = [
     {
         id: 'tools-cursor', name: 'Cursor',
         detect: (h) => existsSync(join(h, '.cursor')) || onPath('cursor'),
-        user: (h) => [{ kind: 'json', path: join(h, '.cursor', 'mcp.json'), key: 'mcpServers', entry: url }],
+        user: (h, key) => [{ kind: 'json', path: join(h, '.cursor', 'mcp.json'), key: 'mcpServers', entry: { ...url, ...auth(key) } }],
         project: (cwd) => [{ kind: 'json', path: join(cwd, '.cursor', 'mcp.json'), key: 'mcpServers', entry: url }],
         signIn: SIGN_IN,
     },
     {
         id: 'tools-copilot', name: 'GitHub Copilot in VS Code',
         detect: (h) => existsSync(codeUserDir(h)),
-        user: (h) => [{ kind: 'json', path: join(codeUserDir(h), 'mcp.json'), key: 'servers', entry: http }],
+        user: (h, key) => [{ kind: 'json', path: join(codeUserDir(h), 'mcp.json'), key: 'servers', entry: { ...http, ...auth(key) } }],
         project: (cwd) => [{ kind: 'json', path: join(cwd, '.mcp.json'), key: 'mcpServers', entry: http }],
         signIn: SIGN_IN,
     },
@@ -102,11 +106,12 @@ export const TOOLS = [
             { kind: 'toml', path: join(h, '.codex', 'config.toml'), table: `mcp_servers.${SERVER_NAME}`, lines: [`url = "${ENDPOINT}"`] },
         ],
         signIn: `run codex mcp login ${SERVER_NAME}, or sign in when Codex first uses Sekura.`,
+        login: ['mcp', 'login', SERVER_NAME],
     },
     {
         id: 'tools-kiro', name: 'Kiro',
         detect: (h) => existsSync(join(h, '.kiro')) || onPath('kiro'),
-        user: (h) => [{ kind: 'json', path: join(h, '.kiro', 'settings', 'mcp.json'), key: 'mcpServers', entry: url }],
+        user: (h, key) => [{ kind: 'json', path: join(h, '.kiro', 'settings', 'mcp.json'), key: 'mcpServers', entry: { ...url, ...auth(key) } }],
         project: (cwd) => [{ kind: 'json', path: join(cwd, '.kiro', 'settings', 'mcp.json'), key: 'mcpServers', entry: url }],
         signIn: SIGN_IN,
     },
@@ -115,26 +120,26 @@ export const TOOLS = [
         // A fresh v4 install has no global-storage folder until the extension
         // writes one, so the installed extension and ~/.cline count too.
         detect: (h) => existsSync(join(h, '.cline')) || hasExtension(h, 'saoudrizwan.claude-dev') || existsSync(join(codeUserDir(h), 'globalStorage', 'saoudrizwan.claude-dev')),
-        user: (h) => [{ kind: 'json', path: clineSettingsPath(h), key: 'mcpServers', entry: { type: 'streamableHttp', url: ENDPOINT } }],
+        user: (h, key) => [{ kind: 'json', path: clineSettingsPath(h), key: 'mcpServers', entry: { type: 'streamableHttp', url: ENDPOINT, ...auth(key) } }],
         signIn: SIGN_IN,
     },
     {
         id: 'tools-zed', name: 'Zed',
         detect: (h) => existsSync(join(xdg(h), 'zed')) || onPath('zed'),
-        user: (h) => [{ kind: 'json', path: join(xdg(h), 'zed', 'settings.json'), key: 'context_servers', entry: url }],
+        user: (h, key) => [{ kind: 'json', path: join(xdg(h), 'zed', 'settings.json'), key: 'context_servers', entry: { ...url, ...auth(key) } }],
         signIn: `${SIGN_IN} Zed keeps the sign-in in your system keychain.`,
     },
     {
         id: 'tools-antigravity', name: 'Antigravity',
         detect: (h) => existsSync(join(h, '.gemini', 'config')),
-        user: (h) => [{ kind: 'json', path: join(h, '.gemini', 'config', 'mcp_config.json'), key: 'mcpServers', entry: { serverUrl: ENDPOINT } }],
+        user: (h, key) => [{ kind: 'json', path: join(h, '.gemini', 'config', 'mcp_config.json'), key: 'mcpServers', entry: { serverUrl: ENDPOINT, ...auth(key) } }],
         project: (cwd) => [{ kind: 'json', path: join(cwd, '.agents', 'mcp_config.json'), key: 'mcpServers', entry: { serverUrl: ENDPOINT } }],
         signIn: SIGN_IN,
     },
     {
         id: 'tools-opencode', name: 'OpenCode',
         detect: (h) => existsSync(join(xdg(h), 'opencode')) || onPath('opencode'),
-        user: (h) => [{ kind: 'json', path: join(xdg(h), 'opencode', 'opencode.json'), key: 'mcp', entry: { type: 'remote', url: ENDPOINT } }],
+        user: (h, key) => [{ kind: 'json', path: join(xdg(h), 'opencode', 'opencode.json'), key: 'mcp', entry: { type: 'remote', url: ENDPOINT, ...auth(key) } }],
         project: (cwd) => [{ kind: 'json', path: join(cwd, 'opencode.json'), key: 'mcp', entry: { type: 'remote', url: ENDPOINT } }],
         signIn: `OpenCode registers itself with Sekura and opens the sign-in on first use; ${SIGN_IN}`,
     },
@@ -165,15 +170,16 @@ export const TOOLS = [
         detect: () => onPath('devin'),
         user: () => [{ kind: 'command', bin: 'devin', add: ['mcp', 'add', SERVER_NAME, ENDPOINT], remove: ['mcp', 'remove', SERVER_NAME] }],
         signIn: `run devin mcp login ${SERVER_NAME}.`,
+        login: ['mcp', 'login', SERVER_NAME],
     },
     {
         id: 'tools-goose', name: 'Goose',
         detect: (h) => existsSync(gooseDir(h)) || onPath('goose'),
         // The streamable_http shape of Goose's ExtensionConfig (block/goose,
         // crates/goose/src/agents/extension.rs; documentation/docs/guides/config-files.md).
-        user: (h) => [{ kind: 'yaml', path: join(gooseDir(h), 'config.yaml'), key: 'extensions', lines: [
+        user: (h, key) => [{ kind: 'yaml', path: join(gooseDir(h), 'config.yaml'), key: 'extensions', lines: [
                     'type: streamable_http', `name: ${SERVER_NAME}`, 'enabled: true', `uri: ${ENDPOINT}`,
-                    'envs: {}', 'env_keys: []', 'headers: {}', 'timeout: 300', 'bundled: null', 'available_tools: []',
+                    'envs: {}', 'env_keys: []', key ? `headers: { Authorization: "Bearer ${key}" }` : 'headers: {}', 'timeout: 300', 'bundled: null', 'available_tools: []',
                 ] }],
         signIn: SIGN_IN,
     },

package/dist/cli.js

@@ -4,15 +4,17 @@
 //   npx sekura@latest init
 //
 // Sekura's MCP server is remote (https://sekura.ai/mcp), so this package
-// runs no server and holds no credential: it writes the server's address
-// into the tools on this machine, installs the skill that teaches an agent
-// the quote-then-confirm rule, and gets out of the way. Signing in happens
-// in the tool, on a sekura.ai page, the first time it uses Sekura.
+// runs no server: it writes the server's address into the tools on this
+// machine, installs the skill that teaches an agent the quote-then-confirm
+// rule, and then finishes getting started in the terminal. It signs in once
+// on a sekura.ai page and gives the resulting key to each tool, so none of
+// them asks, then helps with the GitHub App, a repository and the free scan.
 import { Command } from 'commander';
 import { createRequire } from 'node:module';
 import { initCommand } from './commands/init.js';
 import { statusCommand } from './commands/status.js';
 import { uninstallCommand } from './commands/uninstall.js';
+import { loginCommand, logoutCommand } from './commands/login.js';
 import { DOCS } from './catalogue.js';
 const { version } = createRequire(import.meta.url)('../package.json');
 const program = new Command();
@@ -21,8 +23,10 @@ program
     .description(`Connect your coding tool to Sekura.\n\n  npx sekura@latest init\n\nDocumentation: ${DOCS}`)
     .version(version)
     .addCommand(initCommand, { isDefault: false })
+    .addCommand(loginCommand)
     .addCommand(statusCommand)
-    .addCommand(uninstallCommand);
+    .addCommand(uninstallCommand)
+    .addCommand(logoutCommand);
 try {
     await program.parseAsync(process.argv);
 }

package/dist/commands/init.js

@@ -1,13 +1,16 @@
-// `sekura init`: detect, choose, review, apply, verify. Under a minute, and
-// nothing is written before the review is shown and (unless --yes) agreed.
+// `sekura init`: detect, choose, sign in, review, apply, verify, then the
+// rest of getting started (the GitHub App, a repository, the free scan) so
+// none of it is left for the coding tool. Nothing is written before the
+// review is shown and (unless --yes) agreed.
 import { Command } from 'commander';
 import { checkbox, confirm, select } from '@inquirer/prompts';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, resolve } from 'node:path';
-import { DOCS, ENDPOINT, TOOLS, home } from '../catalogue.js';
+import { DOCS, ENDPOINT, TOOLS, carriesKey, home } from '../catalogue.js';
 import { applyStep, buildPlan, describeStep, detectTools } from '../plan.js';
 import { verifyEndpoint } from '../verify.js';
+import { checkAccount, howToScan, obtainKey, offerFreeScan, pickRepository, runToolLogins } from '../guide.js';
 import { banner, cross, dot, say, tick } from '../ui.js';
 /** The home folder (or the top of the disk) is no project: project scope
  *  there would put AGENTS.md and .mcp.json in it for every tool to find. */
@@ -69,8 +72,16 @@ export async function runInit(opts) {
     if (opts.skill === undefined && interactive) {
         skill = await confirm({ message: 'Also install the sekura skill, which teaches the agent the quote-then-confirm rule?', default: true });
     }
-    // 3. The plan, shown before anything happens.
-    const plan = buildPlan({ tools: chosen, scope, skill, cwd });
+    // 3. Sign in once, here, so the key goes into each tool and none of them
+    // asks. Project files never carry it (they are committed), so project
+    // scope skips this. A dry run uses a key it already has, never a browser.
+    let session = null;
+    if (opts.login !== false && scope === 'user') {
+        say();
+        session = await obtainKey({ interactive: interactive && !opts.dryRun });
+    }
+    // 4. The plan, shown before anything happens.
+    const plan = buildPlan({ tools: chosen, scope, skill, cwd, key: session?.key });
     say();
     say(opts.dryRun ? '  Dry run. This would:' : '  This will:');
     for (const s of plan.steps)
@@ -85,7 +96,7 @@ export async function runInit(opts) {
         say('  Nothing was changed.');
         return { written: 0, byHand: 0, failed: 0 };
     }
-    // 4. Apply, one step at a time, saying what each did.
+    // 5. Apply, one step at a time, saying what each did.
     let written = 0, byHand = 0, failed = 0;
     const signIns = new Map();
     for (const s of plan.steps) {
@@ -113,20 +124,41 @@ export async function runInit(opts) {
                 break;
         }
         if (s.kind === 'tool' && (r.status === 'written' || r.status === 'ran' || r.status === 'unchanged'))
-            signIns.set(s.tool.name, s.tool.signIn);
+            signIns.set(s.tool.name, carriesKey(s.target) ? null : s.tool.signIn);
     }
-    // 5. Verify the address, and say what comes next.
+    // Tools whose entry cannot carry the key sign in with their own command,
+    // now, while the browser is signed in to sekura.ai.
+    if (session)
+        for (const name of await runToolLogins(plan.steps.filter((s) => s.kind === 'tool' && signIns.has(s.tool.name)), interactive))
+            signIns.set(name, null);
+    // 6. Verify the address.
     if (opts.verify !== false) {
         const v = await verifyEndpoint(ENDPOINT);
         say(`${v.ok ? tick : cross} ${v.detail}`);
     }
+    // 7. The account, a repository and the free scan, with the key.
+    let repo = null;
+    if (session && signIns.size) {
+        say();
+        await checkAccount(session, interactive);
+        repo = await pickRepository(session, cwd, interactive);
+        await offerFreeScan(session, repo, interactive);
+    }
+    // 8. What is left, per tool.
     say();
     if (signIns.size) {
-        say('  Next, sign in once per tool:');
-        for (const [name, how] of signIns)
-            say(`${dot} ${name}: ${how}`);
+        const ready = [...signIns].filter(([, how]) => how === null).map(([name]) => name);
+        const pending = [...signIns].filter(([, how]) => how !== null);
+        if (ready.length)
+            say(`${tick} Ready, no sign-in needed: ${ready.join(', ')}`);
+        if (pending.length) {
+            say('  Sign in once per tool:');
+            for (const [name, how] of pending)
+                say(`${dot} ${name}: ${how}`);
+        }
+        say();
+        howToScan([...signIns.keys()], repo);
         say();
-        say('  Then ask it which of your repositories Sekura can scan, and for a quote to scan one.');
     }
     say(`  Documentation and every other tool: ${DOCS}`);
     say();
@@ -134,13 +166,14 @@ export async function runInit(opts) {
 }
 export const initCommand = new Command('init')
     .description('Connect the coding tools on this machine to Sekura, and install the sekura skill.')
-    .option('-y, --yes', 'apply without asking; every detected tool, user scope, with the skill')
+    .option('-y, --yes', 'apply without asking; every detected tool, user scope, with the skill, and the key in SEKURA_API_KEY or saved by sekura login')
     .option('--no-skill', 'the MCP server only: no skill, no guidance block')
     .option('--scope <scope>', 'user (every project) or project (this directory)', (v) => { if (v !== 'user' && v !== 'project')
     throw new Error('--scope is user or project'); return v; })
     .option('--tools <ids>', `only these, comma-separated: ${TOOLS.map((t) => t.id.replace('tools-', '')).join(', ')}`)
     .option('--dry-run', 'show the plan and change nothing')
     .option('--no-verify', 'do not check that the Sekura server answers')
+    .option('--no-login', 'do not sign in here; each tool signs in on first use')
     .action(async (opts) => {
     const r = await runInit(opts);
     process.exitCode = r.failed ? 1 : 0;

package/dist/commands/login.js

@@ -0,0 +1,73 @@
+// `sekura login`: sign in here and put the key into every tool already
+// connected, then the account, a repository and the free scan. For someone
+// who skipped the sign-in during init, revoked the key, or wants another
+// repository. `sekura logout`: forget the saved key.
+import { Command } from 'commander';
+import { applyStep, buildPlan, detectTools, stepPresent } from '../plan.js';
+import { carriesKey } from '../catalogue.js';
+import { credentialsPath, forgetKey } from '../auth.js';
+import { checkAccount, howToScan, obtainKey, offerFreeScan, pickRepository, runToolLogins } from '../guide.js';
+import { cross, dot, say, tick } from '../ui.js';
+export async function runLogin(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const interactive = !!(process.stdin.isTTY && process.stderr.isTTY);
+    say();
+    const session = await obtainKey({ interactive, ask: false });
+    if (!session) {
+        say('  Not signed in; nothing was changed.');
+        say();
+        return 1;
+    }
+    // The tools Sekura is already in (user scope), with or without a key,
+    // get the entry again with this key.
+    const ids = detectTools(cwd).map((t) => t.id);
+    const plain = buildPlan({ tools: ids, scope: 'user', skill: false, cwd });
+    const connected = plain.steps.flatMap((s) => (s.kind === 'tool' && stepPresent(s) !== false ? [s.tool.id] : []));
+    const keyed = buildPlan({ tools: connected, scope: 'user', skill: false, cwd, key: session.key });
+    let failed = 0;
+    const names = [];
+    if (keyed.steps.length)
+        say();
+    for (const s of keyed.steps) {
+        if (s.kind !== 'tool')
+            continue;
+        names.push(s.tool.name);
+        if (!carriesKey(s.target))
+            continue;
+        const r = applyStep(s);
+        if (r.status === 'written' || r.status === 'ran')
+            say(`${tick} ${s.tool.name}: ${r.where}`);
+        else if (r.status === 'unchanged')
+            say(`${tick} ${s.tool.name}: already has this key`);
+        else if (r.status === 'by-hand')
+            say(`${dot} ${s.tool.name}: ${r.where}: ${r.why}; add the header by hand with the key in ${credentialsPath()}`);
+        else if (r.status === 'failed') {
+            failed++;
+            say(`${cross} ${s.tool.name}: ${r.where}: ${r.why}`);
+        }
+    }
+    await runToolLogins(keyed.steps, interactive);
+    if (!names.length)
+        say(`${dot} No tool on this machine has Sekura yet: run sekura init.`);
+    say();
+    await checkAccount(session, interactive);
+    const repo = await pickRepository(session, cwd, interactive);
+    await offerFreeScan(session, repo, interactive);
+    if (names.length) {
+        say();
+        howToScan(names, repo);
+    }
+    say();
+    return failed;
+}
+export const loginCommand = new Command('login')
+    .description('Sign in to Sekura here, give the key to every connected tool, and pick a repository.')
+    .action(async () => { process.exitCode = (await runLogin({})) ? 1 : 0; });
+export const logoutCommand = new Command('logout')
+    .description('Forget the Sekura key saved on this machine.')
+    .action(() => {
+    say();
+    say(forgetKey() ? `${tick} Removed ${credentialsPath()}` : `${dot} No saved key at ${credentialsPath()}`);
+    say('  Tools that were given the key keep it until you run sekura uninstall. To end it everywhere: https://sekura.ai/app/settings → Agents and API keys.');
+    say();
+});

package/dist/commands/status.js

@@ -1,8 +1,10 @@
 // `sekura status`: which tools are here, which carry Sekura, and whether the
 // server answers. Reads only.
 import { Command } from 'commander';
-import { ENDPOINT } from '../catalogue.js';
+import { ENDPOINT, carriesKey } from '../catalogue.js';
 import { buildPlan, detectTools, stepPresent } from '../plan.js';
+import { readKey, redact } from '../auth.js';
+import { getAccount, SignedOut } from '../api.js';
 import { verifyEndpoint } from '../verify.js';
 import { cross, dot, say, tick } from '../ui.js';
 export async function runStatus(opts) {
@@ -12,20 +14,39 @@ export async function runStatus(opts) {
     say();
     if (!detected.length)
         say('  No supported coding tool found on this machine.');
-    const plan = buildPlan({ tools: detected.map((t) => t.id), scope, skill: true, cwd });
-    for (const s of plan.steps) {
-        const p = stepPresent(s);
+    const key = readKey();
+    const plan = buildPlan({ tools: detected.map((t) => t.id), scope, skill: true, cwd, key });
+    const plain = key ? buildPlan({ tools: detected.map((t) => t.id), scope, skill: true, cwd }) : plan;
+    plan.steps.forEach((s, i) => {
+        let p = stepPresent(s);
+        // An entry without the key is still connected; its tool signs in itself.
+        let how = s.kind === 'tool' && p === true && carriesKey(s.target) ? ' (with your key)' : '';
+        if (s.kind === 'tool' && p !== true && plain !== plan && stepPresent(plain.steps[i]) === true) {
+            p = true;
+            how = ' (signs in in the tool)';
+        }
         const mark = p === true ? tick : p === 'unknown' ? dot : cross;
         const noun = s.kind === 'tool' ? 'connected' : 'installed';
-        const word = p === true ? noun : p === 'unknown' ? (s.kind === 'tool' && s.target.kind === 'command' ? 'kept by the tool itself; ask it' : 'its file has comments; look by hand') : `not ${noun}`;
+        const word = p === true ? noun + how : p === 'unknown' ? (s.kind === 'tool' && s.target.kind === 'command' ? 'kept by the tool itself; ask it' : 'its file has comments; look by hand') : `not ${noun}`;
         const label = s.kind === 'tool' ? s.tool.name : s.kind === 'skill' ? `skill ${s.path}` : `guidance ${s.path}`;
         say(`${mark} ${label}: ${word}`);
-    }
+    });
     for (const s of plan.skipped)
         say(`${dot} ${s.tool.name}: ${s.why}`);
     if (opts.verify !== false) {
         const v = await verifyEndpoint(ENDPOINT);
         say(`${v.ok ? tick : cross} ${v.detail}`);
+        if (key) {
+            try {
+                const a = await getAccount(key);
+                say(`${tick} Signed in to Sekura as ${a.email ?? a.name ?? redact(key)}`);
+            }
+            catch (e) {
+                say(`${cross} The saved key ${redact(key)} ${e instanceof SignedOut ? 'no longer works: run sekura login' : `could not be checked: ${e.message}`}`);
+            }
+        }
+        else
+            say(`${dot} Not signed in here: run sekura login to give your tools a key`);
     }
     say();
 }

package/dist/commands/uninstall.js

@@ -6,6 +6,7 @@
 import { Command } from 'commander';
 import { confirm } from '@inquirer/prompts';
 import { buildPlan, describeStep, detectTools, removeStep } from '../plan.js';
+import { credentialsPath, forgetKey } from '../auth.js';
 import { cross, dot, say, tick } from '../ui.js';
 export async function runUninstall(opts) {
     const cwd = opts.cwd ?? process.cwd();
@@ -16,6 +17,8 @@ export async function runUninstall(opts) {
     say('  This will remove Sekura from:');
     for (const s of plan.steps)
         say(`${dot} ${describeStep(s).split(':')[0]}`);
+    if (!opts.keepLogin)
+        say(`${dot} the saved key, ${credentialsPath()}`);
     say('  and change nothing else.');
     say();
     if (interactive && !(await confirm({ message: 'Remove?', default: false }))) {
@@ -38,6 +41,8 @@ export async function runUninstall(opts) {
             say(`${cross} ${r.where}: ${'why' in r ? r.why : r.status}`);
         }
     }
+    if (!opts.keepLogin && forgetKey())
+        say(`${tick} ${credentialsPath()}`);
     say();
     say('  To end the connection on Sekura\'s side too: https://sekura.ai/app/settings → Agents and API keys.');
     say();
@@ -47,6 +52,7 @@ export const uninstallCommand = new Command('uninstall')
     .description('Remove Sekura from every tool on this machine, and the skill.')
     .option('-y, --yes', 'remove without asking')
     .option('--keep-skill', 'leave the skill and the guidance block in place')
+    .option('--keep-login', 'leave the saved Sekura key in place')
     .option('--scope <scope>', 'user or project', 'user')
     .action(async (opts) => {
     process.exitCode = (await runUninstall(opts)) ? 1 : 0;

package/dist/guide.js

@@ -0,0 +1,215 @@
+// The steps after the install that used to happen inside the coding tool:
+// signing in, the GitHub App, a repository, and the free first scan. Shared
+// by `init` and `login`. Nothing here starts a scan or charges anything: the
+// free scan is started by the person on sekura.ai, and every other scan is
+// quoted and agreed in the coding tool.
+import { confirm, input, select } from '@inquirer/prompts';
+import { spawnSync } from 'node:child_process';
+import { forgetKey, openBrowser, readKey, redact, saveKey, signIn } from './auth.js';
+import { getAccount, listRepositories, SignedOut } from './api.js';
+import { carriesKey, onPath, SERVER_NAME } from './catalogue.js';
+import { currentGithubRepo } from './repo.js';
+import { cross, dot, say, tick } from './ui.js';
+const START = 'https://sekura.ai/app/start';
+const DASHBOARD = 'https://sekura.ai/app';
+/**
+ * A key that works: SEKURA_API_KEY, the stored one, or a fresh sign-in in
+ * the browser when the person agrees. Null when there is none, and the tools
+ * then sign in on their own, as they always could.
+ */
+export async function obtainKey(opts) {
+    const fromEnv = !!process.env.SEKURA_API_KEY?.trim();
+    const existing = readKey();
+    if (existing) {
+        try {
+            const account = await getAccount(existing);
+            say(`${tick} Signed in to Sekura as ${account.email ?? account.name ?? redact(existing)}${fromEnv ? ' (SEKURA_API_KEY)' : ''}`);
+            return { key: existing, account };
+        }
+        catch (e) {
+            if (!(e instanceof SignedOut)) {
+                // Offline, or Sekura did not answer: the key is likely fine, and
+                // writing it now saves the person a sign-in later.
+                say(`${dot} Using your saved Sekura key ${redact(existing)}; Sekura could not be asked who it belongs to (${e.message}).`);
+                return { key: existing, account: null };
+            }
+            if (fromEnv) {
+                say(`${cross} SEKURA_API_KEY is not a valid Sekura key (${e.message}); it was not used.`);
+                return null;
+            }
+            forgetKey();
+            say(`${dot} Your saved Sekura key no longer works (${e.message}); sign in again.`);
+        }
+    }
+    if (!opts.interactive)
+        return null;
+    if (opts.ask !== false && !(await confirm({ message: 'Sign in to Sekura now, so your tools do not have to? (opens your browser)', default: true })))
+        return null;
+    try {
+        const key = await signIn({
+            onUrl: (url) => { say(); say('  Opening your browser to sign in to Sekura with GitHub. If it does not open, go to:'); say(`  ${url}`); say(); },
+        });
+        let account = null;
+        try {
+            account = await getAccount(key);
+        }
+        catch { /* shown below as unknown */ }
+        const where = saveKey(key, account?.email);
+        say(`${tick} Signed in to Sekura as ${account?.email ?? account?.name ?? 'you'}; the key (${redact(key)}) is kept in ${where}`);
+        return { key, account };
+    }
+    catch (e) {
+        say(`${cross} ${e.message}`);
+        say('  Your tools will ask you to sign in the first time they use Sekura instead.');
+        return null;
+    }
+}
+/** What the account still needs before a scan can start, with the page for it. */
+export async function checkAccount(s, interactive) {
+    const a = s.account;
+    if (!a)
+        return;
+    const todo = [];
+    if (a.termsAccepted === false)
+        todo.push('accept the Terms');
+    if (a.emailVerified === false)
+        todo.push('verify your email');
+    if (!todo.length)
+        return;
+    const page = a.links?.dashboard ?? DASHBOARD;
+    say(`${dot} Before a scan can start, ${todo.join(' and ')} on sekura.ai: ${page}`);
+    if (interactive && (await confirm({ message: 'Open sekura.ai to do that now?', default: true }))) {
+        openBrowser(page);
+        await input({ message: 'Press Enter when you are done' });
+    }
+}
+const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+/**
+ * The repository to scan first: the one in this folder when Sekura can scan
+ * it, else the person's choice. Offers the GitHub App install when there is
+ * nothing to scan, or when this folder's repository is not covered.
+ */
+export async function pickRepository(s, cwd, interactive) {
+    const here = currentGithubRepo(cwd);
+    const start = s.account?.links?.start ?? START;
+    let repos = [];
+    for (let attempt = 0;; attempt++) {
+        let list;
+        try {
+            list = await listRepositories(s.key);
+        }
+        catch (e) {
+            say(`${cross} Could not list your repositories: ${e.message}`);
+            return null;
+        }
+        for (const i of list.installations) {
+            if (i.error === 'github_sign_in_expired')
+                say(`${dot} ${i.account}: GitHub access has expired; sign in at ${DASHBOARD} again to refresh it.`);
+            else if (i.error === 'installation_gone')
+                say(`${dot} ${i.account}: the Sekura GitHub App is no longer installed there.`);
+        }
+        repos = list.installations.flatMap((i) => i.repositories);
+        const covered = !!here && repos.some((r) => same(r.fullName, here));
+        if (repos.length && (!here || covered))
+            break;
+        say(repos.length
+            ? `${dot} ${here} (this folder) is not one Sekura can scan yet: the Sekura GitHub App needs access to it.`
+            : `${dot} The Sekura GitHub App is not installed on any of your GitHub accounts yet, so there is nothing to scan.`);
+        if (!interactive) {
+            say(`  Install it and choose repositories at ${start}`);
+            break;
+        }
+        if (attempt >= 3)
+            break;
+        const go = await select({
+            message: repos.length ? `Give Sekura access to ${here}?` : 'Install the Sekura GitHub App?',
+            choices: [
+                { name: 'Yes, open sekura.ai (the GitHub App asks which repositories)', value: true },
+                { name: repos.length ? 'No, pick from the repositories Sekura can already scan' : 'Not now', value: false },
+            ],
+        });
+        if (!go)
+            break;
+        openBrowser(start);
+        say(`  Opened ${start}`);
+        await input({ message: 'Press Enter once the GitHub App is installed' });
+    }
+    const scannable = repos.filter((r) => !r.empty);
+    if (!scannable.length)
+        return null;
+    const hereRepo = here ? scannable.find((r) => same(r.fullName, here)) : undefined;
+    if (!interactive)
+        return hereRepo?.fullName ?? null;
+    if (scannable.length === 1) {
+        say(`${tick} Repository: ${scannable[0].fullName}`);
+        return scannable[0].fullName;
+    }
+    const ordered = hereRepo ? [hereRepo, ...repos.filter((r) => r !== hereRepo)] : repos;
+    const picked = await select({
+        message: 'Which repository should Sekura scan first?',
+        pageSize: 12,
+        choices: [
+            ...ordered.map((r) => ({
+                name: `${r.fullName}${r === hereRepo ? ' (this folder)' : ''}${r.private ? ' (private)' : ''}`,
+                value: r.fullName,
+                disabled: r.empty ? '(empty, nothing to scan)' : false,
+            })),
+            { name: 'Skip for now', value: '' },
+        ],
+    });
+    return picked || null;
+}
+/** The free first scan, which only sekura.ai starts, when it is still there. */
+export async function offerFreeScan(s, repo, interactive) {
+    if (!s.account?.freeScanAvailable)
+        return false;
+    const start = s.account.links?.start ?? START;
+    say();
+    say(`  Your free first scan is still available. It is started on sekura.ai${repo ? `: choose ${repo} there` : ''}.`);
+    if (interactive && (await confirm({ message: `Open sekura.ai to start your free scan${repo ? ` of ${repo}` : ''}?`, default: true }))) {
+        openBrowser(start);
+        say(`${tick} Opened ${start}`);
+        return true;
+    }
+    say(`  Start it any time at ${start}`);
+    return false;
+}
+/**
+ * Runs the tool's own sign-in for each written entry that could not carry
+ * the key (Codex, Devin). The browser is already signed in to sekura.ai, so
+ * each is one Approve. Returns the names of the tools signed in.
+ */
+export async function runToolLogins(steps, interactive) {
+    const done = new Set();
+    if (!interactive)
+        return done;
+    for (const s of steps) {
+        if (s.kind !== 'tool' || !s.tool.login || carriesKey(s.target))
+            continue;
+        const bin = s.target.kind === 'command' ? s.target.bin : null;
+        if (!bin || !onPath(bin))
+            continue;
+        const cmd = `${bin} ${s.tool.login.join(' ')}`;
+        if (!(await confirm({ message: `Sign ${s.tool.name} in to Sekura now? (runs ${cmd}; approve in the browser)`, default: true })))
+            continue;
+        const r = spawnSync(bin, s.tool.login, { stdio: 'inherit' });
+        if (r.status === 0) {
+            done.add(s.tool.name);
+            say(`${tick} ${s.tool.name} signed in`);
+        }
+        else
+            say(`${cross} ${cmd} did not finish; run it yourself later.`);
+    }
+    return done;
+}
+/** How to ask for a scan from each connected tool. */
+export function howToScan(tools, repo) {
+    const target = repo ?? 'owner/repo';
+    say('  To scan from your coding tool (every scan is quoted first and starts only after you agree):');
+    for (const name of tools) {
+        if (name === 'Claude Code')
+            say(`${dot} ${name}: /${SERVER_NAME} scan ${target}    (/${SERVER_NAME} help lists every command)`);
+        else
+            say(`${dot} ${name}: ask "scan ${target} with Sekura"`);
+    }
+}

package/dist/plan.js

@@ -10,6 +10,8 @@ export function detectTools(cwd = process.cwd()) {
     const h = home();
     return TOOLS.filter((t) => t.detect(h, cwd));
 }
+/** `key`, when given, is written into each user-scope entry that can carry
+ *  one (catalogue.ts); project scope never carries it. */
 export function buildPlan(opts) {
     const cwd = opts.cwd ?? process.cwd();
     const root = opts.scope === 'user' ? home() : cwd;
@@ -19,7 +21,7 @@ export function buildPlan(opts) {
         const tool = toolById(id);
         if (!tool)
             throw new Error(`no tool named ${id}; one of ${TOOLS.map((t) => t.id).join(', ')}`);
-        const targets = opts.scope === 'user' ? tool.user(home()) : tool.project?.(cwd);
+        const targets = opts.scope === 'user' ? tool.user(home(), opts.key ?? undefined) : tool.project?.(cwd);
         if (!targets) {
             skipped.push({ tool, why: 'has no project-level configuration; run with --scope user' });
             continue;

package/dist/repo.js

@@ -0,0 +1,14 @@
+// The GitHub repository the person is standing in, if any: offered first
+// when they pick one to scan.
+import { spawnSync } from 'node:child_process';
+/** `owner/repo` from a GitHub remote URL, or null for any other host. */
+export function parseGithubRemote(url) {
+    const m = /^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https?:\/\/(?:[^@/]+@)?github\.com\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i.exec(url.trim());
+    return m ? `${m[1]}/${m[2]}` : null;
+}
+export function currentGithubRepo(cwd) {
+    const r = spawnSync('git', ['config', '--get', 'remote.origin.url'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (r.error || r.status !== 0)
+        return null;
+    return parseGithubRemote(r.stdout);
+}

package/dist/ui.js

@@ -9,5 +9,6 @@ export function banner() {
     say();
     say('  Sekura — connect your coding tool');
     say('  Every scan is quoted first and started only after you agree.');
+    say('  Sign in once here, and your tools will not ask again.');
     say();
 }

package/dist/writers.js

@@ -15,9 +15,18 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { ENDPOINT, SERVER_NAME } from './catalogue.js';
-const describeJson = (t) => JSON.stringify({ [t.key]: { [SERVER_NAME]: t.entry } }, null, 2);
+import { redactAll } from './auth.js';
+// What is shown never carries a key: the review, the lines to add by hand
+// and a failed command all print it as sek_live_…abcd. Lines to add by hand
+// say where the whole key is kept instead.
+const describeJson = (t) => redactAll(JSON.stringify({ [t.key]: { [SERVER_NAME]: t.entry } }, null, 2));
+/** The key a target sends, if any. */
+const keyOf = (t) => /Bearer (sek_[a-z]+_[A-Za-z0-9]+)/.exec(JSON.stringify(t))?.[1] ?? null;
 /** What applying the target would do, for the review before any write. */
 export function describe(t, dryRun = false) {
+    return redactAll(describeRaw(t, dryRun));
+}
+function describeRaw(t, dryRun) {
     const verb = dryRun ? 'would ' : '';
     switch (t.kind) {
         case 'json': return `${verb}write ${t.path}: ${t.key}.${SERVER_NAME} = ${JSON.stringify(t.entry)}`;
@@ -169,18 +178,21 @@ function yamlFields(lines) {
 function yamlOk(t, entry) {
     const f = yamlFields(entry);
     const want = yamlFields(t.lines);
-    return f.type === want.type && f.uri === ENDPOINT && f.enabled === 'true';
+    // Goose may rewrite the header mapping in its own layout, so a key is
+    // looked for in the entry's text, not in one field's spelling.
+    const key = keyOf(t);
+    return f.type === want.type && f.uri === ENDPOINT && f.enabled === 'true' && (!key || entry.join('\n').includes(key));
 }
 const splitLines = (text) => text.replace(/\n$/, '').split('\n');
 export function applyYaml(t) {
     const text = existsSync(t.path) ? readFileSync(t.path, 'utf8') : '';
     if (/\t/.test(text.split('\n').filter((l) => /^\s/.test(l)).join(''))) {
-        return { status: 'by-hand', where: t.path, why: 'it is indented with tabs, which this installer will not rewrite', snippet: `${t.key}:\n${yamlBlock(t, '  ')}` };
+        return { status: 'by-hand', where: t.path, why: 'it is indented with tabs, which this installer will not rewrite', snippet: redactAll(`${t.key}:\n${yamlBlock(t, '  ')}`) };
     }
     const lines = text ? splitLines(text) : [];
     const at = yamlLayout(lines, t.key);
     if ('inline' in at) {
-        return { status: 'by-hand', where: t.path, why: `its ${t.key} is written on one line, which this installer will not rewrite`, snippet: `${t.key}:\n${yamlBlock(t, '  ')}` };
+        return { status: 'by-hand', where: t.path, why: `its ${t.key} is written on one line, which this installer will not rewrite`, snippet: redactAll(`${t.key}:\n${yamlBlock(t, '  ')}`) };
     }
     let out;
     if ('missing' in at) {
@@ -229,21 +241,24 @@ function spawn(bin, args) {
 }
 export function runCommand(bin, args) {
     const r = spawn(bin, args);
-    const where = `${bin} ${args.join(' ')}`;
+    const where = redactAll(`${bin} ${args.join(' ')}`);
     if (r.error)
         return { status: 'failed', where, why: r.error.message };
     if (r.status !== 0)
-        return { status: 'failed', where, why: (r.stderr || r.stdout || `exit ${r.status}`).trim().split('\n').slice(-3).join(' ') };
+        return { status: 'failed', where, why: redactAll((r.stderr || r.stdout || `exit ${r.status}`).trim().split('\n').slice(-3).join(' ')) };
     return { status: 'ran', where };
 }
-/** Whether the tool's own command lists our entry at our address. */
+/** Whether the tool's own command lists our entry at our address, and with
+ *  our key when the entry carries one. A tool that does not print its
+ *  headers reads as not having it, and the entry is written again. */
 function commandHas(t) {
     if (!t.get)
         return 'unknown';
     const r = spawn(t.bin, t.get);
     if (r.error)
         return 'unknown';
-    return r.status === 0 && `${r.stdout}`.includes(ENDPOINT);
+    const key = keyOf(t);
+    return r.status === 0 && `${r.stdout}`.includes(ENDPOINT) && (!key || `${r.stdout}`.includes(key));
 }
 /** Adds the entry. A tool that refuses because the name is taken is asked
  *  what it holds: our address is "already there"; another one is replaced,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sekura",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Connect your coding tool to Sekura in one command: npx sekura@latest init",
   "type": "module",
   "license": "MIT",
@@ -37,7 +37,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && node -e \"require('fs').chmodSync('dist/cli.js', 0o755)\"",
-    "test": "npm run build && node --test test/init.test.mjs",
+    "test": "npm run build && node --test test/init.test.mjs test/login.test.mjs",
     "prepack": "npm run build"
   },
   "dependencies": {

package/skills/sekura/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: sekura
 description: Use when the user wants a GitHub repository scanned for vulnerabilities, wants to read scan findings or a report, or wants to put a repository on a recurring Sekura scan. Covers the sekura MCP tools and the rule that every scan and plan is quoted first and started only after the user agrees.
+argument-hint: "[help | repos | scan <owner/repo> | scans | scan-status <scan> | report <scan> | always <owner/repo>]"
 ---
 
 # Sekura
@@ -9,7 +10,58 @@ Sekura is an AI red team as a service. It scans a GitHub repository the user has
 granted it, exploits what it finds to prove each finding, and delivers a report.
 The `sekura` MCP server (https://sekura.ai/mcp) exposes it to this tool. Signing in is the
 user's GitHub login on sekura.ai: if a tool answers that the user is signed out,
-tell them to run `/mcp`, choose `sekura`, and approve in the browser.
+tell them to run `npx sekura@latest login` in a terminal (it signs in once and
+gives every tool the key), or to run `/mcp`, choose `sekura`, and approve in the
+browser.
+
+## Commands
+
+When the user types `/sekura` followed by arguments (here: `$ARGUMENTS`), read
+the first word:
+
+- `help`, `-h`, `--help` or `?`: reply with the help text below exactly as written,
+  and call no tool.
+- nothing: call `getAccount` and `listRepositories`, summarise who is signed in,
+  whether the free first scan is available, and the repositories Sekura can scan,
+  then end with "Type `/sekura help` for commands."
+- `repos`: `listRepositories`.
+- `scan <owner/repo>`: `startScan` for that repository. This answers with a quote;
+  the two-step rule below applies.
+- `scans`: `listScans`.
+- `scan-status <scan>`: `getScan`. `findings <scan>`: `getScanFindings`.
+- `report <scan>`: `getReportLink`.
+- `always <owner/repo>`: `startAlways`, quoted first like a scan.
+- `plans`: `getPlans`. `billing`: `getBilling`.
+- anything else: treat the whole text as an ordinary request about Sekura.
+
+The help text:
+
+```
+Sekura: AI red team scans for your GitHub repositories
+
+  /sekura                      account, free scan and repositories at a glance
+  /sekura repos                repositories Sekura can scan
+  /sekura scan <owner/repo>    quote a scan; it starts only after you agree
+  /sekura scans                your scans and their status
+  /sekura scan-status <scan>   one scan's progress
+  /sekura findings <scan>      a scan's findings, with proof
+  /sekura report <scan>        link to the report
+  /sekura always <owner/repo>  quote a recurring Sekura Always plan
+  /sekura plans                repositories on a recurring plan
+  /sekura billing              what is being billed
+  /sekura help                 this list
+
+Every scan and plan is quoted first (price and authorization) and started
+only after you say yes. Your free first scan is started on sekura.ai:
+https://sekura.ai/app/start
+
+Setup, in a terminal:
+  npx sekura@latest login      sign in again, or pick another repository
+  npx sekura@latest status     what is connected on this machine
+
+Add repositories: https://sekura.ai/app (the Sekura GitHub App)
+Documentation:    https://sekura.ai/connect/
+```
 
 ## Tools