alnair-sdk 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# alnair-sdk
+
+```bash
+npm install alnair-sdk
+```
+
+```ts
+import { alnair } from "alnair-sdk"
+
+await alnair.mint({
+  task: "Fix authentication bug",
+  permissions: ["github.pull_request.merge"],
+  ttl: "15m",
+})
+```

package/dist/agent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Detect which agent host is running this process.
+ * Used at mint time so Cursor/Codex/Claude grants attribute correctly
+ * (init-time config alone is wrong when multiple hosts share a repo).
+ */
+export declare function detectRunningAgent(): string;

package/dist/agent.js

@@ -0,0 +1,40 @@
+/**
+ * Detect which agent host is running this process.
+ * Used at mint time so Cursor/Codex/Claude grants attribute correctly
+ * (init-time config alone is wrong when multiple hosts share a repo).
+ */
+export function detectRunningAgent() {
+    const env = process.env;
+    if (env.ALNAIR_AGENT?.trim())
+        return env.ALNAIR_AGENT.trim();
+    // Cursor
+    if (env.CURSOR_TRACE_ID ||
+        env.CURSOR_AGENT ||
+        env.CURSOR_SESSION_ID ||
+        env.COMPOSER_SESSION ||
+        (env.TERM_PROGRAM === "vscode" && env.VSCODE_PID && env.CURSOR_AGENT !== undefined)) {
+        return "cursor-agent";
+    }
+    // Heuristic: Cursor injects these often
+    if (env.VSCODE_GIT_ASKPASS_MAIN?.includes("cursor") || env.CURSOR_EXTENSION_HOST) {
+        return "cursor-agent";
+    }
+    // Claude Code
+    if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDE_CODE_ENTRYPOINT) {
+        return "claude-code";
+    }
+    // Codex
+    if (env.CODEX_HOME || env.CODEX_SANDBOX || env.CODEX_CI || env.OPENAI_CODEX) {
+        return "codex";
+    }
+    // Conductor (hosts Claude/Cursor/Codex — prefer nested host signals first)
+    if (env.CONDUCTOR || env.CONDUCTOR_SESSION || env.CONDUCTOR_WORKSPACE) {
+        return "conductor";
+    }
+    // Cline / Roo
+    if (env.CLINE || env.CLINE_DIR)
+        return "cline";
+    if (env.ROO || env.ROO_DIR)
+        return "roo";
+    return "";
+}

package/dist/gate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gate.js

