sekura 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sekura Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# sekura
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Connect your coding tool to [Sekura](https://sekura.ai) in one command.
+
+```bash
+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.
+
+## 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.
+
+```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
+```
+
+## What it writes
+
+| Tool | User scope | Project scope |
+|---|---|---|
+| Claude Code | `claude mcp add --transport http -s user sekura …`, or `~/.claude.json` → `mcpServers.sekura` | `.mcp.json` |
+| Cursor | `~/.cursor/mcp.json` → `mcpServers.sekura` | `.cursor/mcp.json` |
+| 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 | — |
+| 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 | — |
+
+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.
+
+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.
+
+## Every tool, by hand
+
+The page at [sekura.ai/connect](https://sekura.ai/connect/) has the file or screen for every tool, including the ones this installer cannot reach (claude.ai, Replit, Lovable, Bolt, v0, and the rest).
+
+## Licence
+
+MIT.

package/dist/catalogue.js

@@ -0,0 +1,155 @@
+// The tools `sekura init` can reach, and how each one takes a remote MCP
+// server. One entry per tool, in the order of https://sekura.ai/connect/
+// (docs/connector-master.md's order of reach). The config shapes are the
+// ones the website's catalogue documents and tests against each vendor's
+// docs (sekura-www, src/marketing/content/connect-tools.ts); a shape typed
+// here that differs from the website's would be a connector that installs
+// but never connects, so change both or neither.
+//
+// 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 { homedir, platform } from 'node:os';
+import { join, delimiter } from 'node:path';
+export const ENDPOINT = 'https://sekura.ai/mcp';
+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. */
+export function codeUserDir(h = home()) {
+    switch (platform()) {
+        case 'darwin': return join(h, 'Library', 'Application Support', 'Code', 'User');
+        case 'win32': return join(process.env.APPDATA || join(h, 'AppData', 'Roaming'), 'Code', 'User');
+        default: return join(process.env.XDG_CONFIG_HOME || join(h, '.config'), 'Code', 'User');
+    }
+}
+const xdg = (h) => process.env.XDG_CONFIG_HOME || join(h, '.config');
+/** True when `bin` is an executable on PATH. */
+export function onPath(bin) {
+    const exts = platform() === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const dir of (process.env.PATH || '').split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts)
+            if (existsSync(join(dir, bin + ext)))
+                return true;
+    }
+    return false;
+}
+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 };
+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 },
+        ],
+        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.`,
+    },
+    {
+        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 }],
+        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 }],
+        project: (cwd) => [{ kind: 'json', path: join(cwd, '.mcp.json'), key: 'mcpServers', entry: http }],
+        signIn: SIGN_IN,
+    },
+    {
+        id: 'tools-codex', name: 'OpenAI Codex',
+        detect: (h) => existsSync(join(h, '.codex')) || onPath('codex'),
+        user: (h) => [
+            { kind: 'command', bin: 'codex', add: ['mcp', 'add', SERVER_NAME, '--url', ENDPOINT], remove: ['mcp', 'remove', SERVER_NAME] },
+            { 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.`,
+    },
+    {
+        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 }],
+        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 } }],
+        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 }],
+        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 } }],
+        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 } }],
+        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}`,
+    },
+    {
+        id: 'tools-jetbrains', name: 'JetBrains Junie',
+        detect: (h, cwd) => existsSync(join(cwd, '.junie')) || existsSync(join(h, '.junie')),
+        user: () => [{ kind: 'link', href: `${DOCS}#tools-jetbrains`, note: 'Junie reads a project file; run sekura init --scope project in the project, or follow the page.' }],
+        project: (cwd) => [{ kind: 'json', path: join(cwd, '.junie', 'mcp', 'mcp.json'), key: 'mcpServers', entry: url }],
+        signIn: `type /mcp in Junie and sign in with GitHub.`,
+    },
+    {
+        id: 'tools-factory', name: 'Factory Droid',
+        detect: (h) => existsSync(join(h, '.factory')) || onPath('droid'),
+        user: () => [
+            { kind: 'command', bin: 'droid', add: ['mcp', 'add', SERVER_NAME, ENDPOINT, '--type', 'http'], remove: ['mcp', 'remove', SERVER_NAME] },
+            { kind: 'link', href: `${DOCS}#tools-factory`, note: 'droid is not on PATH; run the command from the page in a terminal where it is.' },
+        ],
+        signIn: `type /mcp in Droid and sign in to ${SERVER_NAME}.`,
+    },
+    {
+        id: 'tools-tabnine', name: 'Tabnine CLI',
+        detect: () => onPath('tabnine'),
+        user: () => [{ kind: 'command', bin: 'tabnine', add: ['mcp', 'add', SERVER_NAME, ENDPOINT, '--type', 'http'], remove: ['mcp', 'remove', SERVER_NAME] }],
+        signIn: 'run /mcp auth in the Tabnine CLI.',
+    },
+    {
+        id: 'tools-devin', name: 'Devin Desktop and CLI',
+        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}.`,
+    },
+    {
+        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.' }],
+        signIn: SIGN_IN,
+    },
+];
+export const toolById = (id) => TOOLS.find((t) => t.id === id);
+/** The first target that can be applied: a command only when its binary is on PATH. */
+export function pickTarget(targets) {
+    for (const t of targets) {
+        if (t.kind === 'command' && !onPath(t.bin))
+            continue;
+        return t;
+    }
+    return null;
+}

package/dist/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// sekura: connect your coding tool to Sekura in one command.
+//
+//   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.
+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 { DOCS } from './catalogue.js';
+const { version } = createRequire(import.meta.url)('../package.json');
+const program = new Command();
+program
+    .name('sekura')
+    .description(`Connect your coding tool to Sekura.\n\n  npx sekura@latest init\n\nDocumentation: ${DOCS}`)
+    .version(version)
+    .addCommand(initCommand, { isDefault: false })
+    .addCommand(statusCommand)
+    .addCommand(uninstallCommand);
+try {
+    await program.parseAsync(process.argv);
+}
+catch (e) {
+    // Ctrl-C inside a prompt is an exit, not an error.
+    if (e?.name === 'ExitPromptError')
+        process.exit(130);
+    process.stderr.write(`\n  ${e.message}\n\n`);
+    process.exit(1);
+}

package/dist/commands/init.js

@@ -0,0 +1,126 @@
+// `sekura init`: detect, choose, review, apply, verify. Under a minute, and
+// 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 { applyStep, buildPlan, describeStep, detectTools } from '../plan.js';
+import { verifyEndpoint } from '../verify.js';
+import { banner, cross, dot, say, tick } from '../ui.js';
+export async function runInit(opts) {
+    const interactive = !opts.yes && process.stdin.isTTY && process.stderr.isTTY;
+    const cwd = opts.cwd ?? process.cwd();
+    banner();
+    // 1. Detect.
+    const detected = detectTools(cwd);
+    let chosen;
+    if (opts.tools) {
+        chosen = opts.tools.split(',').map((s) => s.trim()).filter(Boolean).map((s) => (s.startsWith('tools-') ? s : `tools-${s}`));
+    }
+    else if (detected.length === 0) {
+        say('  No supported coding tool was found on this machine.');
+        say(`  Sekura connects to Claude Code, Cursor, GitHub Copilot, OpenAI Codex and nearly forty other tools; the page has every one: ${DOCS}`);
+        return { written: 0, byHand: 0, failed: 0 };
+    }
+    else if (!interactive) {
+        chosen = detected.map((t) => t.id);
+    }
+    else {
+        say(`  Found ${detected.length === 1 ? 'one tool' : `${detected.length} tools`}: ${detected.map((t) => t.name).join(', ')}`);
+        say();
+        chosen = await checkbox({
+            message: 'Connect Sekura to',
+            choices: detected.map((t) => ({ name: t.name, value: t.id, checked: true })),
+            required: true,
+        });
+    }
+    // 2. Scope and skill.
+    let scope = opts.scope ?? 'user';
+    if (!opts.scope && interactive) {
+        scope = await select({
+            message: 'Where',
+            choices: [
+                { name: 'For me, in every project (your user configuration)', value: 'user' },
+                { name: `This project only (${cwd})`, value: 'project' },
+            ],
+        });
+    }
+    let skill = opts.skill !== false;
+    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 });
+    say();
+    say(opts.dryRun ? '  Dry run. This would:' : '  This will:');
+    for (const s of plan.steps)
+        say(`${dot} ${describeStep(s, !!opts.dryRun)}`);
+    for (const s of plan.skipped)
+        say(`${dot} ${s.tool.name}: skipped, ${s.why}`);
+    say(`${dot} touch nothing else: other servers, settings and files stay as they are`);
+    say();
+    if (opts.dryRun)
+        return { written: 0, byHand: 0, failed: 0 };
+    if (interactive && !(await confirm({ message: 'Apply?', default: true }))) {
+        say('  Nothing was changed.');
+        return { written: 0, byHand: 0, failed: 0 };
+    }
+    // 4. 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) {
+        const r = applyStep(s);
+        switch (r.status) {
+            case 'written':
+            case 'ran':
+                written++;
+                say(`${tick} ${r.where}`);
+                break;
+            case 'removed':
+            case 'absent': break;
+            case 'unchanged':
+                say(`${tick} ${r.where} (already there)`);
+                break;
+            case 'by-hand':
+                byHand++;
+                say(`${cross} ${r.where}: ${r.why}`);
+                if (r.snippet)
+                    say(r.snippet.split('\n').map((l) => '      ' + l).join('\n'));
+                break;
+            case 'failed':
+                failed++;
+                say(`${cross} ${r.where}: ${r.why}`);
+                break;
+        }
+        if (s.kind === 'tool' && (r.status === 'written' || r.status === 'ran' || r.status === 'unchanged'))
+            signIns.set(s.tool.name, s.tool.signIn);
+    }
+    // 5. Verify the address, and say what comes next.
+    if (opts.verify !== false) {
+        const v = await verifyEndpoint(ENDPOINT);
+        say(`${v.ok ? tick : cross} ${v.detail}`);
+    }
+    say();
+    if (signIns.size) {
+        say('  Next, sign in once per tool:');
+        for (const [name, how] of signIns)
+            say(`${dot} ${name}: ${how}`);
+        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();
+    return { written, byHand, failed };
+}
+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('--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')
+    .action(async (opts) => {
+    const r = await runInit(opts);
+    process.exitCode = r.failed ? 1 : 0;
+});

package/dist/commands/status.js

@@ -0,0 +1,36 @@
+// `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 { buildPlan, detectTools, stepPresent } from '../plan.js';
+import { verifyEndpoint } from '../verify.js';
+import { cross, dot, say, tick } from '../ui.js';
+export async function runStatus(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const scope = opts.scope ?? 'user';
+    const detected = detectTools(cwd);
+    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 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 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}`);
+    }
+    say();
+}
+export const statusCommand = new Command('status')
+    .description('Show which tools on this machine are connected to Sekura.')
+    .option('--scope <scope>', 'user or project', 'user')
+    .option('--no-verify', 'do not check that the Sekura server answers')
+    .action(async (opts) => { await runStatus(opts); });

package/dist/commands/uninstall.js

@@ -0,0 +1,53 @@
+// `sekura uninstall`: take the sekura entry out of every tool it was written
+// to, and the skill and guidance with it unless asked to keep them. Nothing
+// else in any file is touched. Sign-ins the tool keeps in its own store (a
+// keychain entry, a token) are the tool's to forget; the connection can also
+// be revoked on sekura.ai under Settings → Agents and API keys.
+import { Command } from 'commander';
+import { confirm } from '@inquirer/prompts';
+import { buildPlan, describeStep, detectTools, removeStep } from '../plan.js';
+import { cross, dot, say, tick } from '../ui.js';
+export async function runUninstall(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const scope = opts.scope ?? 'user';
+    const interactive = !opts.yes && process.stdin.isTTY && process.stderr.isTTY;
+    const plan = buildPlan({ tools: detectTools(cwd).map((t) => t.id), scope, skill: !opts.keepSkill, cwd });
+    say();
+    say('  This will remove Sekura from:');
+    for (const s of plan.steps)
+        say(`${dot} ${describeStep(s).split(':')[0]}`);
+    say('  and change nothing else.');
+    say();
+    if (interactive && !(await confirm({ message: 'Remove?', default: false }))) {
+        say('  Nothing was changed.');
+        return 0;
+    }
+    let failed = 0;
+    for (const s of plan.steps) {
+        const r = removeStep(s);
+        if (r.status === 'removed' || r.status === 'ran')
+            say(`${tick} ${r.where}`);
+        else if (r.status === 'absent')
+            say(`${dot} ${r.where}: nothing to remove`);
+        // A file this installer never rewrites (comments) is one it never wrote
+        // to either; the person is told where to look, and nothing has failed.
+        else if (r.status === 'by-hand')
+            say(`${dot} ${r.where}: ${r.why}; ${r.snippet} by hand if it is there`);
+        else {
+            failed++;
+            say(`${cross} ${r.where}: ${'why' in r ? r.why : r.status}`);
+        }
+    }
+    say();
+    say('  To end the connection on Sekura\'s side too: https://sekura.ai/app/settings → Agents and API keys.');
+    say();
+    return failed;
+}
+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('--scope <scope>', 'user or project', 'user')
+    .action(async (opts) => {
+    process.exitCode = (await runUninstall(opts)) ? 1 : 0;
+});

package/dist/plan.js

@@ -0,0 +1,72 @@
+// The plan: what `init` would do on this machine for the tools the person
+// chose, built once and shown before anything is written, then applied
+// step by step. `status` and `uninstall` read the same plan, so the three
+// commands cannot disagree about where Sekura lives.
+import { existsSync } from 'node:fs';
+import { TOOLS, home, onPath, pickTarget, toolById } from './catalogue.js';
+import { apply, describe, has, remove } from './writers.js';
+import { guidanceFiles, hasGuidance, removeGuidance, removeSkill, skillPaths, writeGuidance, writeSkill } from './skill.js';
+export function detectTools(cwd = process.cwd()) {
+    const h = home();
+    return TOOLS.filter((t) => t.detect(h, cwd));
+}
+export function buildPlan(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const root = opts.scope === 'user' ? home() : cwd;
+    const steps = [];
+    const skipped = [];
+    for (const id of opts.tools) {
+        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);
+        if (!targets) {
+            skipped.push({ tool, why: 'has no project-level configuration; run with --scope user' });
+            continue;
+        }
+        const target = pickTarget(targets);
+        if (!target) {
+            skipped.push({ tool, why: 'its command is not on PATH' });
+            continue;
+        }
+        steps.push({ kind: 'tool', tool, target });
+    }
+    if (opts.skill) {
+        const claude = opts.tools.includes('tools-claude') || existsSync(`${home()}/.claude`) || onPath('claude');
+        for (const p of skillPaths(root, claude, opts.scope))
+            steps.push({ kind: 'skill', path: p });
+        if (opts.scope === 'project')
+            for (const p of guidanceFiles(cwd))
+                steps.push({ kind: 'guidance', path: p });
+    }
+    return { scope: opts.scope, root, steps, skipped };
+}
+export function describeStep(s, dryRun = false) {
+    const verb = dryRun ? 'would ' : '';
+    switch (s.kind) {
+        case 'tool': return `${s.tool.name}: ${describe(s.target, dryRun)}`;
+        case 'skill': return `skill: ${verb}write ${s.path}`;
+        case 'guidance': return `guidance: ${verb}add a marked Sekura section to ${s.path}`;
+    }
+}
+export function applyStep(s) {
+    switch (s.kind) {
+        case 'tool': return apply(s.target);
+        case 'skill': return writeSkill(s.path);
+        case 'guidance': return writeGuidance(s.path);
+    }
+}
+export function removeStep(s) {
+    switch (s.kind) {
+        case 'tool': return remove(s.target);
+        case 'skill': return removeSkill(s.path);
+        case 'guidance': return removeGuidance(s.path);
+    }
+}
+export function stepPresent(s) {
+    switch (s.kind) {
+        case 'tool': return has(s.target);
+        case 'skill': return existsSync(s.path);
+        case 'guidance': return hasGuidance(s.path);
+    }
+}

package/dist/skill.js

@@ -0,0 +1,91 @@
+// The skill and the guidance block: what teaches an agent the rule that
+// every Sekura scan is quoted first and started only after the person agrees.
+//
+// The skill is the one in sekuraai/sekura-plugins (the Claude Code plugin's
+// skills/sekura/SKILL.md), shipped inside this package so an install that
+// cannot reach GitHub still gets it. Written under ~/.agents/skills/ (the
+// Agent Skills location several tools read) and, where Claude Code is
+// present, under ~/.claude/skills/. In project scope the same two paths
+// under the project, plus a marked block in AGENTS.md (and CLAUDE.md when
+// one exists): reruns replace only what sits between the markers.
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DOCS, ENDPOINT, SERVER_NAME } from './catalogue.js';
+const here = dirname(fileURLToPath(import.meta.url));
+/** The packaged skill: dist/ sits beside skills/ in the published package. */
+export const SKILL_SOURCE = join(here, '..', 'skills', SERVER_NAME, 'SKILL.md');
+/** LF whatever the checkout did: a Windows clone with autocrlf would otherwise
+ *  install a skill whose every line ends in \r, and a rerun would rewrite it. */
+export const skillText = () => readFileSync(SKILL_SOURCE, 'utf8').replace(/\r\n/g, '\n');
+export function skillPaths(root, claude, scope) {
+    const out = [join(root, '.agents', 'skills', SERVER_NAME, 'SKILL.md')];
+    if (claude || (scope === 'project' && existsSync(join(root, '.claude'))))
+        out.push(join(root, '.claude', 'skills', SERVER_NAME, 'SKILL.md'));
+    return out;
+}
+export function writeSkill(path) {
+    const text = skillText();
+    if (existsSync(path) && readFileSync(path, 'utf8') === text)
+        return { status: 'unchanged', where: path };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text);
+    return { status: 'written', where: path };
+}
+export function removeSkill(path) {
+    if (!existsSync(path))
+        return { status: 'absent', where: path };
+    rmSync(dirname(path), { recursive: true, force: true });
+    return { status: 'removed', where: path };
+}
+// ── the guidance block ──────────────────────────────────────────────────────
+const START = '<!-- sekura:start -->';
+const END = '<!-- sekura:end -->';
+export const GUIDANCE = `${START}
+## Sekura
+
+Sekura (the \`${SERVER_NAME}\` MCP server, ${ENDPOINT}) scans a GitHub repository for
+vulnerabilities and proves each finding. Every scan or plan is quoted first: show
+the user the preview as it stands, with the price and the authorization sentence,
+and call the tool again only after they have agreed in the conversation. The
+\`${SERVER_NAME}\` skill (.agents/skills/${SERVER_NAME}/SKILL.md) has the tool names and the rules.
+Documentation: ${DOCS}
+${END}
+`;
+export function guidanceFiles(cwd) {
+    const out = [join(cwd, 'AGENTS.md')];
+    if (existsSync(join(cwd, 'CLAUDE.md')))
+        out.push(join(cwd, 'CLAUDE.md'));
+    return out;
+}
+export function writeGuidance(path) {
+    const text = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const a = text.indexOf(START), b = text.indexOf(END);
+    if (a >= 0 && b > a) {
+        const current = text.slice(a, b + END.length + 1);
+        if (current === GUIDANCE)
+            return { status: 'unchanged', where: path };
+        writeFileSync(path, text.slice(0, a) + GUIDANCE + text.slice(b + END.length).replace(/^\n/, ''));
+        return { status: 'written', where: path };
+    }
+    const sep = !text ? '' : text.endsWith('\n\n') ? '' : text.endsWith('\n') ? '\n' : '\n\n';
+    writeFileSync(path, text + sep + GUIDANCE);
+    return { status: 'written', where: path };
+}
+export function removeGuidance(path) {
+    if (!existsSync(path))
+        return { status: 'absent', where: path };
+    const text = readFileSync(path, 'utf8');
+    const a = text.indexOf(START), b = text.indexOf(END);
+    if (a < 0 || b < a)
+        return { status: 'absent', where: path };
+    const out = (text.slice(0, a) + text.slice(b + END.length).replace(/^\n/, '')).replace(/\n{3,}/g, '\n\n').replace(/\n+$/, '\n');
+    if (!out.trim())
+        rmSync(path);
+    else
+        writeFileSync(path, out);
+    return { status: 'removed', where: path };
+}
+export function hasGuidance(path) {
+    return existsSync(path) && readFileSync(path, 'utf8').includes(GUIDANCE);
+}

package/dist/ui.js

@@ -0,0 +1,13 @@
+// Output goes to stderr with plain words and no colour library, so it reads
+// the same in every terminal and in a log. stdout stays empty: the person
+// may pipe it.
+export const say = (s = '') => { process.stderr.write(s + '\n'); };
+export const tick = '  ✓';
+export const cross = '  ✗';
+export const dot = '  ·';
+export function banner() {
+    say();
+    say('  Sekura — connect your coding tool');
+    say('  Every scan is quoted first and started only after you agree.');
+    say();
+}

package/dist/verify.js

@@ -0,0 +1,25 @@
+// Is the Sekura MCP server answering? A keyless GET to the endpoint is a 401
+// in JSON (the server asks for a sign-in), and the protected-resource
+// document beside it is a 200. Anything else means the address this
+// installer wrote will not connect, which the person should hear now rather
+// than from their tool later.
+import { ENDPOINT } from './catalogue.js';
+export async function verifyEndpoint(endpoint = ENDPOINT, timeoutMs = 8000) {
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), timeoutMs);
+    try {
+        const r = await fetch(endpoint, { method: 'GET', headers: { accept: 'application/json' }, signal: ctl.signal, redirect: 'manual' });
+        const type = r.headers.get('content-type') || '';
+        if (r.status === 401 && type.includes('json'))
+            return { ok: true, detail: `${endpoint} answers 401 (sign-in required), as it should before you sign in` };
+        if (r.status === 200)
+            return { ok: true, detail: `${endpoint} answers 200` };
+        return { ok: false, detail: `${endpoint} answered ${r.status} ${type || ''}`.trim() };
+    }
+    catch (e) {
+        return { ok: false, detail: `${endpoint} could not be reached: ${e.message}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/writers.js

@@ -0,0 +1,164 @@
+// Writing one `sekura` entry into a tool's configuration, and taking it out
+// again, without touching anything else in the file.
+//
+// A JSON file is parsed, the entry set under its key, and the file written
+// back with the indent it had. A file that does not parse is never rewritten:
+// Zed's settings.json and OpenCode's opencode.jsonc may carry comments, and a
+// rewrite that dropped them would cost the person their own configuration to
+// save them a copy-paste. Such a file is reported with the lines to add by
+// hand. A TOML file (Codex) is edited as text: the table is appended when
+// absent, replaced when present, and the rest of the file is left byte for
+// byte.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { SERVER_NAME } from './catalogue.js';
+const describeJson = (t) => JSON.stringify({ [t.key]: { [SERVER_NAME]: t.entry } }, null, 2);
+/** What applying the target would do, for the review before any write. */
+export function describe(t, dryRun = false) {
+    const verb = dryRun ? 'would ' : '';
+    switch (t.kind) {
+        case 'json': return `${verb}write ${t.path}: ${t.key}.${SERVER_NAME} = ${JSON.stringify(t.entry)}`;
+        case 'toml': return `${verb}write ${t.path}: [${t.table}] ${t.lines.join('; ')}`;
+        case 'command': return `${verb}run ${t.bin} ${t.add.join(' ')}`;
+        case 'link': return `by hand: ${t.note} ${t.href}`;
+    }
+}
+function detectIndent(text) {
+    const m = /\n([ \t]+)"/.exec(text);
+    return m ? m[1] : 2;
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return { data: {}, indent: 2, trailingNewline: true };
+    const text = readFileSync(path, 'utf8');
+    if (!text.trim())
+        return { data: {}, indent: 2, trailingNewline: true };
+    try {
+        const data = JSON.parse(text);
+        if (!data || typeof data !== 'object' || Array.isArray(data))
+            return { invalid: 'its top level is not an object' };
+        return { data, indent: detectIndent(text), trailingNewline: text.endsWith('\n') };
+    }
+    catch {
+        return { invalid: 'it is not plain JSON (comments or trailing commas, which this tool allows and this installer will not rewrite)' };
+    }
+}
+export function applyJson(t) {
+    const r = readJson(t.path);
+    if ('invalid' in r)
+        return { status: 'by-hand', where: t.path, why: r.invalid, snippet: describeJson(t) };
+    const servers = (r.data[t.key] && typeof r.data[t.key] === 'object' ? r.data[t.key] : {});
+    const current = servers[SERVER_NAME];
+    if (current && JSON.stringify(current) === JSON.stringify(t.entry))
+        return { status: 'unchanged', where: t.path };
+    servers[SERVER_NAME] = t.entry;
+    r.data[t.key] = servers;
+    mkdirSync(dirname(t.path), { recursive: true });
+    writeFileSync(t.path, JSON.stringify(r.data, null, r.indent) + (r.trailingNewline ? '\n' : ''));
+    return { status: 'written', where: t.path };
+}
+export function removeJson(t) {
+    const r = readJson(t.path);
+    if ('invalid' in r)
+        return { status: 'by-hand', where: t.path, why: r.invalid, snippet: `remove ${t.key}.${SERVER_NAME}` };
+    const servers = r.data[t.key];
+    if (!servers || !(SERVER_NAME in servers))
+        return { status: 'absent', where: t.path };
+    delete servers[SERVER_NAME];
+    writeFileSync(t.path, JSON.stringify(r.data, null, r.indent) + (r.trailingNewline ? '\n' : ''));
+    return { status: 'removed', where: t.path };
+}
+/** Does this JSON file carry our entry as it should be? */
+export function hasJson(t) {
+    const r = readJson(t.path);
+    if ('invalid' in r)
+        return 'unreadable';
+    const servers = r.data[t.key];
+    return !!servers && JSON.stringify(servers[SERVER_NAME]) === JSON.stringify(t.entry);
+}
+// ── TOML, as text ───────────────────────────────────────────────────────────
+const tomlBlock = (t) => `[${t.table}]\n${t.lines.join('\n')}\n`;
+/** The span of `[table]` up to the next header or the end, or null. */
+function tomlSpan(text, table) {
+    const header = new RegExp(`^\\[${table.replace(/\./g, '\\.')}\\]\\s*$`, 'm');
+    const m = header.exec(text);
+    if (!m)
+        return null;
+    const rest = text.slice(m.index + m[0].length);
+    const next = /^\s*\[/m.exec(rest);
+    return [m.index, next ? m.index + m[0].length + next.index : text.length];
+}
+export function applyToml(t) {
+    const text = existsSync(t.path) ? readFileSync(t.path, 'utf8') : '';
+    const block = tomlBlock(t);
+    const span = tomlSpan(text, t.table);
+    if (span) {
+        const current = text.slice(span[0], span[1]).trim();
+        if (current === block.trim())
+            return { status: 'unchanged', where: t.path };
+        const out = text.slice(0, span[0]) + block + (text.slice(span[1]).startsWith('\n') ? '' : '\n') + text.slice(span[1]);
+        writeFileSync(t.path, out);
+        return { status: 'written', where: t.path };
+    }
+    mkdirSync(dirname(t.path), { recursive: true });
+    const sep = !text ? '' : text.endsWith('\n\n') ? '' : text.endsWith('\n') ? '\n' : '\n\n';
+    writeFileSync(t.path, text + sep + block);
+    return { status: 'written', where: t.path };
+}
+export function removeToml(t) {
+    if (!existsSync(t.path))
+        return { status: 'absent', where: t.path };
+    const text = readFileSync(t.path, 'utf8');
+    const span = tomlSpan(text, t.table);
+    if (!span)
+        return { status: 'absent', where: t.path };
+    writeFileSync(t.path, (text.slice(0, span[0]) + text.slice(span[1])).replace(/\n{3,}/g, '\n\n').replace(/\n+$/, '\n'));
+    return { status: 'removed', where: t.path };
+}
+export function hasToml(t) {
+    if (!existsSync(t.path))
+        return false;
+    const text = readFileSync(t.path, 'utf8');
+    const span = tomlSpan(text, t.table);
+    return !!span && text.slice(span[0], span[1]).trim() === tomlBlock(t).trim();
+}
+// ── commands ────────────────────────────────────────────────────────────────
+export function runCommand(bin, args) {
+    const r = spawnSync(bin, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    const where = `${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: 'ran', where };
+}
+// ── one door for the three kinds ────────────────────────────────────────────
+export function apply(t) {
+    switch (t.kind) {
+        case 'json': return applyJson(t);
+        case 'toml': return applyToml(t);
+        case 'command': return runCommand(t.bin, t.add);
+        case 'link': return { status: 'by-hand', where: t.href, why: t.note, snippet: '' };
+    }
+}
+export function remove(t) {
+    switch (t.kind) {
+        case 'json': return removeJson(t);
+        case 'toml': return removeToml(t);
+        case 'command': return runCommand(t.bin, t.remove);
+        case 'link': return { status: 'absent', where: t.href };
+    }
+}
+/** Present, absent, or unknowable (a command's own store, or a file with comments). */
+export function has(t) {
+    switch (t.kind) {
+        case 'json': {
+            const r = hasJson(t);
+            return r === 'unreadable' ? 'unknown' : r;
+        }
+        case 'toml': return hasToml(t);
+        case 'command': return 'unknown';
+        case 'link': return 'unknown';
+    }
+}

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "sekura",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Connect your coding tool to Sekura in one command: npx sekura@latest init",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://sekura.ai/connect/",
+  "repository": { "type": "git", "url": "git+https://github.com/sekuraai/sekura-cli.git" },
+  "bugs": { "url": "https://github.com/sekuraai/sekura-cli/issues" },
+  "author": "Sekura Inc. <hello@sekura.ai>",
+  "keywords": ["sekura", "mcp", "security", "vulnerability-scanning", "claude-code", "cursor", "copilot", "codex"],
+  "bin": { "sekura": "dist/cli.js" },
+  "files": ["dist", "skills", "README.md", "LICENSE"],
+  "engines": { "node": ">=18" },
+  "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",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.8.0",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}

package/skills/sekura/SKILL.md

@@ -0,0 +1,51 @@
+---
+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.
+---
+
+# Sekura
+
+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.
+
+## Tools
+
+Read, free, no confirmation:
+
+- `getAccount`: who is signed in, what is billed, and whether the account's free first scan is still available on sekura.ai.
+- `listRepositories`: the repositories the Sekura GitHub App is installed on.
+- `listScans`, `getScan`, `getScanFindings`, `getReportLink`: scans, their status, their findings and the report.
+- `getPlans`, `getBilling`: the repositories on a recurring plan, and a billing summary without card numbers.
+
+Write, each in two steps:
+
+- `startScan`: a Sekura Once scan of one repository.
+- `startAlways`: a recurring Sekura Always plan for one repository.
+- `runNow`: bring an Always plan's next scheduled run forward. Charges nothing.
+- `cancelScan`, `cancelPlan`: stop a scan, or end a plan.
+
+## The two-step rule
+
+Every write tool answers first with a preview: what will run, against which
+repository, under which authorization wording, and the price. Show that text to
+the user as it stands, including the price and the authorization sentence.
+Start nothing until the user has agreed in the conversation. Then call the same
+tool again with the arguments the preview names (`confirmArguments` in the
+JSON block). Never invent a confirmation argument, and never pass one before the
+user has said yes.
+
+A card is charged only after the user approves the quoted amount. If no card is
+on file, the answer carries a Stripe Checkout link: give it to the user and stop;
+the scan starts once they have paid on sekura.ai.
+
+## What to tell the user
+
+- The free first scan is taken on sekura.ai, never through this tool: when `getAccount` says it is still available, tell the user they can start it themselves at https://sekura.ai/app/start, and that a scan started here is Sekura Once at the quoted price.
+- A scan can take a while. Offer `getScan` to check on it rather than polling in a loop.
+- Findings carry proof. When summarising, keep the evidence the finding gives; do not soften a severity.
+- Sekura scans only repositories the user has granted through the Sekura GitHub App. To add one: https://sekura.ai/app.
+
+Documentation for every tool and client: https://sekura.ai/connect/