sekura 0.1.0 → 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
@@ -36,21 +47,24 @@ npx sekura@latest uninstall             # remove the entries, the skill and the
 | GitHub Copilot (VS Code) | the VS Code user `mcp.json` → `servers.sekura` | `.mcp.json` |
 | OpenAI Codex | `codex mcp add sekura --url …`, or `~/.codex/config.toml` → `[mcp_servers.sekura]` | — |
 | Kiro | `~/.kiro/settings/mcp.json` | `.kiro/settings/mcp.json` |
-| Cline | `cline_mcp_settings.json` in VS Code's global storage | — |
+| Cline | `~/.cline/data/settings/cline_mcp_settings.json` (shared by the extension, v4 and later, and the Cline CLI) | — |
 | Zed | `~/.config/zed/settings.json` → `context_servers.sekura` (shown by hand when the file has comments) | — |
 | Antigravity | `~/.gemini/config/mcp_config.json` → `serverUrl` | `.agents/mcp_config.json` |
 | OpenCode | `~/.config/opencode/opencode.json` → `mcp.sekura` | `opencode.json` |
 | JetBrains Junie | — | `.junie/mcp/mcp.json` |
 | Factory Droid, Tabnine, Devin | the tool's own `mcp add` command | — |
-| Goose | a link to the page | — |
+| Goose | `~/.config/goose/config.yaml` → `extensions.sekura` (`streamable_http`) | — |
 
 The skill goes to `~/.agents/skills/sekura/SKILL.md` and, when Claude Code is present, `~/.claude/skills/sekura/SKILL.md`; in project scope to the same paths under the project, plus a section between `<!-- sekura:start -->` and `<!-- sekura:end -->` in `AGENTS.md` (and `CLAUDE.md` if one exists). Reruns replace only what sits between the markers.
 
 ## 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

@@ -9,7 +9,7 @@
 // A tool is "present" when its config directory exists or its binary is on
 // PATH. Presence decides what the wizard offers, never what it writes: the
 // person chooses, and a tool they did not choose is not touched.
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { join, delimiter } from 'node:path';
 export const ENDPOINT = 'https://sekura.ai/mcp';
@@ -17,7 +17,7 @@ export const SERVER_NAME = 'sekura';
 export const DOCS = 'https://sekura.ai/connect/';
 /** The home directory, overridable for tests. */
 export const home = () => process.env.SEKURA_HOME || homedir();
-/** VS Code's user directory, where Copilot's `mcp.json` and Cline's settings live. */
+/** VS Code's user directory, where Copilot's `mcp.json` lives. */
 export function codeUserDir(h = home()) {
     switch (platform()) {
         case 'darwin': return join(h, 'Library', 'Application Support', 'Code', 'User');
@@ -26,6 +26,34 @@ export function codeUserDir(h = home()) {
     }
 }
 const xdg = (h) => process.env.XDG_CONFIG_HOME || join(h, '.config');
+/** Cline's MCP settings. Since v4 the extension and the Cline CLI share one
+ *  file under ~/.cline/data (cline/cline, sdk/packages/shared/src/storage/
+ *  paths.ts, resolveMcpSettingsPath), with the same three overrides. The
+ *  file in VS Code's global storage is only migrated from, once per source,
+ *  so an entry written there after that is never read. */
+export function clineSettingsPath(h = home()) {
+    const explicit = process.env.CLINE_MCP_SETTINGS_PATH?.trim();
+    if (explicit)
+        return explicit;
+    const data = process.env.CLINE_DATA_DIR?.trim() || join(process.env.CLINE_DIR?.trim() || join(h, '.cline'), 'data');
+    return join(data, 'settings', 'cline_mcp_settings.json');
+}
+/** True when a VS Code extension is installed: its folder is `<publisher.name>-<version>`. */
+function hasExtension(h, id) {
+    try {
+        return readdirSync(join(h, '.vscode', 'extensions')).some((d) => d.toLowerCase().startsWith(`${id}-`));
+    }
+    catch {
+        return false;
+    }
+}
+/** Goose's config directory: ~/.config/goose on macOS and Linux (Goose uses
+ *  the XDG layout on both), %APPDATA%\Block\goose\config on Windows. */
+export function gooseDir(h = home()) {
+    if (platform() === 'win32')
+        return join(process.env.APPDATA || join(h, 'AppData', 'Roaming'), 'Block', 'goose', 'config');
+    return join(xdg(h), 'goose');
+}
 /** True when `bin` is an executable on PATH. */
 export function onPath(bin) {
     const exts = platform() === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
@@ -41,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] },
-            { 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.`,
@@ -55,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,
     },
@@ -74,37 +106,40 @@ 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,
     },
     {
         id: 'tools-cline', name: 'Cline',
-        detect: (h) => existsSync(join(codeUserDir(h), 'globalStorage', 'saoudrizwan.claude-dev')),
-        user: (h) => [{ kind: 'json', path: join(codeUserDir(h), 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'), key: 'mcpServers', entry: { type: 'streamableHttp', url: ENDPOINT } }],
+        // 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, 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}`,
     },
@@ -135,11 +170,17 @@ 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(join(xdg(h), 'goose')) || onPath('goose'),
-        user: () => [{ kind: 'link', href: `${DOCS}#tools-goose`, note: 'Goose takes a goose://extension link or goose configure; the page has both.' }],
+        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, 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: []', 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,11 +1,29 @@
-// `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 { DOCS, ENDPOINT, TOOLS } from '../catalogue.js';
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+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. */
+export function isProjectDir(cwd) {
+    const real = (p) => { try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    } };
+    const dir = real(cwd);
+    return dir !== real(home()) && dir !== real(homedir()) && dirname(dir) !== dir;
+}
 export async function runInit(opts) {
     const interactive = !opts.yes && process.stdin.isTTY && process.stderr.isTTY;
     const cwd = opts.cwd ?? process.cwd();
@@ -35,7 +53,13 @@ export async function runInit(opts) {
     }
     // 2. Scope and skill.
     let scope = opts.scope ?? 'user';
-    if (!opts.scope && interactive) {
+    const inProject = isProjectDir(cwd);
+    if (scope === 'project' && !inProject) {
+        say(`  ${cwd} is your home folder or the top of the disk, not a project: run sekura init --scope project inside the project, or use --scope user.`);
+        say('  Nothing was changed.');
+        return { written: 0, byHand: 0, failed: 1 };
+    }
+    if (!opts.scope && interactive && inProject) {
         scope = await select({
             message: 'Where',
             choices: [
@@ -48,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)
@@ -64,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) {
@@ -92,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();
@@ -113,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;