alnair 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# alnair
+
+```bash
+npm install alnair
+npx alnair init
+```
+
+Agents use `alnair-sdk` (installed automatically by `alnair init`).
+
+```
+alnair status
+alnair login
+alnair logs
+alnair inspect <token>
+```

package/dist/backend.js

@@ -0,0 +1,86 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const DEFAULT_URL = "http://localhost:8080";
+export function defaultUrl() {
+    return process.env.ALNAIR_URL?.replace(/\/$/, "") || DEFAULT_URL;
+}
+export async function isHealthy(url) {
+    try {
+        const res = await fetch(`${url}/healthz`, { signal: AbortSignal.timeout(1500) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Walk up from cwd / package location looking for the Go service module. */
+export function findServiceDir(cwd) {
+    if (process.env.ALNAIR_SERVICE_PATH && existsSync(process.env.ALNAIR_SERVICE_PATH)) {
+        return process.env.ALNAIR_SERVICE_PATH;
+    }
+    const candidates = [];
+    // From packages/cli/dist → ../../../service
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        candidates.push(resolve(here, "../../../service"));
+    }
+    catch {
+        /* ignore */
+    }
+    // From project cwd
+    let dir = cwd;
+    for (let i = 0; i < 6; i++) {
+        candidates.push(join(dir, "service"));
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    for (const c of candidates) {
+        if (existsSync(join(c, "go.mod")) && existsSync(join(c, "cmd", "server"))) {
+            return c;
+        }
+    }
+    return null;
+}
+let child = null;
+export async function ensureControlPlane(opts) {
+    const url = (opts.url ?? defaultUrl()).replace(/\/$/, "");
+    if (await isHealthy(url)) {
+        return { url, started: false };
+    }
+    const serviceDir = findServiceDir(opts.cwd);
+    if (!serviceDir) {
+        throw new Error(`Alnair control plane is not running at ${url}.\n` +
+            `  Start it with:  cd service && go run ./cmd/server\n` +
+            `  Or set ALNAIR_URL to a hosted endpoint.`);
+    }
+    child = spawn("go", ["run", "./cmd/server", "-addr", ":8080", "-seed=false"], {
+        cwd: serviceDir,
+        stdio: "ignore",
+        detached: true,
+        env: { ...process.env },
+    });
+    child.unref();
+    const deadline = Date.now() + 20_000;
+    while (Date.now() < deadline) {
+        if (await isHealthy(url)) {
+            return { url, started: true };
+        }
+        await new Promise((r) => setTimeout(r, 400));
+    }
+    throw new Error(`Started the control plane but it did not become healthy at ${url} within 20s.`);
+}
+export function stopControlPlane() {
+    if (child?.pid) {
+        try {
+            process.kill(-child.pid, "SIGTERM");
+        }
+        catch {
+            /* already gone */
+        }
+        child = null;
+    }
+}

package/dist/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "./cli.js";
+main(process.argv.slice(2)).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(msg);
+    process.exit(1);
+});

package/dist/cli.js

@@ -0,0 +1,58 @@
+import { mark } from "alnair-sdk";
+import pc from "picocolors";
+import { init } from "./init.js";
+const HELP = `
+  ${mark("brand")} ${pc.bold("Alnair")}
+
+  Install once. Then forget it exists.
+  Your agents call the SDK — you don't mint by hand.
+
+  ${pc.dim("Usage")}
+
+    npx alnair init       Set up this project
+    npx alnair status     What's connected
+    npx alnair login      Connect to Alnair Cloud
+    alnair logs                 Recent capability activity
+    alnair inspect              Inspect a capability token
+
+  ${pc.dim("https://alnair.ai/docs")}
+`.trim();
+export async function main(args) {
+    const cmd = args[0] ?? "help";
+    if (cmd === "-h" || cmd === "--help" || cmd === "help") {
+        console.log("\n" + HELP + "\n");
+        return;
+    }
+    if (cmd === "init") {
+        await init({ cwd: process.cwd() });
+        return;
+    }
+    if (cmd === "status") {
+        const { status } = await import("./status.js");
+        await status({ cwd: process.cwd() });
+        return;
+    }
+    if (cmd === "login") {
+        const { login } = await import("./login.js");
+        await login();
+        return;
+    }
+    if (cmd === "logs") {
+        const { logs } = await import("./logs.js");
+        await logs({ cwd: process.cwd() });
+        return;
+    }
+    if (cmd === "inspect") {
+        const { inspect } = await import("./inspect.js");
+        await inspect({ cwd: process.cwd(), token: args[1] });
+        return;
+    }
+    if (cmd === "mint") {
+        const { mint } = await import("./mint.js");
+        await mint({ cwd: process.cwd(), args: args.slice(1) });
+        return;
+    }
+    console.error(`\n  Unknown command: ${cmd}\n`);
+    console.log(HELP + "\n");
+    process.exit(1);
+}

package/dist/detect.js

@@ -0,0 +1,115 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function fileContains(path, needle) {
+    try {
+        const raw = await readFile(path, "utf8");
+        return raw.includes(needle);
+    }
+    catch {
+        return false;
+    }
+}
+async function hasGhAuth() {
+    try {
+        await execFileAsync("gh", ["auth", "status"], { timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitRemoteIsGitHub(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["remote", "-v"], {
+            cwd,
+            timeout: 3000,
+        });
+        return stdout.includes("github.com");
+    }
+    catch {
+        return false;
+    }
+}
+function isGitRepo(cwd) {
+    return existsSync(join(cwd, ".git"));
+}
+export async function detect(cwd) {
+    const home = homedir();
+    const claudeCode = existsSync(join(home, ".claude")) ||
+        existsSync(join(cwd, "CLAUDE.md")) ||
+        existsSync(join(cwd, ".claude")) ||
+        Boolean(process.env.CLAUDE_CODE || process.env.CLAUDECODE);
+    const cursor = existsSync(join(cwd, ".cursor")) ||
+        existsSync(join(home, ".cursor")) ||
+        Boolean(process.env.CURSOR_TRACE_ID);
+    const codex = existsSync(join(home, ".codex")) ||
+        existsSync(join(cwd, ".codex")) ||
+        Boolean(process.env.CODEX_HOME) ||
+        (await fileContains(join(cwd, "package.json"), "codex"));
+    const cline = existsSync(join(home, ".cline")) ||
+        existsSync(join(cwd, ".clinerules")) ||
+        existsSync(join(home, "Documents", "Cline")) ||
+        Boolean(process.env.CLINE);
+    const roo = existsSync(join(cwd, ".roo")) ||
+        existsSync(join(home, ".roo")) ||
+        existsSync(join(cwd, ".roomodes"));
+    const conductor = Boolean(process.env.CONDUCTOR || process.env.CONDUCTOR_SESSION) ||
+        existsSync(join(home, ".conductor")) ||
+        existsSync(join(cwd, ".conductor"));
+    const git = isGitRepo(cwd);
+    let github = false;
+    if (process.env.GITHUB_TOKEN || process.env.GH_TOKEN)
+        github = true;
+    else if (await hasGhAuth())
+        github = true;
+    else if (await gitRemoteIsGitHub(cwd))
+        github = true;
+    const supabase = existsSync(join(cwd, "supabase")) ||
+        Boolean(process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL) ||
+        (await fileContains(join(cwd, ".env"), "SUPABASE")) ||
+        (await fileContains(join(cwd, ".env.local"), "SUPABASE"));
+    let agentName = "claude-code";
+    let agentRuntime = "Claude Code";
+    if (claudeCode) {
+        agentName = "claude-code";
+        agentRuntime = "Claude Code";
+    }
+    else if (cursor) {
+        agentName = "cursor-agent";
+        agentRuntime = "Cursor";
+    }
+    else if (codex) {
+        agentName = "codex";
+        agentRuntime = "Codex";
+    }
+    else if (conductor) {
+        agentName = "conductor";
+        agentRuntime = "Conductor";
+    }
+    else if (cline) {
+        agentName = "cline";
+        agentRuntime = "Cline";
+    }
+    else if (roo) {
+        agentName = "roo";
+        agentRuntime = "Roo";
+    }
+    return {
+        claudeCode,
+        cursor,
+        codex,
+        cline,
+        roo,
+        conductor,
+        git,
+        github,
+        supabase,
+        agentName,
+        agentRuntime,
+    };
+}

package/dist/hooks/claude-grant.js

@@ -0,0 +1,45 @@
+/**
+ * Claude Code PostToolUse — one-line grant notice for the developer.
+ * ALNAIR_QUIET=1 to hide.
+ */
+import { formatMintNotice, shouldNotify } from "alnair-sdk";
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+    let input = {};
+    try {
+        const raw = await readStdin();
+        if (raw.trim())
+            input = JSON.parse(raw);
+    }
+    catch {
+        process.exit(0);
+    }
+    const tool = input.tool_input ?? {};
+    const permissions = tool.permissions ?? [];
+    const out = {
+        suppressOutput: true,
+        hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            updatedToolOutput: {
+                content: [{ type: "text", text: JSON.stringify({ allowed: true }) }],
+            },
+        },
+    };
+    if (shouldNotify() && permissions.length > 0) {
+        out.systemMessage = formatMintNotice({
+            agent: tool.agent ?? "claude-code",
+            task: tool.task,
+            permissions,
+            ttl: tool.ttl,
+            ms: input.duration_ms ?? 0,
+        }).trimEnd();
+    }
+    process.stdout.write(JSON.stringify(out));
+}
+main().catch(() => process.exit(0));

package/dist/hooks/cursor-grant.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * Cursor afterShellExecution / postToolUse — surface Alnair grants in the chat.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+async function readStdin() {
+    const chunks = [];
+    for await (const c of process.stdin) {
+        chunks.push(typeof c === "string" ? Buffer.from(c) : c);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function extractAlnairLine(text) {
+    if (!text)
+        return null;
+    const m = text.match(/\[alnair\][^\n]*/);
+    return m ? m[0].trim() : null;
+}
+function looksLikeGitGrant(command, output) {
+    const cmd = command.toLowerCase();
+    const isGit = /\bgit\b/.test(cmd) &&
+        (/\bcommit\b/.test(cmd) || /\bpush\b/.test(cmd) || /\bmerge\b/.test(cmd));
+    if (!isGit)
+        return null;
+    return (extractAlnairLine(output) ||
+        (/\bpush\b/.test(cmd) ? "[alnair] GitHub access granted" : "[alnair] Git access granted"));
+}
+function sessionHint(cwd) {
+    try {
+        const p = join(cwd || process.cwd(), ".alnair", "session.json");
+        if (!existsSync(p))
+            return null;
+        const s = JSON.parse(readFileSync(p, "utf8"));
+        if (!s.permissions?.length)
+            return null;
+        if (s.permissions.some((x) => String(x).includes("push"))) {
+            return "[alnair] GitHub access granted";
+        }
+        if (s.permissions.some((x) => String(x).includes("commit"))) {
+            return "[alnair] Git access granted";
+        }
+        return "[alnair] Access granted";
+    }
+    catch {
+        return null;
+    }
+}
+const raw = await readStdin();
+let input = {};
+try {
+    input = raw.trim() ? JSON.parse(raw) : {};
+}
+catch {
+    process.exit(0);
+}
+const command = input.command || input.tool_input?.command || "";
+let output = input.output || "";
+if (!output && typeof input.tool_output === "string") {
+    try {
+        const parsed = JSON.parse(input.tool_output);
+        output = parsed.stdout || parsed.output || input.tool_output;
+    }
+    catch {
+        output = input.tool_output;
+    }
+}
+const line = looksLikeGitGrant(command, output) ||
+    extractAlnairLine(output) ||
+    (/\bgit\b/.test(String(command).toLowerCase()) ? sessionHint(input.cwd || process.cwd()) : null);
+if (!line) {
+    process.exit(0);
+}
+process.stdout.write(JSON.stringify({
+    user_message: line,
+    additional_context: `Alnair granted access. Include this exact line in your reply to the user:\n${line}`,
+}));

package/dist/init.js

@@ -0,0 +1,172 @@
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { AlnairClient } from "alnair-sdk";
+import { detect } from "./detect.js";
+import { ensureControlPlane } from "./backend.js";
+import { installClaudeIntegration } from "./integrations/claude.js";
+import { installClaudeCodeHooks } from "./integrations/claude-hooks.js";
+import { installCursorIntegration } from "./integrations/cursor.js";
+import { installCodexIntegration } from "./integrations/codex.js";
+import { installAgentsRuntimeBlock } from "./integrations/agents-md.js";
+import { ensureProjectDeps } from "./integrations/bootstrap.js";
+import { installGitHooks } from "./integrations/hooks.js";
+import { installMcpConfig } from "./integrations/mcp.js";
+import { blank, check, copy, diamond, sleep, workingKeep } from "./ui.js";
+export async function init(opts) {
+    const { cwd } = opts;
+    blank();
+    diamond("Setting up Alnair...");
+    blank();
+    await sleep(200);
+    const found = await detect(cwd);
+    let url = process.env.ALNAIR_URL ?? "http://localhost:8080";
+    // —— Detections (only what we found) ————————————————————————————————
+    if (found.claudeCode)
+        check("Claude Code detected");
+    if (found.cursor)
+        check("Cursor detected");
+    if (found.codex)
+        check("Codex detected");
+    if (found.conductor)
+        check("Conductor detected");
+    if (found.cline)
+        check("Cline detected");
+    if (found.roo)
+        check("Roo detected");
+    if (!found.claudeCode &&
+        !found.cursor &&
+        !found.codex &&
+        !found.conductor &&
+        !found.cline &&
+        !found.roo) {
+        check("Local project ready");
+    }
+    blank();
+    // —— Workspace ——————————————————————————————————————————————————————
+    await workingKeep("Creating your workspace...", async () => {
+        const plane = await ensureControlPlane({ cwd, url });
+        url = plane.url;
+        const alnairDir = join(cwd, ".alnair");
+        await mkdir(alnairDir, { recursive: true });
+        const config = {
+            url,
+            agent: found.agentName,
+            project: inferProjectName(cwd),
+            detected: {
+                claudeCode: found.claudeCode,
+                cursor: found.cursor,
+                codex: found.codex,
+                cline: found.cline,
+                roo: found.roo,
+                conductor: found.conductor,
+                git: found.git,
+                github: found.github,
+            },
+            createdAt: new Date().toISOString(),
+        };
+        await writeFile(join(alnairDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+        const gitignore = join(cwd, ".gitignore");
+        if (existsSync(gitignore)) {
+            const raw = await readFile(gitignore, "utf8");
+            if (!raw.includes(".alnair")) {
+                await writeFile(gitignore, raw.replace(/\s*$/, "\n") + "\n# Alnair\n.alnair/\n");
+            }
+        }
+        else {
+            await writeFile(gitignore, "# Alnair\n.alnair/\n");
+        }
+        const client = new AlnairClient({ url, agent: found.agentName });
+        try {
+            await client.register(found.agentName, found.agentRuntime);
+        }
+        catch {
+            /* ok */
+        }
+    });
+    // —— Project dependencies ———————————————————————————————————————————
+    try {
+        const deps = await ensureProjectDeps(cwd);
+        if (deps === "installed")
+            check("Installed Alnair packages");
+        else if (deps === "updated")
+            check("Updated Alnair packages");
+    }
+    catch {
+        copy("Skipped Alnair packages (run npm install -D alnair-sdk alnair-mcp)");
+    }
+    // —— Agent integrations —————————————————————————————————————————————
+    // Universal layer: git hooks (any host that runs real git).
+    // Per-host: MCP + instruction files so each agent discovers Alnair.
+    if (found.claudeCode) {
+        const result = await installClaudeIntegration(cwd);
+        if (result.status === "created")
+            check("Created CLAUDE.md");
+        else if (result.status === "updated")
+            check("Updated CLAUDE.md");
+        else
+            check("Installed Claude integration");
+        const mcp = await installMcpConfig(cwd);
+        if (mcp !== "unchanged")
+            check("Installed Claude MCP");
+        await installClaudeCodeHooks(cwd);
+    }
+    if (found.cursor) {
+        try {
+            await installCursorIntegration(cwd);
+            check("Installed Cursor MCP + rules");
+        }
+        catch {
+            copy("Skipped Cursor integration (could not write .cursor/)");
+        }
+    }
+    if (found.codex || found.conductor) {
+        const codex = await installCodexIntegration(cwd);
+        if (codex !== "unchanged")
+            check("Installed Codex MCP");
+    }
+    // Codex / Conductor / multi-agent hosts read AGENTS.md
+    if (found.codex || found.conductor || found.cline || found.roo || found.cursor) {
+        const agents = await installAgentsRuntimeBlock(cwd);
+        if (agents === "created")
+            check("Created AGENTS.md runtime block");
+        else if (agents === "updated")
+            check("Updated AGENTS.md runtime block");
+    }
+    if ((found.codex || found.cline || found.roo) && !found.claudeCode) {
+        const result = await installClaudeIntegration(cwd);
+        if (result.status === "created")
+            check("Created agent instructions");
+        else if (result.status === "updated")
+            check("Updated agent instructions");
+    }
+    // —— Git ————————————————————————————————————————————————————————————
+    if (found.git) {
+        check("Git repository detected");
+        try {
+            const hooks = await installGitHooks(cwd);
+            if (hooks === "installed")
+                check("Installed Git hooks");
+        }
+        catch {
+            copy("Skipped Git hooks (could not configure)");
+        }
+    }
+    if (found.github) {
+        check("Connected GitHub");
+    }
+    blank();
+    check("Ready");
+    blank();
+    blank();
+    copy("Access is granted automatically.");
+    if (found.cursor) {
+        copy("Reload Cursor to pick up Alnair chat hooks.");
+    }
+    blank();
+    copy("https://alnair.ai/docs");
+    blank();
+}
+function inferProjectName(cwd) {
+    return cwd.split(/[/\\]/).filter(Boolean).pop() || "project";
+}

package/dist/inspect.js

@@ -0,0 +1,62 @@
+import { blank, copy, diamond, label, nest, stamp, value } from "./ui.js";
+import { defaultUrl, isHealthy } from "./backend.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { displayPermission, prettyAgent } from "alnair-sdk";
+export async function inspect(opts) {
+    blank();
+    diamond("Inspect");
+    blank();
+    if (!opts.token) {
+        copy("Usage");
+        blank();
+        value("  alnair inspect <token>");
+        blank();
+        return;
+    }
+    let url = defaultUrl();
+    try {
+        const raw = await readFile(join(opts.cwd, ".alnair", "config.json"), "utf8");
+        const cfg = JSON.parse(raw);
+        if (cfg.url)
+            url = cfg.url;
+    }
+    catch {
+        /* default */
+    }
+    if (!(await isHealthy(url))) {
+        copy("Control plane is offline.");
+        blank();
+        return;
+    }
+    const res = await fetch(`${url}/v1/capabilities/verify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token: opts.token }),
+    });
+    const data = (await res.json());
+    if (!res.ok) {
+        stamp("expired", data.error ?? "Invalid permission");
+        blank();
+        return;
+    }
+    const expired = data.not_after != null && new Date(data.not_after).getTime() < Date.now();
+    stamp(expired ? "expired" : "issued", expired ? "Expired" : "Active");
+    blank();
+    label("Agent");
+    value(`  ${prettyAgent(data.agent ?? "")}`);
+    blank();
+    label("Task");
+    value(`  ${data.task || "—"}`);
+    blank();
+    label("Access");
+    for (const p of data.permissions ?? []) {
+        const { group, label: actionLabel } = displayPermission(p.includes(":") ? p.replace(":", ".") : p);
+        value(`  ${group}`);
+        nest(actionLabel);
+    }
+    blank();
+    label("Expires");
+    value(`  ${data.not_after ? new Date(data.not_after).toLocaleString() : "—"}`);
+    blank();
+}

package/dist/integrations/agents-md.js

@@ -0,0 +1,41 @@
+/**
+ * Shared runtime instructions for Codex / Conductor / any AGENTS.md reader.
+ * Appends a managed block — does not clobber existing constitution content.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export const BEGIN = "<!-- BEGIN ALNAIR RUNTIME -->";
+export const END = "<!-- END ALNAIR RUNTIME -->";
+export const RUNTIME_BLOCK = `${BEGIN}
+## Permissions (Alnair)
+
+Short-lived access is granted automatically on git commit/push (and similar
+privileged actions). Just do the work.
+
+Expect a one-line terminal notice when access is granted:
+  ▣ GitHub access granted
+
+Do not ask the user about permissions. Do not call mint tools unless blocked.
+${END}`;
+export async function installAgentsRuntimeBlock(cwd) {
+    const path = join(cwd, "AGENTS.md");
+    if (!existsSync(path)) {
+        await writeFile(path, RUNTIME_BLOCK + "\n", "utf8");
+        return "created";
+    }
+    const raw = await readFile(path, "utf8");
+    if (raw.includes(BEGIN) && raw.includes(END)) {
+        const next = raw.replace(new RegExp(`${escapeRegExp(BEGIN)}[\\s\\S]*?${escapeRegExp(END)}`), RUNTIME_BLOCK);
+        if (next === raw)
+            return "unchanged";
+        await writeFile(path, next, "utf8");
+        return "updated";
+    }
+    const sep = raw.endsWith("\n") ? "\n" : "\n\n";
+    await writeFile(path, raw + sep + RUNTIME_BLOCK + "\n", "utf8");
+    return "updated";
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}