AbadgeUserClient

import { AbadgeUserClient } from "@abadge/sdk";

const client = new AbadgeUserClient({
  apiUrl: "https://api.abadge.io",
  sessionToken: userSessionToken,
  orgId: "org_...",  // optional — sets X-Abadge-Org-Id for org-scoped requests
});

client.orgs.create({ name, slug? });
client.orgs.list();
client.orgs.get(orgId);
client.orgs.update(orgId, { name });
client.orgs.delete(orgId);

client.listMembers(orgId);
client.inviteMember(orgId, { role });           // no email param — invites are token-based
client.getInviteInfo(token);
client.acceptInvite(token);
client.revokeInvite(orgId, invitationId);
client.removeMember(orgId, userId);
client.updateMemberRole(orgId, userId, role);

client.profiles.create({
  orgId: string;
  name: string;
  description?: string;
  storageMode: "zero_knowledge" | "server_managed";
});
client.profiles.list(orgId);
client.profiles.get(profileId);
client.bootstrapProfile(profileId, { wrappedRootKey, kdfSalt, kdfParams });
client.changeProfilePassword(profileId, { wrappedRootKey, kdfSalt, kdfParams });
client.setupProfileRecovery(profileId, { recoveryWrappedRootKey });
client.rotateProfileKey(profileId, {
  wrappedRootKey,
  recoveryWrappedRootKey?,
  rekeyedItems,
});
client.profiles.delete(profileId);

// Zero-knowledge item
client.items.create({
  storageMode: "zero_knowledge";
  label: string;
  encryptedItemKey: string;
  ciphertext: string;
});

// Server-managed item
client.items.create({
  storageMode: "server_managed";
  label: string;
  payload: ItemPayload;
});

client.items.list();             // scoped to active org
client.items.get(itemId);
client.items.update(itemId, data); // data shape matches items.update — includes contentVersion
client.items.delete(itemId);

// Owner reveal for server-managed items. Returns { payload: ItemPayload }.
// Pick fields from payload.fields yourself — the user-client method takes no
// field argument. Use agent.access.read for field-level resolution.
client.ownerReveal(itemId);

client.agents.create({
  name: string;
  kind: "local_cli" | "local_mcp" | "remote";
  authMethod?: "public_key_session";     // only value; default
  publicKey?: string;
  issueBootstrapToken?: boolean;
  metadata?: Record<string, unknown>;   // put description, owner tags, etc. here
});

client.agents.list();
client.agents.delete(agentId);          // revoke agent

// Issue a fresh bootstrap token for an existing agent.
client.issueBootstrapToken(agentId);

// Item target
client.permissions.create({
  agentId: string;
  itemId: string;
  capabilities: Capability[];   // e.g. ["read"] | ["use"]
  expiresAt?: string;           // ISO 8601
});

// Profile target
client.permissions.create({
  agentId: string;
  profileId: string;
  capabilities: Capability[];
  expiresAt?: string;
});

client.permissions.list({ agentId?, itemId?, profileId? });
client.permissions.delete(permissionId);

client.audit.list({
  agentId?: string;
  itemId?: string;
  eventType?: AuditEventType;
  result?: AuditResult;
  cursor?: string;
  limit?: number;            // 1-100, default 50
});

import { AbadgeUserClient } from "@abadge/sdk";

const client = new AbadgeUserClient({
  apiUrl: "https://api.abadge.io",
  sessionToken: userSessionToken,
  orgId: "org_...",
});

const { id: itemId } = await client.items.create({
  storageMode: "server_managed",
  payload: {
    v: 1,
    label: "GitHub Deploy Token",
    kind: "token",
    tags: ["ci", "github"],
    fields: { token: "ghp_xxxxxxxxxxxx" },
  },
});

const { agent, bootstrapToken } = await client.agents.create({
  name: "github-actions-deploy",
  kind: "remote",
  issueBootstrapToken: true,
});

await client.permissions.create({
  agentId: agent.id,
  itemId,
  capabilities: ["read"],
  expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
});