@newtype-ai/nit 0.4.9 → 0.4.11

package/dist/chunk-M6SR6QMR.js

@@ -0,0 +1,291 @@
+// nit — version control for agent cards
+
+// src/remote.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/identity.ts
+import {
+  createHash,
+  generateKeyPairSync,
+  createPrivateKey,
+  createPublicKey,
+  sign,
+  verify
+} from "crypto";
+import { promises as fs } from "fs";
+import { join } from "path";
+function base64urlToBase64(b64url) {
+  let s = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  while (s.length % 4 !== 0) s += "=";
+  return s;
+}
+function base64ToBase64url(b64) {
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function generateKeypair(nitDir) {
+  const identityDir = join(nitDir, "identity");
+  await fs.mkdir(identityDir, { recursive: true });
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const pubJwk = publicKey.export({ format: "jwk" });
+  const privJwk = privateKey.export({ format: "jwk" });
+  const pubBase64 = base64urlToBase64(pubJwk.x);
+  const privBase64 = base64urlToBase64(privJwk.d);
+  const pubPath = join(identityDir, "agent.pub");
+  const keyPath = join(identityDir, "agent.key");
+  await fs.writeFile(pubPath, pubBase64 + "\n", "utf-8");
+  await fs.writeFile(keyPath, privBase64 + "\n", {
+    mode: 384,
+    encoding: "utf-8"
+  });
+  return { publicKey: pubBase64, privateKey: privBase64 };
+}
+async function loadPublicKey(nitDir) {
+  const pubPath = join(nitDir, "identity", "agent.pub");
+  try {
+    return (await fs.readFile(pubPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      "No identity found. Run `nit init` to generate a keypair."
+    );
+  }
+}
+async function loadPrivateKey(nitDir) {
+  const pubBase64 = await loadPublicKey(nitDir);
+  const keyPath = join(nitDir, "identity", "agent.key");
+  let privBase64;
+  try {
+    privBase64 = (await fs.readFile(keyPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      "Private key not found at .nit/identity/agent.key. Regenerate with `nit init`."
+    );
+  }
+  const xB64url = base64ToBase64url(pubBase64);
+  const dB64url = base64ToBase64url(privBase64);
+  return createPrivateKey({
+    key: { kty: "OKP", crv: "Ed25519", x: xB64url, d: dB64url },
+    format: "jwk"
+  });
+}
+async function loadRawKeyPair(nitDir) {
+  const pubBase64 = await loadPublicKey(nitDir);
+  const keyPath = join(nitDir, "identity", "agent.key");
+  let privBase64;
+  try {
+    privBase64 = (await fs.readFile(keyPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      "Private key not found at .nit/identity/agent.key. Regenerate with `nit init`."
+    );
+  }
+  const seed = Buffer.from(privBase64, "base64");
+  const pubkey = Buffer.from(pubBase64, "base64");
+  const keypair = new Uint8Array(64);
+  keypair.set(seed, 0);
+  keypair.set(pubkey, 32);
+  return keypair;
+}
+function formatPublicKeyField(pubBase64) {
+  return `ed25519:${pubBase64}`;
+}
+function parsePublicKeyField(field) {
+  const prefix = "ed25519:";
+  if (!field.startsWith(prefix)) {
+    throw new Error(
+      `Invalid publicKey format: expected "ed25519:<base64>", got "${field}"`
+    );
+  }
+  return field.slice(prefix.length);
+}
+async function signChallenge(nitDir, challenge) {
+  const privateKey = await loadPrivateKey(nitDir);
+  const sig = sign(null, Buffer.from(challenge, "utf-8"), privateKey);
+  return sig.toString("base64");
+}
+async function signMessage(nitDir, message) {
+  const privateKey = await loadPrivateKey(nitDir);
+  const sig = sign(null, Buffer.from(message, "utf-8"), privateKey);
+  return sig.toString("base64");
+}
+var NIT_NAMESPACE = "801ba518-f326-47e5-97c9-d1efd1865a19";
+function deriveAgentId(publicKeyField) {
+  return uuidv5(publicKeyField, NIT_NAMESPACE);
+}
+async function loadAgentId(nitDir) {
+  const idPath = join(nitDir, "identity", "agent-id");
+  try {
+    return (await fs.readFile(idPath, "utf-8")).trim();
+  } catch {
+    throw new Error(
+      "No agent ID found. Run `nit init` to generate identity."
+    );
+  }
+}
+async function saveAgentId(nitDir, agentId) {
+  const idPath = join(nitDir, "identity", "agent-id");
+  await fs.writeFile(idPath, agentId + "\n", "utf-8");
+}
+function parseUuid(uuid) {
+  const hex = uuid.replace(/-/g, "");
+  return Buffer.from(hex, "hex");
+}
+function formatUuid(bytes) {
+  const hex = bytes.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+function uuidv5(name, namespace) {
+  const namespaceBytes = parseUuid(namespace);
+  const nameBytes = Buffer.from(name, "utf-8");
+  const data = Buffer.concat([namespaceBytes, nameBytes]);
+  const hash = createHash("sha1").update(data).digest();
+  const uuid = Buffer.from(hash.subarray(0, 16));
+  uuid[6] = uuid[6] & 15 | 80;
+  uuid[8] = uuid[8] & 63 | 128;
+  return formatUuid(uuid);
+}
+
+// src/remote.ts
+function sha256Hex(data) {
+  return createHash2("sha256").update(data, "utf-8").digest("hex");
+}
+async function buildAuthHeaders(nitDir, method, path, body) {
+  const agentId = await loadAgentId(nitDir);
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  let message = `${method}
+${path}
+${agentId}
+${timestamp}`;
+  if (body !== void 0) {
+    message += `
+${sha256Hex(body)}`;
+  }
+  const signature = await signMessage(nitDir, message);
+  return {
+    "X-Nit-Agent-Id": agentId,
+    "X-Nit-Timestamp": timestamp,
+    "X-Nit-Signature": signature
+  };
+}
+async function pushBranch(nitDir, apiBase, branch, cardJson, commitHash) {
+  const path = `/agent-card/branches/${encodeURIComponent(branch)}`;
+  const body = JSON.stringify({ card_json: cardJson, commit_hash: commitHash });
+  try {
+    const authHeaders = await buildAuthHeaders(nitDir, "PUT", path, body);
+    const res = await fetch(`${apiBase}${path}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders
+      },
+      body
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      return {
+        branch,
+        commitHash,
+        remoteUrl: apiBase,
+        success: false,
+        error: `HTTP ${res.status}: ${text}`
+      };
+    }
+    return { branch, commitHash, remoteUrl: apiBase, success: true };
+  } catch (err) {
+    return {
+      branch,
+      commitHash,
+      remoteUrl: apiBase,
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function pushAll(nitDir, apiBase, branches) {
+  const results = [];
+  for (const b of branches) {
+    const result = await pushBranch(nitDir, apiBase, b.name, b.cardJson, b.commitHash);
+    results.push(result);
+  }
+  return results;
+}
+async function listRemoteBranches(nitDir, apiBase) {
+  const path = "/agent-card/branches";
+  const authHeaders = await buildAuthHeaders(nitDir, "GET", path);
+  const res = await fetch(`${apiBase}${path}`, {
+    headers: authHeaders
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to list remote branches: HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return data.branches.map((b) => b.name);
+}
+async function deleteRemoteBranch(nitDir, apiBase, branch) {
+  const path = `/agent-card/branches/${encodeURIComponent(branch)}`;
+  const authHeaders = await buildAuthHeaders(nitDir, "DELETE", path);
+  const res = await fetch(`${apiBase}${path}`, {
+    method: "DELETE",
+    headers: authHeaders
+  });
+  return res.ok;
+}
+async function fetchBranchCard(cardUrl, branch, nitDir) {
+  const baseUrl = cardUrl.replace(/\/$/, "");
+  let url = `${baseUrl}/.well-known/agent-card.json`;
+  if (branch !== "main") {
+    url += `?branch=${encodeURIComponent(branch)}`;
+  }
+  const res = await fetch(url);
+  if (res.ok) {
+    return await res.json();
+  }
+  if (res.status === 401 && branch !== "main") {
+    if (!nitDir) {
+      throw new Error(
+        `Branch "${branch}" requires authentication. Provide nitDir for signing.`
+      );
+    }
+    const challengeData = await res.json();
+    const signature = await signChallenge(nitDir, challengeData.challenge);
+    const authRes = await fetch(url, {
+      headers: {
+        "X-Nit-Challenge": challengeData.challenge,
+        "X-Nit-Signature": signature
+      }
+    });
+    if (!authRes.ok) {
+      const body = await authRes.text();
+      throw new Error(
+        `Failed to fetch branch "${branch}" after challenge: HTTP ${authRes.status} ${body}`
+      );
+    }
+    return await authRes.json();
+  }
+  throw new Error(`Failed to fetch card: HTTP ${res.status}`);
+}
+
+export {
+  generateKeypair,
+  loadPublicKey,
+  loadPrivateKey,
+  loadRawKeyPair,
+  formatPublicKeyField,
+  parsePublicKeyField,
+  signChallenge,
+  signMessage,
+  NIT_NAMESPACE,
+  deriveAgentId,
+  loadAgentId,
+  saveAgentId,
+  pushBranch,
+  pushAll,
+  listRemoteBranches,
+  deleteRemoteBranch,
+  fetchBranchCard
+};

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 // nit — version control for agent cards
 import {
+  authSet,
+  authShow,
   branch,
   broadcast,
   checkout,
@@ -10,16 +12,20 @@ import {
   init,
   log,
   loginPayload,
+  pull,
   push,
   remote,
   remoteAdd,
   remoteSetUrl,
+  reset,
   rpcInfo,
   rpcSetUrl,
+  show,
   sign,
   signTx,
   status
-} from "./chunk-Q5GX7ZXR.js";
+} from "./chunk-445BLP4Q.js";
+import "./chunk-M6SR6QMR.js";
 
 // src/update-check.ts
 import { execSync } from "child_process";
@@ -32,7 +38,7 @@ var FETCH_TIMEOUT_MS = 3e3;
 var REGISTRY_URL = "https://registry.npmjs.org/@newtype-ai/nit/latest";
 function getCurrentVersion() {
   try {
-    return "0.4.9";
+    return "0.4.11";
   } catch {
     return "0.0.0";
   }
@@ -162,6 +168,18 @@ async function main() {
       case "rpc":
         await cmdRpc(args);
         break;
+      case "auth":
+        await cmdAuth(args);
+        break;
+      case "reset":
+        await cmdReset(args);
+        break;
+      case "show":
+        await cmdShow(args);
+        break;
+      case "pull":
+        await cmdPull(args);
+        break;
       case "help":
       case "--help":
       case "-h":
@@ -359,6 +377,7 @@ async function cmdSign(args) {
     if (payload.createdSkill) {
       console.error(`Created skill template '${payload.createdSkill}'`);
     }
+    console.error(`Auth: use browser profile="user" to reuse existing sessions. If login required, click OAuth buttons. Do NOT enter credentials.`);
     const { switchedBranch: _s, createdSkill: _c, ...output } = payload;
     console.log(JSON.stringify(output, null, 2));
     return;
@@ -439,6 +458,100 @@ async function cmdRpc(args) {
     console.log(`  ${bold(chain)}: ${config.url}`);
   }
 }
+async function cmdReset(args) {
+  const target = args[0];
+  const result = await reset(target);
+  console.log(`Reset to ${dim(result.hash.slice(0, 8))}`);
+}
+async function cmdShow(args) {
+  const target = args[0];
+  const s = await show(target);
+  const date = new Date(s.timestamp * 1e3).toISOString().slice(0, 19);
+  console.log(`${bold("commit")} ${yellow(s.hash.slice(0, 8))}`);
+  console.log(`Author: ${s.author}`);
+  console.log(`Date:   ${date}`);
+  if (s.parent) {
+    console.log(`Parent: ${dim(s.parent.slice(0, 8))}`);
+  }
+  console.log();
+  console.log(`    ${s.message}`);
+  console.log();
+  console.log(JSON.stringify(s.cardJson, null, 2));
+}
+async function cmdPull(args) {
+  const all = args.includes("--all");
+  const results = await pull({ all });
+  for (const r of results) {
+    if (r.updated) {
+      console.log(`${green("\u2713")} ${r.branch} \u2190 ${dim(r.commitHash.slice(0, 8))}`);
+    } else {
+      console.log(`${dim("\u2014")} ${r.branch} ${dim("(up to date)")}`);
+    }
+  }
+}
+async function cmdAuth(args) {
+  const subcommand = args[0];
+  if (subcommand === "set") {
+    const domain = args[1];
+    if (!domain) {
+      console.error("Usage: nit auth set <domain> --provider <google|github|x> --account <email>");
+      process.exit(1);
+    }
+    const providerIndex = args.indexOf("--provider");
+    if (providerIndex === -1 || !args[providerIndex + 1]) {
+      console.error("Missing --provider. Usage: nit auth set <domain> --provider <google|github|x> --account <email>");
+      process.exit(1);
+    }
+    const provider = args[providerIndex + 1];
+    const validProviders = ["google", "github", "x"];
+    if (!validProviders.includes(provider)) {
+      console.error(`Unknown provider: ${provider}. Use: google, github, x`);
+      process.exit(1);
+    }
+    const accountIndex = args.indexOf("--account");
+    if (accountIndex === -1 || !args[accountIndex + 1]) {
+      console.error("Missing --account. Usage: nit auth set <domain> --provider <google|github|x> --account <email>");
+      process.exit(1);
+    }
+    const account = args[accountIndex + 1];
+    const result = await authSet(domain, provider, account);
+    if (result.createdBranch) {
+      console.log(`Created branch '${green(result.branch)}'`);
+    }
+    if (result.switchedBranch) {
+      console.log(`Switched to branch '${green(result.switchedBranch)}'`);
+    }
+    console.log(`${green("\u2713")} Auth configured for ${bold(domain)}: ${result.provider} (${result.account})`);
+    console.log(dim(`  Updated SKILL.md: ${result.skillId}/SKILL.md`));
+    return;
+  }
+  if (subcommand === "show") {
+    const domain = args[1];
+    const results = await authShow(domain);
+    if (results.length === 0) {
+      if (domain) {
+        console.log(dim(`No auth configured for '${domain}'.`));
+      } else {
+        console.log(dim("No branches with auth configured."));
+      }
+      return;
+    }
+    for (const r of results) {
+      if (r.auth) {
+        console.log(`  ${bold(r.branch)}: ${r.auth.provider} (${r.auth.account})`);
+      } else {
+        console.log(`  ${bold(r.branch)}: ${dim("(no auth)")}`);
+      }
+    }
+    return;
+  }
+  if (subcommand) {
+    console.error(`nit auth: unknown subcommand '${subcommand}'`);
+  }
+  console.error("Usage: nit auth set <domain> --provider <google|github|x> --account <email>");
+  console.error("       nit auth show [domain]");
+  process.exit(1);
+}
 function printUsage() {
   console.log(`
 ${bold("nit")} \u2014 version control for agent cards
@@ -454,6 +567,9 @@ ${bold("Commands:")}
   branch [name]      List branches or create a new one
   checkout <branch>  Switch branch (overwrites agent-card.json)
   push [--all]       Push branch(es) to remote
+  pull [--all]       Pull branch(es) from remote
+  reset [target]     Restore agent-card.json from HEAD or target
+  show [target]      Show commit metadata and card content
   sign "message"     Sign a message with your Ed25519 key
   sign --login <dom> Switch to domain branch + generate login payload
   remote             Show remote info
@@ -463,6 +579,9 @@ ${bold("Commands:")}
   broadcast --chain <c> <tx>  Send signed tx to RPC endpoint
   rpc                Show configured RPC endpoints
   rpc set-url <c> <url>  Set RPC endpoint for a chain
+  auth set <dom> --provider <p> --account <a>
+                     Configure OAuth auth for a branch
+  auth show [dom]    Show auth config for branch(es)
 
 ${bold("Examples:")}
   nit init

package/dist/index.d.ts

@@ -151,6 +151,13 @@ interface BroadcastResult {
     /** RPC endpoint used */
     rpcUrl: string;
 }
+/** OAuth provider for per-branch authentication config. */
+type AuthProvider = 'google' | 'github' | 'x';
+/** Per-branch authentication configuration stored in SKILL.md frontmatter. */
+interface AuthConfig {
+    provider: AuthProvider;
+    account: string;
+}
 /** Result of generating a login payload for app authentication. */
 interface LoginPayload {
     agent_id: string;
@@ -420,5 +427,88 @@ declare function rpcSetUrl(chain: string, url: string, options?: {
 declare function rpcInfo(options?: {
     projectDir?: string;
 }): Promise<Record<string, NitRpcConfig>>;
+/**
+ * Restore agent-card.json from a commit, discarding uncommitted changes.
+ *
+ * - No target: restore from HEAD (discard all uncommitted changes)
+ * - Commit hash or branch name: restore card from that commit
+ *
+ * Does NOT move the branch pointer — only overwrites the working card.
+ */
+declare function reset(target?: string, options?: {
+    projectDir?: string;
+}): Promise<{
+    hash: string;
+}>;
+interface ShowResult {
+    hash: string;
+    card: string;
+    parent: string | null;
+    author: string;
+    timestamp: number;
+    message: string;
+    cardJson: AgentCard;
+}
+/**
+ * Show a commit's metadata and card content.
+ *
+ * - No target: show HEAD
+ * - Commit hash or branch name: show that commit
+ */
+declare function show(target?: string, options?: {
+    projectDir?: string;
+}): Promise<ShowResult>;
+interface PullResult {
+    branch: string;
+    commitHash: string;
+    updated: boolean;
+}
+/**
+ * Fetch current branch (or all branches) from the remote and update local state.
+ *
+ * 1. Fetch card JSON from remote
+ * 2. Write card to object store
+ * 3. Create a commit object
+ * 4. Update branch ref + remote-tracking ref
+ * 5. Write card to working copy (current branch only)
+ */
+declare function pull(options?: {
+    projectDir?: string;
+    remoteName?: string;
+    all?: boolean;
+}): Promise<PullResult[]>;
+interface AuthSetResult {
+    branch: string;
+    skillId: string;
+    provider: AuthProvider;
+    account: string;
+    switchedBranch?: string;
+    createdBranch?: boolean;
+}
+interface AuthShowResult {
+    branch: string;
+    auth: AuthConfig | null;
+}
+/**
+ * Configure OAuth authentication for a branch.
+ *
+ * 1. Switches to the target branch (creates if needed)
+ * 2. Updates the branch's SKILL.md with auth frontmatter + consent instructions
+ * 3. Adds skill pointer to agent-card.json if not present
+ *
+ * The SKILL.md tells OpenClaw which OAuth provider and account to use when
+ * the agent encounters a login page. The agent reuses the human's existing
+ * Chrome session (browser-profile = user) and only handles OAuth consent
+ * flows — never enters credentials.
+ */
+declare function authSet(domain: string, provider: AuthProvider, account: string, options?: {
+    projectDir?: string;
+}): Promise<AuthSetResult>;
+/**
+ * Show auth config for a specific branch, or all branches with auth configured.
+ */
+declare function authShow(domain?: string, options?: {
+    projectDir?: string;
+}): Promise<AuthShowResult[]>;
 
-export { type AgentCard, type AgentCardSkill, type BroadcastResult, type DiffResult, type FieldDiff, type InitResult, type LoginPayload, NIT_NAMESPACE, type NitBranch, type NitCommit, type NitConfig, type NitHead, type NitRemoteConfig, type NitRpcConfig, type PushResult, type RemoteInfo, type SignTxResult, type SkillMetadata, type StatusResult, type WalletAddresses$1 as WalletAddresses, base58Encode, branch, broadcast, checkout, commit, deriveAgentId, diff, diffCards, fetchBranchCard, findNitDir, formatDiff, formatPublicKeyField, getEvmAddress, getSolanaAddress, getWalletAddresses, init, loadAgentId, loadRawKeyPair, loadSecp256k1RawKeyPair, log, loginPayload, parsePublicKeyField, push, remote, remoteAdd, remoteSetUrl, rpcInfo, rpcSetUrl, sign, signChallenge, signEvmHash, signMessage, signSolanaBytes, signTx, status };
+export { type AgentCard, type AgentCardSkill, type AuthConfig, type AuthProvider, type AuthSetResult, type AuthShowResult, type BroadcastResult, type DiffResult, type FieldDiff, type InitResult, type LoginPayload, NIT_NAMESPACE, type NitBranch, type NitCommit, type NitConfig, type NitHead, type NitRemoteConfig, type NitRpcConfig, type PullResult, type PushResult, type RemoteInfo, type ShowResult, type SignTxResult, type SkillMetadata, type StatusResult, type WalletAddresses$1 as WalletAddresses, authSet, authShow, base58Encode, branch, broadcast, checkout, commit, deriveAgentId, diff, diffCards, fetchBranchCard, findNitDir, formatDiff, formatPublicKeyField, getEvmAddress, getSolanaAddress, getWalletAddresses, init, loadAgentId, loadRawKeyPair, loadSecp256k1RawKeyPair, log, loginPayload, parsePublicKeyField, pull, push, remote, remoteAdd, remoteSetUrl, reset, rpcInfo, rpcSetUrl, show, sign, signChallenge, signEvmHash, signMessage, signSolanaBytes, signTx, status };

package/dist/index.js

@@ -1,44 +1,53 @@
 // nit — version control for agent cards
 import {
-  NIT_NAMESPACE,
+  authSet,
+  authShow,
   base58Encode,
   branch,
   broadcast,
   checkout,
   commit,
-  deriveAgentId,
   diff,
   diffCards,
-  fetchBranchCard,
   findNitDir,
   formatDiff,
-  formatPublicKeyField,
   getEvmAddress,
   getSolanaAddress,
   getWalletAddresses,
   init,
-  loadAgentId,
-  loadRawKeyPair,
   loadSecp256k1RawKeyPair,
   log,
   loginPayload,
-  parsePublicKeyField,
+  pull,
   push,
   remote,
   remoteAdd,
   remoteSetUrl,
+  reset,
   rpcInfo,
   rpcSetUrl,
+  show,
   sign,
-  signChallenge,
   signEvmHash,
-  signMessage,
   signSolanaBytes,
   signTx,
   status
-} from "./chunk-Q5GX7ZXR.js";
+} from "./chunk-445BLP4Q.js";
+import {
+  NIT_NAMESPACE,
+  deriveAgentId,
+  fetchBranchCard,
+  formatPublicKeyField,
+  loadAgentId,
+  loadRawKeyPair,
+  parsePublicKeyField,
+  signChallenge,
+  signMessage
+} from "./chunk-M6SR6QMR.js";
 export {
   NIT_NAMESPACE,
+  authSet,
+  authShow,
   base58Encode,
   branch,
   broadcast,
@@ -61,12 +70,15 @@ export {
   log,
   loginPayload,
   parsePublicKeyField,
+  pull,
   push,
   remote,
   remoteAdd,
   remoteSetUrl,
+  reset,
   rpcInfo,
   rpcSetUrl,
+  show,
   sign,
   signChallenge,
   signEvmHash,

package/dist/remote-WZ625MBZ.js

@@ -0,0 +1,15 @@
+// nit — version control for agent cards
+import {
+  deleteRemoteBranch,
+  fetchBranchCard,
+  listRemoteBranches,
+  pushAll,
+  pushBranch
+} from "./chunk-M6SR6QMR.js";
+export {
+  deleteRemoteBranch,
+  fetchBranchCard,
+  listRemoteBranches,
+  pushAll,
+  pushBranch
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newtype-ai/nit",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "Version control for agent cards",
   "type": "module",
   "bin": {