@@ -0,0 +1,115 @@
+/**
+ * Gate used by git hooks.
+ *
+ * Bash hooks echo `[alnair] … access granted` to stdout (Cursor tool capture).
+ * Gate still mints; set ALNAIR_HOOK_ECHO=0 to have gate print instead.
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function covers(granted, want) {
+    const w = want.includes(":")
+        ? want
+        : want.replace(/^([^.]+)\./, "$1:");
+    const alt = want.includes(".")
+        ? `${want.split(".")[0]}:${want.split(".").slice(1).join(".")}`
+        : want;
+    for (const p of granted) {
+        if (p === w || p === alt || p === want)
+            return true;
+        if (p.endsWith(".*")) {
+            const prefix = p.slice(0, -1);
+            if (w.startsWith(prefix) || alt.startsWith(prefix))
+                return true;
+        }
+    }
+    return false;
+}
+async function sessionCovers(want) {
+    try {
+        const raw = await readFile(join(process.cwd(), ".alnair", "session.json"), "utf8");
+        const session = JSON.parse(raw);
+        if (!session.expiresAt || new Date(session.expiresAt).getTime() < Date.now()) {
+            return false;
+        }
+        return covers(session.permissions ?? [], want);
+    }
+    catch {
+        return false;
+    }
+}
+async function inferTask(want) {
+    try {
+        if (want.includes("commit")) {
+            const raw = await readFile(join(process.cwd(), ".git", "COMMIT_EDITMSG"), "utf8");
+            const subject = raw.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+            if (subject?.trim())
+                return subject.trim();
+        }
+        const { stdout } = await execFileAsync("git", ["log", "-1", "--pretty=%s"], {
+            cwd: process.cwd(),
+        });
+        if (stdout.trim())
+            return stdout.trim();
+    }
+    catch {
+        /* fall through */
+    }
+    if (want.includes("push"))
+        return "git push";
+    if (want.includes("commit"))
+        return "git commit";
+    return want;
+}
+async function announce(want, agent, ms) {
+    // Default: bash hook echoes the line. Gate prints only when asked.
+    if (process.env.ALNAIR_HOOK_ECHO === "0") {
+        const { streamMintNotice } = await import("./notify.js");
+        streamMintNotice({
+            agent: agent || "agent",
+            permissions: [want],
+            ms,
+        });
+    }
+}
+async function autoGrant(want) {
+    const started = Date.now();
+    try {
+        const { AlnairClient, detectRunningAgent } = await import("./index.js");
+        const runtime = detectRunningAgent();
+        const client = await AlnairClient.fromProject(runtime ? { agent: runtime } : {});
+        const task = process.env.ALNAIR_TASK?.trim() || (await inferTask(want));
+        await client.mint({
+            task,
+            permissions: [want],
+            ttl: process.env.ALNAIR_TTL ?? "15m",
+            agent: runtime || undefined,
+            notify: false,
+        });
+        return { ok: true, agent: runtime || "agent", ms: Date.now() - started };
+    }
+    catch {
+        return { ok: false, agent: "", ms: 0 };
+    }
+}
+async function main() {
+    const want = process.argv[2];
+    if (!want) {
+        process.exit(2);
+    }
+    const { detectRunningAgent } = await import("./agent.js");
+    const agent = detectRunningAgent() || "agent";
+    if (await sessionCovers(want)) {
+        await announce(want, agent, 1);
+        process.exit(0);
+    }
+    const granted = await autoGrant(want);
+    if (granted.ok) {
+        await announce(want, granted.agent || agent, granted.ms);
+        process.exit(0);
+    }
+    process.exit(1);
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * alnair-sdk — mint and verify short-lived agent capabilities.
+ *
+ * Claude / Cursor call this. Developers run `npx alnair init` once, then forget it.
+ *
+ *   const token = await alnair.mint({
+ *     task: "Fix authentication bug",
+ *     permissions: ["github.pull_request.merge"],
+ *     ttl: "15m",
+ *   })
+ */
+export type MintRequest = {
+    /** What the agent is doing — required for a real mint. */
+    task?: string;
+    ttl?: string;
+    agent?: string;
+    /** Preferred: ["github.pull_request.merge"] */
+    permissions?: string[];
+    /** Aliases — also accepted */
+    github?: string[];
+    supabase?: string[];
+    postgres?: string[];
+    vercel?: string[];
+    audience?: string[];
+    /** Set false to silence the one-line notice. Default: on (ALNAIR_QUIET=1 to hide). */
+    notify?: boolean;
+};
+export type AlnairConfig = {
+    url?: string;
+    agent?: string;
+};
+export type Capability = {
+    can: (permission: string) => boolean;
+    agent: () => string;
+    agentId: () => string;
+    task: () => string;
+    expiresAt: () => Date;
+    permissions: () => string[];
+    tokenId: () => string;
+};
+/** Normalize to wire form github:pull_request.merge for the control plane. */
+export declare function flatten(req: MintRequest): string[];
+export declare class AlnairClient {
+    #private;
+    constructor(config?: AlnairConfig);
+    static fromProject(overrides?: AlnairConfig): Promise<AlnairClient>;
+    get url(): string;
+    register(name: string, runtime?: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    mint(req: MintRequest): Promise<string>;
+    mintCapability(req: MintRequest): Promise<{
+        token: string;
+        capability: Capability;
+    }>;
+    verify(token: string, opts?: {
+        audience?: string;
+    }): Promise<Capability>;
+}
+export declare const alnair: {
+    mint: (req: MintRequest) => Promise<string>;
+    verify: (token: string, opts?: {
+        audience?: string;
+    }) => Promise<Capability>;
+    mintCapability: (req: MintRequest) => Promise<{
+        token: string;
+        capability: Capability;
+    }>;
+    register: (name: string, runtime?: string) => Promise<{
+        id: string;
+        name: string;
+    }>;
+    configure: (config: AlnairConfig) => void;
+};
+export { prettyAgent, prettyAction, prettyProvider, parsePermission, displayPermission, formatMintNotice, shouldNotify, streamMintNotice, } from "./notify.js";
+export { mark, markGlyph, MARK } from "./mark.js";
+export type { MarkState } from "./mark.js";
+export { detectRunningAgent } from "./agent.js";
+export default alnair;

package/dist/index.js

@@ -0,0 +1,233 @@
+/**
+ * alnair-sdk — mint and verify short-lived agent capabilities.
+ *
+ * Claude / Cursor call this. Developers run `npx alnair init` once, then forget it.
+ *
+ *   const token = await alnair.mint({
+ *     task: "Fix authentication bug",
+ *     permissions: ["github.pull_request.merge"],
+ *     ttl: "15m",
+ *   })
+ */
+import { streamMintNotice, parsePermission, shouldNotify } from "./notify.js";
+import { detectRunningAgent } from "./agent.js";
+async function loadConfigFile() {
+    try {
+        const { readFile } = await import("node:fs/promises");
+        const { join } = await import("node:path");
+        const raw = await readFile(join(process.cwd(), ".alnair", "config.json"), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/** Normalize to wire form github:pull_request.merge for the control plane. */
+export function flatten(req) {
+    const out = [];
+    for (const p of req.permissions ?? []) {
+        const trimmed = p.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.includes(":")) {
+            out.push(trimmed);
+            continue;
+        }
+        // github.pull_request.merge → github:pull_request.merge
+        const { provider, action } = parsePermission(trimmed);
+        if (provider && action)
+            out.push(`${provider}:${action}`);
+        else
+            out.push(trimmed);
+    }
+    const add = (provider, actions) => {
+        for (const a of actions ?? []) {
+            const trimmed = a.trim();
+            if (!trimmed)
+                continue;
+            out.push(trimmed.includes(":") ? trimmed : `${provider}:${trimmed}`);
+        }
+    };
+    add("github", req.github);
+    add("supabase", req.supabase);
+    add("postgres", req.postgres);
+    add("vercel", req.vercel);
+    return out;
+}
+function canMatch(granted, want) {
+    let w = want.trim();
+    if (!w)
+        return false;
+    // Allow asking with dots or colons
+    if (!w.includes(":") && w.includes(".")) {
+        const { provider, action } = parsePermission(w);
+        w = `${provider}:${action}`;
+    }
+    for (const p of granted) {
+        if (p === w)
+            return true;
+        if (p.endsWith(":*") && w.startsWith(p.slice(0, -1)))
+            return true;
+    }
+    return false;
+}
+function capabilityFrom(result) {
+    const perms = result.permissions ?? [];
+    return {
+        can: (permission) => canMatch(perms, permission),
+        agent: () => result.agent,
+        agentId: () => result.agent_id,
+        task: () => result.task ?? "",
+        expiresAt: () => new Date(result.not_after),
+        permissions: () => [...perms],
+        tokenId: () => result.token_id,
+    };
+}
+export class AlnairClient {
+    #url;
+    #agent;
+    constructor(config = {}) {
+        this.#url = (config.url ?? "http://localhost:8080").replace(/\/$/, "");
+        this.#agent = config.agent ?? "claude-code";
+    }
+    static async fromProject(overrides = {}) {
+        const file = await loadConfigFile();
+        const runtime = detectRunningAgent();
+        return new AlnairClient({
+            url: overrides.url ?? file.url ?? process.env.ALNAIR_URL ?? "http://localhost:8080",
+            agent: overrides.agent ?? (runtime || file.agent || "claude-code"),
+        });
+    }
+    get url() {
+        return this.#url;
+    }
+    async register(name, runtime = "cli") {
+        return this.#post("/v1/agents", { name, runtime });
+    }
+    async mint(req) {
+        const perms = flatten(req);
+        if (perms.length === 0) {
+            throw new Error('Add at least one permission, e.g. { permissions: ["github.pull_request.merge"] }');
+        }
+        if (!req.task?.trim()) {
+            throw new Error('Add a task so the grant is meaningful, e.g. { task: "Fix authentication bug" }');
+        }
+        const agent = req.agent ?? this.#agent;
+        const body = {
+            task: req.task,
+            agent,
+            ttl: req.ttl ?? "15m",
+            audience: req.audience,
+            // Control plane expects provider arrays — split wire perms back
+            ...toProviderBody(perms),
+        };
+        const started = Date.now();
+        const res = await this.#post("/v1/capabilities/mint", body);
+        if (req.notify !== false && shouldNotify(req.notify)) {
+            streamMintNotice({
+                agent: res.agent || agent,
+                task: res.task || req.task,
+                permissions: res.permissions?.length ? res.permissions : perms,
+                ttl: req.ttl ?? "15m",
+                ms: Date.now() - started,
+            });
+        }
+        // Session file for git hooks / gates
+        await writeSession({
+            permissions: res.permissions?.length ? res.permissions : perms,
+            expiresAt: res.not_after,
+            task: res.task || req.task,
+            agent: res.agent || agent,
+            tokenId: res.token_id,
+        });
+        return res.token;
+    }
+    async mintCapability(req) {
+        const token = await this.mint(req);
+        const capability = await this.verify(token);
+        return { token, capability };
+    }
+    async verify(token, opts) {
+        const res = await this.#post("/v1/capabilities/verify", {
+            token,
+            audience: opts?.audience,
+        });
+        return capabilityFrom({
+            ...res,
+            token_id: res.token_id ?? "",
+        });
+    }
+    async #post(path, body) {
+        let res;
+        try {
+            res = await fetch(`${this.#url}${path}`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+        }
+        catch {
+            throw new Error(`Cannot reach Alnair at ${this.#url}. Run \`npx alnair init\` first.`);
+        }
+        const text = await res.text();
+        let data = null;
+        try {
+            data = text ? JSON.parse(text) : null;
+        }
+        catch {
+            data = { error: text };
+        }
+        if (!res.ok) {
+            const msg = data && typeof data === "object" && data !== null && "error" in data
+                ? String(data.error)
+                : res.statusText;
+            throw new Error(msg);
+        }
+        return data;
+    }
+}
+async function writeSession(session) {
+    try {
+        const { mkdir, writeFile } = await import("node:fs/promises");
+        const { join } = await import("node:path");
+        const dir = join(process.cwd(), ".alnair");
+        await mkdir(dir, { recursive: true });
+        await writeFile(join(dir, "session.json"), JSON.stringify(session, null, 2) + "\n");
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+function toProviderBody(perms) {
+    const body = {};
+    for (const p of perms) {
+        const i = p.indexOf(":");
+        if (i < 0)
+            continue;
+        const prov = p.slice(0, i);
+        const act = p.slice(i + 1);
+        if (!body[prov])
+            body[prov] = [];
+        body[prov].push(act);
+    }
+    return body;
+}
+let _default = null;
+async function getDefault() {
+    if (!_default)
+        _default = await AlnairClient.fromProject();
+    return _default;
+}
+export const alnair = {
+    mint: async (req) => (await getDefault()).mint(req),
+    verify: async (token, opts) => (await getDefault()).verify(token, opts),
+    mintCapability: async (req) => (await getDefault()).mintCapability(req),
+    register: async (name, runtime) => (await getDefault()).register(name, runtime),
+    configure: (config) => {
+        _default = new AlnairClient(config);
+    },
+};
+export { prettyAgent, prettyAction, prettyProvider, parsePermission, displayPermission, formatMintNotice, shouldNotify, streamMintNotice, } from "./notify.js";
+export { mark, markGlyph, MARK } from "./mark.js";
+export { detectRunningAgent } from "./agent.js";
+export default alnair;

package/dist/mark.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Alnair mark — nested squares from brand 4b / 6a.
+ *
+ * Outer square = identity (constant).
+ * Inner square = capability:
+ *   issued  ▣  solid purple — authority holds
+ *   used    ▢  purple outline — exercised, grant still stands
+ *   expired ⬚  faint ghost — returned to identity
+ *
+ * Purple (#7C6CF5) only while the capability holds authority.
+ */
+export type MarkState = "issued" | "used" | "expired" | "brand";
+/** Colored Alnair mark for the given lifecycle state. */
+export declare function mark(state?: MarkState): string;
+/** Raw glyph without ANSI (tests, plain logs). */
+export declare function markGlyph(state?: MarkState): string;
+export declare const MARK: {
+    readonly brand: () => string;
+    readonly issued: () => string;
+    readonly used: () => string;
+    readonly expired: () => string;
+};

package/dist/mark.js

@@ -0,0 +1,50 @@
+/**
+ * Alnair mark — nested squares from brand 4b / 6a.
+ *
+ * Outer square = identity (constant).
+ * Inner square = capability:
+ *   issued  ▣  solid purple — authority holds
+ *   used    ▢  purple outline — exercised, grant still stands
+ *   expired ⬚  faint ghost — returned to identity
+ *
+ * Purple (#7C6CF5) only while the capability holds authority.
+ */
+const PURPLE = "\x1b[38;2;124;108;245m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const GLYPH = {
+    brand: "▣",
+    issued: "▣",
+    used: "▢",
+    expired: "⬚",
+};
+function colorEnabled() {
+    if (process.env.NO_COLOR)
+        return false;
+    if (process.env.FORCE_COLOR === "0")
+        return false;
+    // Don't emit ANSI into Cursor/Claude tool captures — they often hide it.
+    if (!process.stdout.isTTY && !process.stderr.isTTY)
+        return false;
+    return true;
+}
+/** Colored Alnair mark for the given lifecycle state. */
+export function mark(state = "brand") {
+    const g = GLYPH[state];
+    if (!colorEnabled())
+        return g;
+    if (state === "expired")
+        return `${DIM}${g}${RESET}`;
+    // brand / issued / used — purple (used is outline glyph, still purple)
+    return `${PURPLE}${g}${RESET}`;
+}
+/** Raw glyph without ANSI (tests, plain logs). */
+export function markGlyph(state = "brand") {
+    return GLYPH[state];
+}
+export const MARK = {
+    brand: () => mark("brand"),
+    issued: () => mark("issued"),
+    used: () => mark("used"),
+    expired: () => mark("expired"),
+};

package/dist/notify.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Developer-facing grant notice — one line on stdout for tool UIs.
+ *
+ *   [alnair] Git access granted   (piped / agent)
+ *   ▣ Git access granted         (interactive TTY)
+ *
+ * Opt out with ALNAIR_QUIET=1. No desktop toasts.
+ */
+export declare function prettyAgent(name: string): string;
+export declare function parsePermission(perm: string): {
+    provider: string;
+    action: string;
+};
+export declare function displayPermission(perm: string): {
+    group: string;
+    label: string;
+};
+export declare function prettyAction(action: string): string;
+export declare function prettyProvider(provider: string): string;
+export type MintNotice = {
+    agent: string;
+    task?: string;
+    permissions: string[];
+    ttl?: string;
+    ms: number;
+};
+/** Plain line for agent tool UIs; colored mark only on a real TTY. */
+export declare function formatMintNotice(n: MintNotice): string;
+export declare function shouldNotify(explicit?: boolean): boolean;
+export declare function streamMintNotice(n: MintNotice): void;

package/dist/notify.js

@@ -0,0 +1,118 @@
+/**
+ * Developer-facing grant notice — one line on stdout for tool UIs.
+ *
+ *   [alnair] Git access granted   (piped / agent)
+ *   ▣ Git access granted         (interactive TTY)
+ *
+ * Opt out with ALNAIR_QUIET=1. No desktop toasts.
+ */
+import { mark, markGlyph } from "./mark.js";
+function isQuiet() {
+    return process.env.ALNAIR_QUIET === "1" || process.env.ALNAIR_QUIET === "true";
+}
+function writeDeveloper(text) {
+    try {
+        process.stdout.write(text);
+    }
+    catch {
+        try {
+            process.stderr.write(text);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function prettyAgent(name) {
+    const map = {
+        "claude-code": "Claude Code",
+        claude: "Claude Code",
+        "cursor-agent": "Cursor",
+        cursor: "Cursor",
+        codex: "Codex",
+        "ci-runner": "GitHub Actions",
+    };
+    return map[name] ?? name;
+}
+export function parsePermission(perm) {
+    const normalized = perm.replace(/^\s+|\s+$/g, "");
+    if (normalized.includes(":")) {
+        const [provider, ...rest] = normalized.split(":");
+        return { provider, action: rest.join(":") };
+    }
+    const [provider, ...rest] = normalized.split(".");
+    return { provider, action: rest.join(".") };
+}
+export function displayPermission(perm) {
+    const { provider, action } = parsePermission(perm);
+    const key = `${provider}.${action}`.toLowerCase();
+    const known = {
+        "github.git.commit": { group: "Git", label: "Commit changes" },
+        "github.git.push": { group: "GitHub", label: "Push to repository" },
+        "github.pull_request.merge": { group: "GitHub", label: "Merge pull requests" },
+        "github.pr.merge": { group: "GitHub", label: "Merge pull requests" },
+        "github.pull_request.open": { group: "GitHub", label: "Open pull requests" },
+        "vercel.deploy.preview": { group: "Vercel", label: "Deploy preview" },
+        "vercel.deploy.production": { group: "Vercel", label: "Deploy to production" },
+        "supabase.write": { group: "Supabase", label: "Write data" },
+        "supabase.read": { group: "Supabase", label: "Read data" },
+        "postgres.write": { group: "Postgres", label: "Write data" },
+        "postgres.read": { group: "Postgres", label: "Read data" },
+    };
+    if (known[key])
+        return known[key];
+    return {
+        group: prettyProvider(provider),
+        label: prettyAction(action),
+    };
+}
+export function prettyAction(action) {
+    const known = {
+        "pull_request.merge": "Merge pull requests",
+        "pr.merge": "Merge pull requests",
+        "pull_request.open": "Open pull requests",
+        "git.commit": "Commit changes",
+        "git.push": "Push to repository",
+        read: "Read data",
+        write: "Write data",
+        "deploy.preview": "Deploy preview",
+        "deploy.production": "Deploy to production",
+    };
+    if (known[action])
+        return known[action];
+    return action.replace(/[._]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+export function prettyProvider(provider) {
+    const known = {
+        github: "GitHub",
+        git: "Git",
+        supabase: "Supabase",
+        vercel: "Vercel",
+        postgres: "Postgres",
+    };
+    return known[provider.toLowerCase()] ?? provider;
+}
+function whoFrom(n) {
+    const groups = [...new Set(n.permissions.map((p) => displayPermission(p).group))];
+    return groups.length === 1 ? groups[0] : "Access";
+}
+/** Plain line for agent tool UIs; colored mark only on a real TTY. */
+export function formatMintNotice(n) {
+    const who = whoFrom(n);
+    if (process.stdout.isTTY) {
+        return `  ${mark("issued")} ${who} access granted\n`;
+    }
+    return `  [alnair] ${markGlyph("issued")} ${who} access granted\n`;
+}
+export function shouldNotify(explicit) {
+    if (explicit === true)
+        return true;
+    if (explicit === false)
+        return false;
+    return !isQuiet();
+}
+export function streamMintNotice(n) {
+    if (isQuiet())
+        return;
+    writeDeveloper(formatMintNotice(n));
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "alnair-sdk",
+  "version": "0.1.0",
+  "description": "Give AI agents secure, temporary permissions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./gate": "./dist/gate.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CamiloJac/seren.git",
+    "directory": "packages/sdk"
+  },
+  "keywords": [
+    "alnair",
+    "ai",
+    "agents",
+    "permissions",
+    "capabilities"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  }
+}