@seekrit/cli 1.9.1 → 1.9.2

package/dist/index.js

@@ -864,6 +864,12 @@ const ENTITLEMENT_KEYS = Object.keys({
 		description: "Push environment secrets to external platforms like Vercel.",
 		default: true
 	},
+	"feature.vault": {
+		kind: "feature",
+		label: "Vault",
+		description: "Capture, hold and apply your end users' credentials for an agent — without your systems or seekrit ever holding a plaintext.",
+		default: true
+	},
 	"apps.max": {
 		kind: "limit",
 		label: "Applications",
@@ -924,6 +930,12 @@ const ENTITLEMENT_KEYS = Object.keys({
 		description: "Maximum secrets with managed rotation configured.",
 		default: null
 	},
+	"vault.connections.max": {
+		kind: "limit",
+		label: "Vault connections",
+		description: "Maximum active end-user connections across the organization's Vault projects.",
+		default: null
+	},
 	members: {
 		kind: "metered",
 		label: "Members",
@@ -2031,7 +2043,25 @@ const AUDIT_ACTIONS = [
 	"change_request.rejected",
 	"change_request.withdrawn",
 	"change_request.applied",
-	"change_request.superseded"
+	"change_request.superseded",
+	"vault.project.created",
+	"vault.project.updated",
+	"vault.key.created",
+	"vault.key.revoked",
+	"vault.registration_code.created",
+	"vault.executor.registered",
+	"vault.executor.disabled",
+	"vault.executor.key_added",
+	"vault.executor.catalog_updated",
+	"vault.connect_session.created",
+	"vault.connection.created",
+	"vault.connection.reauth_required",
+	"vault.connection.reactivated",
+	"vault.connection.revoked",
+	"vault.credential.written",
+	"vault.credential.release_denied",
+	"vault.webhook.created",
+	"vault.webhook.deleted"
 ];
 /**
 * Transactional notification emails seekrit can send. Each id is one
@@ -3998,6 +4028,291 @@ z.object({
 	enabled: z.boolean().optional()
 });
 //#endregion
+//#region ../../packages/core/src/vault.ts
+/** One encrypted credential within a connection. */
+const VAULT_SLOTS = [
+	"oauth2",
+	"api_key",
+	"session",
+	"login"
+];
+const VAULT_CONNECTION_STATUSES = [
+	"active",
+	"reauth_required",
+	"revoked"
+];
+const VAULT_CONNECT_SESSION_MAX_TTL_SECONDS = 86400;
+/** Ciphertext bound: a `sc1.` blob of a 512 KiB session, with room for base64. */
+const VAULT_CIPHERTEXT_MAX_CHARS = 819200;
+/** Never above Browser Run's keep-alive ceiling, whatever a site profile asks for. */
+const VAULT_LEASE_MAX_MS = 12e5;
+const VAULT_LEASE_MIN_MS = 1e4;
+/** Fields `browser.fill` can type from a `login` slot. */
+const VAULT_FILL_FIELDS = [
+	"username",
+	"password",
+	"totp"
+];
+const VAULT_WEBHOOK_EVENTS = [
+	"connection.ready",
+	"connection.reauth_required",
+	"connection.revoked"
+];
+const base64urlMember = z.string().regex(/^[A-Za-z0-9_-]{43}$/, "not a P-256 coordinate");
+const vaultPublicJwkSchema = z.object({
+	kty: z.literal("EC"),
+	crv: z.literal("P-256"),
+	x: base64urlMember,
+	y: base64urlMember
+});
+const isoInstant = z.iso.datetime({ offset: true });
+z.object({
+	v: z.literal(1),
+	accessToken: z.string().min(1).max(16384),
+	tokenType: z.literal("Bearer"),
+	accessTokenExpiresAt: isoInstant.optional(),
+	refreshToken: z.string().min(1).max(16384).optional(),
+	refreshTokenExpiresAt: isoInstant.optional(),
+	scope: z.array(z.string().max(512)).max(128),
+	obtainedAt: isoInstant
+});
+z.object({
+	v: z.literal(1),
+	key: z.string().min(1).max(8192)
+});
+/** RFC 6238 parameters, as an authenticator app would hold them. */
+const vaultTotpSchema = z.object({
+	/** Base32 (RFC 4648), upper case, no padding, no separators. */
+	secret: z.string().regex(/^[A-Z2-7]{16,128}$/, "TOTP secret must be base32"),
+	digits: z.union([z.literal(6), z.literal(8)]),
+	period: z.number().int().min(15).max(120),
+	algorithm: z.enum([
+		"SHA1",
+		"SHA256",
+		"SHA512"
+	])
+});
+z.object({
+	v: z.literal(1),
+	username: z.string().min(1).max(512),
+	password: z.string().min(1).max(4096),
+	totp: vaultTotpSchema.optional()
+});
+const vaultSessionCookieSchema = z.object({
+	name: z.string().min(1).max(4096),
+	value: z.string().max(16384),
+	/** Kept exactly as captured — parent-domain cookies restore to their parent. */
+	domain: z.string().min(1).max(253),
+	path: z.string().min(1).max(4096),
+	/** Unix seconds; -1 ⇒ a session cookie. */
+	expires: z.number(),
+	httpOnly: z.boolean(),
+	secure: z.boolean(),
+	sameSite: z.enum([
+		"Strict",
+		"Lax",
+		"None"
+	]).optional(),
+	partitionKey: z.unknown().optional()
+});
+z.object({
+	v: z.literal(1),
+	siteId: z.string().min(1).max(64),
+	capturedAt: isoInstant,
+	userAgent: z.string().max(1024),
+	cookies: z.array(vaultSessionCookieSchema).max(4096),
+	/** origin → key → value. */
+	localStorage: z.record(z.string(), z.record(z.string(), z.string()))
+});
+const vaultProviderIdSchema = z.string().trim().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/, "provider ids are lowercase letters, digits, dots and dashes");
+/**
+* What the dashboard, Connect and the SDK may know about a provider: its name,
+* its method, and — for the consent screen — a plain sentence about what the
+* agent will be able to do. Never the rules, the endpoints or the injection:
+* those are compiled into the executor and the API must not be able to serve a
+* different version of them.
+*/
+const vaultCatalogProviderSchema = z.object({
+	id: vaultProviderIdSchema,
+	displayName: z.string().trim().min(1).max(80),
+	method: z.enum(["oauth2", "api_key"]),
+	/** The one sentence Connect shows: "read and send email as you". */
+	consentSummary: z.string().trim().min(1).max(240),
+	/** Hosts the executor will forward to, for display. */
+	hosts: z.array(z.string().trim().min(1).max(253)).max(64).default([]),
+	/** Where the end user finds the key (api_key providers). */
+	helpUrl: z.url().max(2048).optional(),
+	/** Label for the key field (api_key providers), e.g. "API key". */
+	keyLabel: z.string().trim().min(1).max(60).optional(),
+	/** OAuth scopes the provider will be asked for (oauth2 providers), for display. */
+	scopes: z.array(z.string().trim().min(1).max(512)).max(64).optional()
+});
+const vaultCatalogSiteSchema = z.object({
+	id: vaultProviderIdSchema,
+	displayName: z.string().trim().min(1).max(80),
+	consentSummary: z.string().trim().min(1).max(240),
+	/** Origins the login form must live on (shown so the person can check). */
+	loginOrigins: z.array(z.url().max(2048)).max(16).default([]),
+	/** Where a restored session lands, for display. */
+	startUrl: z.url().max(2048).optional()
+});
+const vaultCatalogSchema = z.object({
+	v: z.literal(1),
+	providers: z.array(vaultCatalogProviderSchema).max(200).default([]),
+	sites: z.array(vaultCatalogSiteSchema).max(200).default([])
+});
+const vaultDisplaySchema = z.object({
+	/** The platform's name as its users know it: "Instinct", not "instinct-prod". */
+	name: z.string().trim().min(1).max(80),
+	logoUrl: z.url().max(2048).startsWith("https://").optional(),
+	/** `#rrggbb`. */
+	accent: z.string().regex(/^#[0-9a-fA-F]{6}$/, "accent must be a #rrggbb colour").optional(),
+	/** Origins a `returnUrl` may point at. Exact-match, scheme + host (+ port). */
+	returnOrigins: z.array(z.url().max(2048)).max(16).default([])
+});
+z.object({
+	name: nameSchema,
+	display: vaultDisplaySchema.optional()
+});
+z.object({
+	name: nameSchema.optional(),
+	display: vaultDisplaySchema.optional(),
+	status: z.enum(["active", "disabled"]).optional()
+});
+z.object({ name: nameSchema });
+/**
+* The platform's opaque identifier for its end user. Stored as given and
+* returned as given. It must not be an email address or anything else that
+* identifies the person outside the platform: the person has no seekrit
+* account, and this is the one field about them Vault holds in the clear.
+*/
+const vaultUserRefSchema = z.string().trim().min(1).max(200).refine((v) => !/\s/.test(v), { message: "userRef must not contain whitespace" }).refine((v) => !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(v), { message: "userRef must be an opaque identifier, not an email address" });
+z.object({
+	userRef: vaultUserRefSchema,
+	providerId: vaultProviderIdSchema,
+	purpose: z.enum(["connect", "reconnect"]).default("connect"),
+	/** Required for `reconnect`: the connection being repaired. */
+	connectionId: z.string().trim().min(1).max(64).optional(),
+	/** Where the done screen may send the person. Must match a registered origin. */
+	returnUrl: z.url().max(2048).optional(),
+	expiresInSeconds: z.number().int().min(60).max(VAULT_CONNECT_SESSION_MAX_TTL_SECONDS).optional()
+});
+z.object({
+	userRef: vaultUserRefSchema,
+	returnUrl: z.url().max(2048).optional(),
+	expiresInSeconds: z.number().int().min(60).max(VAULT_CONNECT_SESSION_MAX_TTL_SECONDS).optional()
+});
+z.object({
+	url: z.url().max(2048).refine((u) => u.startsWith("https://"), "webhook URLs must be https"),
+	/** Defaults to every event. */
+	events: z.array(z.enum(VAULT_WEBHOOK_EVENTS)).min(1).max(VAULT_WEBHOOK_EVENTS.length).optional(),
+	description: z.string().trim().max(200).optional()
+});
+z.object({
+	userRef: vaultUserRefSchema.optional(),
+	status: z.enum(VAULT_CONNECTION_STATUSES).optional(),
+	cursor: z.string().max(200).optional(),
+	limit: z.coerce.number().int().min(1).max(200).default(50)
+});
+/** An `https://host[:port]` origin with nothing after it; `http://localhost` in dev. */
+const vaultOriginSchema = z.string().trim().max(2048).refine((v) => {
+	let url;
+	try {
+		url = new URL(v);
+	} catch {
+		return false;
+	}
+	if (url.origin !== v) return false;
+	if (url.protocol === "https:") return true;
+	return url.protocol === "http:" && [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+}, { message: "must be an https origin (scheme + host, nothing else)" });
+const vaultWrappingKeySchema = z.object({
+	jwk: vaultPublicJwkSchema,
+	thumbprint: z.string().regex(/^[A-Za-z0-9_-]{43}$/)
+});
+z.object({
+	code: z.string().trim().min(16).max(200),
+	origin: vaultOriginSchema,
+	wrappingKey: vaultWrappingKeySchema,
+	catalog: vaultCatalogSchema,
+	sdkVersion: z.string().trim().min(1).max(40)
+});
+z.object({
+	catalog: vaultCatalogSchema,
+	sdkVersion: z.string().trim().min(1).max(40)
+});
+z.object({ wrappingKey: vaultWrappingKeySchema });
+/** One encrypted slot, as produced by Connect or the executor. */
+const vaultEncryptedSlotSchema = z.object({
+	slot: z.enum(VAULT_SLOTS),
+	revision: z.number().int().min(1),
+	ciphertext: z.string().startsWith("sc1.").max(VAULT_CIPHERTEXT_MAX_CHARS),
+	wrappedDek: z.string().startsWith("wd1.").max(2048),
+	keyThumbprint: z.string().regex(/^[A-Za-z0-9_-]{43}$/)
+});
+z.object({
+	slots: z.array(vaultEncryptedSlotSchema).min(1).max(2),
+	/** "ava@example.com" / "@ava" — shown to the platform and the org, never used for auth. */
+	accountLabel: z.string().trim().min(1).max(200).optional()
+});
+z.object({
+	/** The revision the writer read; the write lands as `expectedRevision + 1`. */
+	expectedRevision: z.number().int().min(0),
+	ciphertext: z.string().startsWith("sc1.").max(VAULT_CIPHERTEXT_MAX_CHARS),
+	wrappedDek: z.string().startsWith("wd1.").max(2048),
+	keyThumbprint: z.string().regex(/^[A-Za-z0-9_-]{43}$/)
+});
+z.discriminatedUnion("status", [z.object({
+	status: z.literal("reauth_required"),
+	reason: z.string().trim().min(1).max(120)
+}), z.object({ status: z.literal("active") })]);
+z.object({ claimToken: z.string().min(16).max(200) });
+z.object({ token: z.string().min(16).max(200) });
+z.object({ consentVersion: z.literal(1) });
+z.object({ connectionId: z.string().trim().min(1).max(64) });
+z.object({
+	login: vaultEncryptedSlotSchema.refine((slot) => slot.slot === "login", "must be the login slot").optional(),
+	accountLabel: z.string().trim().min(1).max(200).optional()
+});
+z.object({
+	userRef: vaultUserRefSchema,
+	connectionId: z.string().trim().min(1).max(64),
+	request: z.object({
+		method: z.string().trim().toUpperCase().regex(/^[A-Z]{3,10}$/),
+		url: z.url().max(8192),
+		headers: z.record(z.string().max(256), z.string().max(16384)).optional(),
+		/** UTF-8 text. Binary bodies are out of scope for V1. */
+		body: z.string().max(4194304).optional()
+	})
+});
+const connectionIdSchema = z.string().trim().min(1).max(64);
+const leaseIdSchema = z.string().trim().min(1).max(64);
+z.object({
+	userRef: vaultUserRefSchema,
+	connectionId: connectionIdSchema,
+	/** How long the agent may hold the browser. Clamped to the site's ceiling. */
+	keepAliveMs: z.number().int().min(VAULT_LEASE_MIN_MS).max(VAULT_LEASE_MAX_MS).optional()
+});
+z.object({
+	userRef: vaultUserRefSchema,
+	leaseId: leaseIdSchema,
+	field: z.enum(VAULT_FILL_FIELDS)
+});
+z.object({
+	userRef: vaultUserRefSchema,
+	leaseId: leaseIdSchema,
+	/** Write the rotated session back (default). `false` drops the browser without saving. */
+	save: z.boolean().default(true)
+});
+z.object({
+	userRef: vaultUserRefSchema,
+	leaseId: leaseIdSchema
+});
+//#endregion
 //#region ../../packages/crypto/src/encoding.ts
 const CHUNK = 32768;
 /** Base64url (no padding) — portable across browsers, Workers, and Node. */
@@ -5225,7 +5540,7 @@ async function createAgentTaskToken() {
 }
 //#endregion
 //#region package.json
-var version = "1.9.1";
+var version = "1.9.2";
 //#endregion
 //#region ../../packages/api-client/src/index.ts
 /**
@@ -5962,6 +6277,52 @@ var SeekritClient = class {
 	redeemPromoCode(orgId, input) {
 		return this.request("POST", `/v1/orgs/${orgId}/billing/promo`, input);
 	}
+	listVaultProjects(orgId) {
+		return this.request("GET", `/v1/orgs/${orgId}/vault/projects`);
+	}
+	createVaultProject(orgId, input) {
+		return this.request("POST", `/v1/orgs/${orgId}/vault/projects`, input);
+	}
+	getVaultProject(orgId, projectId) {
+		return this.request("GET", `/v1/orgs/${orgId}/vault/projects/${projectId}`);
+	}
+	updateVaultProject(orgId, projectId, input) {
+		return this.request("PATCH", `/v1/orgs/${orgId}/vault/projects/${projectId}`, input);
+	}
+	/**
+	* Mint a platform key. The `secret` is the `skv_…` string, returned exactly
+	* once; the server keeps only its hash. Needs a browser session with a fresh
+	* second factor — the API answers `mfa_required` otherwise.
+	*/
+	createVaultPlatformKey(orgId, projectId, input) {
+		return this.request("POST", `/v1/orgs/${orgId}/vault/projects/${projectId}/keys`, input);
+	}
+	revokeVaultPlatformKey(orgId, projectId, keyId) {
+		return this.request("DELETE", `/v1/orgs/${orgId}/vault/projects/${projectId}/keys/${keyId}`);
+	}
+	/** A one-time executor registration code (10 minutes). Same step-up rule as a key. */
+	createVaultRegistrationCode(orgId, projectId) {
+		return this.request("POST", `/v1/orgs/${orgId}/vault/projects/${projectId}/registration-codes`);
+	}
+	disableVaultExecutor(orgId, projectId) {
+		return this.request("POST", `/v1/orgs/${orgId}/vault/projects/${projectId}/executor/disable`);
+	}
+	listVaultConnections(orgId, projectId, query = {}) {
+		const params = new URLSearchParams();
+		for (const [key, value] of Object.entries(query)) if (value !== void 0 && value !== "") params.set(key, String(value));
+		const qs = params.toString();
+		return this.request("GET", `/v1/orgs/${orgId}/vault/projects/${projectId}/connections${qs ? `?${qs}` : ""}`);
+	}
+	revokeVaultConnection(orgId, projectId, connectionId) {
+		return this.request("POST", `/v1/orgs/${orgId}/vault/projects/${projectId}/connections/${connectionId}/revoke`);
+	}
+	/** Webhook endpoints a platform registered with its key; the dashboard reads and removes. */
+	listVaultWebhooks(orgId, projectId) {
+		return this.request("GET", `/v1/orgs/${orgId}/vault/projects/${projectId}/webhooks`);
+	}
+	deleteVaultWebhook(orgId, projectId, webhookId) {
+		return this.request("DELETE", `/v1/orgs/${orgId}/vault/projects/${projectId}/webhooks/${webhookId}`);
+	}
 };
 async function unauthenticatedPost(baseUrl, path, body, fetchImpl, client) {
 	const headers = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seekrit/cli",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "End-to-end encrypted secrets manager CLI — inject decrypted secrets into any command.",
   "type": "module",
   "publishConfig": {