@repome/api 0.1.2

package/dist/index.mjs

@@ -0,0 +1,730 @@
+import * as z from "zod";
+import { oc } from "@orpc/contract";
+//#region src/base.ts
+const commonErrors = {
+	BAD_REQUEST: {
+		status: 400,
+		message: "Bad request",
+		data: z.object({}).optional()
+	},
+	UNAUTHENTICATED: {
+		status: 401,
+		message: "Sign in required",
+		data: z.object({}).optional()
+	},
+	FORBIDDEN: {
+		status: 403,
+		message: "You do not have access to this resource",
+		data: z.object({}).optional()
+	},
+	INVITATION_NOT_FOUND: {
+		status: 404,
+		message: "Invitation not found",
+		data: z.object({ invitationId: z.string() })
+	},
+	REPO_NOT_FOUND: {
+		status: 404,
+		message: "Repo not found",
+		data: z.object({ name: z.string() })
+	},
+	GIT_OBJECT_NOT_FOUND: {
+		status: 404,
+		message: "Git object not found",
+		data: z.object({
+			name: z.string(),
+			object: z.string()
+		})
+	},
+	REF_ALREADY_EXISTS: {
+		status: 409,
+		message: "Git ref already exists",
+		data: z.object({
+			name: z.string(),
+			ref: z.string()
+		})
+	},
+	STALE_REF: {
+		status: 409,
+		message: "Git ref is stale",
+		data: z.object({
+			name: z.string(),
+			ref: z.string()
+		})
+	},
+	NON_FAST_FORWARD: {
+		status: 422,
+		message: "Git ref update is not a fast-forward",
+		data: z.object({
+			name: z.string(),
+			ref: z.string()
+		})
+	},
+	INVALID_TREE: {
+		status: 422,
+		message: "Invalid git tree",
+		data: z.object({
+			name: z.string(),
+			object: z.string()
+		})
+	},
+	INVALID_PARENT: {
+		status: 422,
+		message: "Invalid git parent",
+		data: z.object({
+			name: z.string(),
+			object: z.string()
+		})
+	},
+	INVARIANT_WORKSPACE_REQUIRED: {
+		status: 503,
+		message: "Repo workspace is required for this git operation",
+		data: z.object({ name: z.string() })
+	},
+	GIT_REMOTE_WRITE_FAILED: {
+		status: 502,
+		message: "Git remote write failed",
+		data: z.object({
+			name: z.string(),
+			ref: z.string()
+		})
+	},
+	REPO_ALREADY_EXISTS: {
+		status: 409,
+		message: "Repo already exists",
+		data: z.object({ name: z.string() })
+	},
+	QUOTA_EXCEEDED: {
+		status: 429,
+		message: "Quota exceeded",
+		data: z.object({
+			scope: z.enum([
+				"anon",
+				"org",
+				"size"
+			]),
+			limit: z.number(),
+			observed: z.number().optional(),
+			projected: z.number().optional()
+		})
+	},
+	PAYLOAD_TOO_LARGE: {
+		status: 413,
+		message: "Request payload exceeds the supported limit",
+		data: z.object({
+			scope: z.enum(["workspace_commit", "git_workspace_memory"]),
+			limit: z.number(),
+			observed: z.number().optional()
+		})
+	},
+	IMPORT_FAILED: {
+		status: 502,
+		message: "Repo import failed",
+		data: z.object({ name: z.string() })
+	}
+};
+const ocBase = oc.errors(commonErrors);
+//#endregion
+//#region src/orgs.ts
+const orgSlugHint = "Lowercase, alphanumeric, - only.";
+const orgSlugSchema = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-]*$/, orgSlugHint);
+const repoScopeSchema = z.object({ orgSlug: orgSlugSchema.optional() });
+const orgIdOrSlugSchema = z.object({ idOrSlug: z.string().min(1) });
+const orgCreateInputSchema = z.object({
+	slug: orgSlugSchema,
+	name: z.string().min(1).max(80)
+});
+const orgViewSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	name: z.string(),
+	logo: z.string().nullable(),
+	metadata: z.string().nullable(),
+	createdAt: z.number()
+});
+const orgListOutputSchema = z.object({ items: z.array(orgViewSchema) });
+const orgs = {
+	create: ocBase.input(orgCreateInputSchema).output(orgViewSchema),
+	list: ocBase.output(orgListOutputSchema),
+	get: ocBase.input(orgIdOrSlugSchema).output(orgViewSchema),
+	delete: ocBase.input(orgIdOrSlugSchema).output(z.object({ deleted: z.literal(true) }))
+};
+//#endregion
+//#region src/repos.ts
+const repoNameHint = "Lowercase, alphanumeric, ._- only.";
+const repoNameSchema = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/, repoNameHint);
+function parseRepoName(value) {
+	return repoNameSchema.parse(value);
+}
+const repoIdentSchema = repoScopeSchema.extend({ name: repoNameSchema });
+const repoCreateInputSchema = repoIdentSchema.extend({
+	description: z.string().max(512).optional(),
+	defaultBranch: z.string().min(1).max(128).default("main")
+});
+const repoEnsureInputSchema = repoCreateInputSchema;
+const repoImportInputSchema = repoCreateInputSchema.extend({ remote: z.url() });
+const repoUpdateInputSchema = repoIdentSchema.extend({
+	description: z.string().max(512).nullable().optional(),
+	defaultBranch: z.string().min(1).max(128).optional()
+});
+const repoListInputSchema = repoScopeSchema.extend({
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(100).default(50)
+});
+const repoSchema = z.object({
+	orgId: z.string(),
+	name: z.string(),
+	ownerId: z.string(),
+	description: z.string().nullable(),
+	defaultBranch: z.string(),
+	artifactName: z.string(),
+	artifactId: z.string().nullable(),
+	remote: z.string().nullable(),
+	readOnly: z.boolean(),
+	lastPushAt: z.string().nullable(),
+	source: z.string().nullable(),
+	createdAt: z.number(),
+	updatedAt: z.number()
+});
+const repoCreateOutputSchema = repoSchema.extend({
+	token: z.string(),
+	tokenExpiresAt: z.string()
+});
+const repoListOutputSchema = z.object({
+	items: z.array(repoSchema),
+	nextCursor: z.string().nullable()
+});
+const repoDeleteOutputSchema = z.object({ deleted: z.literal(true) });
+const repoEnsureOutputSchema = z.object({
+	repo: repoSchema,
+	created: z.boolean()
+});
+const repos = {
+	create: ocBase.input(repoCreateInputSchema).output(repoCreateOutputSchema),
+	importFromGitHub: ocBase.input(repoImportInputSchema).output(repoCreateOutputSchema),
+	ensure: ocBase.input(repoEnsureInputSchema).output(repoEnsureOutputSchema),
+	get: ocBase.input(repoIdentSchema).output(repoSchema),
+	list: ocBase.input(repoListInputSchema).output(repoListOutputSchema),
+	update: ocBase.input(repoUpdateInputSchema).output(repoSchema),
+	delete: ocBase.input(repoIdentSchema).output(repoDeleteOutputSchema)
+};
+//#endregion
+//#region src/git.ts
+const pageInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(100).default(50)
+});
+const refInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1)
+});
+const oidInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	oid: z.string().min(1)
+});
+const treeInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1).default("HEAD"),
+	path: z.string().optional(),
+	recursive: z.boolean().default(true),
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(100).default(50)
+});
+const blobInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	oid: z.string().min(1)
+});
+const signatureSchema$1 = z.object({
+	name: z.string().min(1),
+	email: z.email(),
+	timestamp: z.number().int().optional(),
+	timezoneOffset: z.number().int().optional()
+});
+const branchCreateInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	branch: z.string().min(1),
+	fromRef: z.string().min(1)
+});
+const branchUpdateInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1),
+	oid: z.string().min(1),
+	expectedOid: z.string().min(1).optional(),
+	force: z.boolean().optional(),
+	allowDefaultBranchRewrite: z.boolean().optional()
+});
+const branchDeleteInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1),
+	expectedOid: z.string().min(1).optional()
+});
+const tagCreateInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	tag: z.string().min(1),
+	oid: z.string().min(1),
+	message: z.string().min(1).optional(),
+	tagger: signatureSchema$1.optional()
+});
+const tagDeleteInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1)
+});
+const commitCreateInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1),
+	message: z.string().min(1),
+	tree: z.string().min(1),
+	parents: z.array(z.string().min(1)),
+	expectedOid: z.string().min(1).optional(),
+	author: signatureSchema$1.optional(),
+	committer: signatureSchema$1.optional()
+});
+const workspaceFileSchema$1 = z.object({
+	path: z.string().min(1),
+	content: z.string(),
+	encoding: z.literal("base64").default("base64")
+});
+const workspaceCommitInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	ref: z.string().min(1).default("refs/heads/main"),
+	message: z.string().min(1),
+	files: z.array(workspaceFileSchema$1).default([]),
+	removes: z.array(z.string().min(1)).default([]),
+	expectedOid: z.string().min(1).optional(),
+	author: signatureSchema$1.optional(),
+	committer: signatureSchema$1.optional()
+}).refine((input) => input.files.length + input.removes.length > 0, {
+	message: "workspace.commit requires at least one file or remove",
+	path: ["files"]
+});
+const compareInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	base: z.string().min(1),
+	head: z.string().min(1),
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(250).default(250)
+});
+const diffInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	base: z.string().min(1),
+	head: z.string().min(1),
+	path: z.string().optional(),
+	includePatch: z.boolean().default(false),
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(250).default(50)
+});
+const gitRefSchema = z.object({
+	name: z.string(),
+	oid: z.string(),
+	type: z.enum([
+		"branch",
+		"tag",
+		"other"
+	])
+});
+const gitCommitSchema = z.object({
+	oid: z.string(),
+	message: z.string(),
+	authorName: z.string().nullable(),
+	authorEmail: z.string().nullable(),
+	authoredAt: z.string().nullable()
+});
+const gitTreeEntrySchema = z.object({
+	path: z.string(),
+	oid: z.string(),
+	type: z.enum(["tree", "blob"]),
+	mode: z.string()
+});
+const gitBlobSchema = z.object({
+	oid: z.string(),
+	encoding: z.literal("base64"),
+	content: z.string()
+});
+const gitBlobTooLargeSchema = z.object({
+	oid: z.string(),
+	tooLarge: z.literal(true),
+	byteLength: z.number().int().nonnegative().nullable(),
+	limit: z.number().int().positive()
+});
+const diffFileSchema = z.object({
+	path: z.string(),
+	oldOid: z.string().nullable(),
+	newOid: z.string().nullable(),
+	status: z.enum([
+		"added",
+		"modified",
+		"deleted"
+	]),
+	additions: z.number().int(),
+	deletions: z.number().int(),
+	patch: z.string().optional(),
+	binary: z.boolean()
+});
+const compareViewSchema = z.object({
+	base: z.string(),
+	head: z.string(),
+	baseCommit: z.string(),
+	headCommit: z.string(),
+	mergeBase: z.string().nullable(),
+	aheadBy: z.number().int(),
+	behindBy: z.number().int(),
+	commits: pageOf$1(gitCommitSchema),
+	mergeable: z.enum([
+		"clean",
+		"dirty",
+		"unknown"
+	]),
+	conflicts: z.array(z.string())
+});
+const diffViewSchema = z.object({
+	files: pageOf$1(diffFileSchema),
+	stats: z.object({
+		additions: z.number().int(),
+		deletions: z.number().int(),
+		changedFiles: z.number().int()
+	}),
+	patchTruncated: z.boolean(),
+	tooLarge: z.boolean().optional()
+});
+function pageOf$1(item) {
+	return z.object({
+		items: z.array(item),
+		nextCursor: z.string().nullable(),
+		hasMore: z.boolean()
+	});
+}
+const git = {
+	refs: {
+		list: ocBase.input(pageInputSchema).output(pageOf$1(gitRefSchema)),
+		get: ocBase.input(refInputSchema).output(gitRefSchema)
+	},
+	branches: {
+		list: ocBase.input(pageInputSchema).output(pageOf$1(gitRefSchema)),
+		get: ocBase.input(refInputSchema).output(gitRefSchema),
+		create: ocBase.input(branchCreateInputSchema).output(gitRefSchema),
+		update: ocBase.input(branchUpdateInputSchema).output(gitRefSchema),
+		delete: ocBase.input(branchDeleteInputSchema).output(z.object({ deleted: z.literal(true) }))
+	},
+	tags: {
+		list: ocBase.input(pageInputSchema).output(pageOf$1(gitRefSchema)),
+		get: ocBase.input(refInputSchema).output(gitRefSchema),
+		create: ocBase.input(tagCreateInputSchema).output(gitRefSchema),
+		delete: ocBase.input(tagDeleteInputSchema).output(z.object({ deleted: z.literal(true) }))
+	},
+	commits: {
+		list: ocBase.input(pageInputSchema.extend({ ref: z.string().optional() })).output(pageOf$1(gitCommitSchema)),
+		get: ocBase.input(oidInputSchema).output(gitCommitSchema),
+		create: ocBase.input(commitCreateInputSchema).output(z.object({
+			commit: gitCommitSchema,
+			ref: gitRefSchema
+		}))
+	},
+	tree: { get: ocBase.input(treeInputSchema).output(pageOf$1(gitTreeEntrySchema)) },
+	blob: { get: ocBase.input(blobInputSchema).output(z.union([gitBlobSchema, gitBlobTooLargeSchema])) },
+	workspace: { commit: ocBase.input(workspaceCommitInputSchema).output(z.object({
+		commit: gitCommitSchema,
+		ref: gitRefSchema
+	})) },
+	compare: ocBase.input(compareInputSchema).output(compareViewSchema),
+	diff: ocBase.input(diffInputSchema).output(diffViewSchema)
+};
+//#endregion
+//#region src/tokens.ts
+const tokenScopeSchema = z.enum(["read", "write"]);
+const tokenMintInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	scope: tokenScopeSchema,
+	ttlSeconds: z.number().int().positive().optional(),
+	op: z.string().min(1).max(32).optional()
+});
+const tokenIdentInputSchema = repoScopeSchema.extend({
+	name: repoNameSchema,
+	id: z.string().min(1)
+});
+const tokenValidateInputSchema = z.object({ token: z.string().min(1) });
+const tokenMintForGitRemoteInputSchema = z.object({
+	protocol: z.literal("https"),
+	host: z.string().min(1),
+	path: z.string().min(1),
+	ttlSeconds: z.number().int().positive().optional(),
+	op: z.string().min(1).max(32).optional()
+});
+const tokenViewSchema = z.object({
+	id: z.string(),
+	artifactId: z.string(),
+	tokenPrefix: z.string(),
+	artifactsTokenId: z.string(),
+	scope: tokenScopeSchema,
+	op: z.string(),
+	tokenOps: z.string(),
+	createdAt: z.number(),
+	expiresAt: z.string(),
+	revokedAt: z.string().nullable()
+});
+const tokenMintOutputSchema = tokenViewSchema.extend({ token: z.string() });
+const tokenListInputSchema = repoScopeSchema.extend({ name: repoNameSchema });
+const tokenListOutputSchema = z.object({ items: z.array(tokenViewSchema) });
+const tokenRevokeOutputSchema = z.object({ revoked: z.boolean() });
+const tokenValidateOutputSchema = z.object({
+	valid: z.boolean(),
+	id: z.string().nullable(),
+	artifactId: z.string().nullable(),
+	tokenPrefix: z.string().nullable(),
+	scope: tokenScopeSchema.nullable(),
+	op: z.string().nullable(),
+	expiresAt: z.string().nullable(),
+	revokedAt: z.string().nullable()
+});
+const tokens = {
+	mint: ocBase.input(tokenMintInputSchema).output(tokenMintOutputSchema),
+	mintForGitRemote: ocBase.input(tokenMintForGitRemoteInputSchema).output(tokenMintOutputSchema),
+	list: ocBase.input(tokenListInputSchema).output(tokenListOutputSchema),
+	revoke: ocBase.input(tokenIdentInputSchema).output(tokenRevokeOutputSchema),
+	validate: ocBase.input(tokenValidateInputSchema).output(tokenValidateOutputSchema)
+};
+//#endregion
+//#region src/anon.ts
+const anonRepoIdentSchema = z.object({ name: repoNameSchema });
+const anonPageInputSchema = anonRepoIdentSchema.extend({
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(100).default(50)
+});
+const anonRefInputSchema = anonRepoIdentSchema.extend({ ref: z.string().min(1) });
+const anonTreeInputSchema = anonRepoIdentSchema.extend({
+	ref: z.string().min(1).default("HEAD"),
+	path: z.string().optional(),
+	recursive: z.boolean().default(true),
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(100).default(50)
+});
+const anonBlobInputSchema = anonRepoIdentSchema.extend({ oid: z.string().min(1) });
+const anonRepoCreateInputSchema = z.object({
+	name: repoNameSchema.optional(),
+	description: z.string().max(512).optional(),
+	defaultBranch: z.string().min(1).max(128).default("main"),
+	ttlSeconds: z.number().int().min(0).max(86400 * 30).optional()
+});
+const anonRepoSchema = repoSchema.extend({
+	expiresAt: z.string(),
+	anonymous: z.literal(true)
+});
+const anonRepoCreateOutputSchema = anonRepoSchema.extend({ anonId: z.string() });
+const anonRepoListInputSchema = z.object({
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(100).default(50)
+});
+const anonRepoListOutputSchema = z.object({
+	items: z.array(anonRepoSchema),
+	nextCursor: z.string().nullable()
+});
+const anonTokenMintForGitRemoteInputSchema = z.object({
+	protocol: z.literal("https"),
+	host: z.string().min(1),
+	path: z.string().min(1),
+	ttlSeconds: z.number().int().positive().optional(),
+	op: z.string().min(1).max(32).optional()
+});
+const signatureSchema = z.object({
+	name: z.string().min(1),
+	email: z.email(),
+	timestamp: z.number().int().optional(),
+	timezoneOffset: z.number().int().optional()
+});
+const workspaceFileSchema = z.object({
+	path: z.string().min(1),
+	content: z.string(),
+	encoding: z.literal("base64").default("base64")
+});
+const anonWorkspaceCommitInputSchema = anonRepoIdentSchema.extend({
+	ref: z.string().min(1).default("refs/heads/main"),
+	message: z.string().min(1),
+	files: z.array(workspaceFileSchema).default([]),
+	removes: z.array(z.string().min(1)).default([]),
+	expectedOid: z.string().min(1).optional(),
+	author: signatureSchema.optional(),
+	committer: signatureSchema.optional()
+}).refine((input) => input.files.length + input.removes.length > 0, {
+	message: "workspace.commit requires at least one file or remove",
+	path: ["files"]
+});
+function pageOf(item) {
+	return z.object({
+		items: z.array(item),
+		nextCursor: z.string().nullable(),
+		hasMore: z.boolean()
+	});
+}
+const anon = {
+	repos: {
+		create: ocBase.input(anonRepoCreateInputSchema).output(anonRepoCreateOutputSchema),
+		get: ocBase.input(anonRepoIdentSchema).output(anonRepoSchema),
+		list: ocBase.input(anonRepoListInputSchema).output(anonRepoListOutputSchema),
+		delete: ocBase.input(anonRepoIdentSchema).output(z.object({ deleted: z.literal(true) }))
+	},
+	tokens: { mintForGitRemote: ocBase.input(anonTokenMintForGitRemoteInputSchema).output(tokenMintOutputSchema) },
+	git: {
+		refs: {
+			list: ocBase.input(anonPageInputSchema).output(pageOf(gitRefSchema)),
+			get: ocBase.input(anonRefInputSchema).output(gitRefSchema)
+		},
+		commits: { list: ocBase.input(anonPageInputSchema.extend({ ref: z.string().optional() })).output(pageOf(gitCommitSchema)) },
+		tree: { get: ocBase.input(anonTreeInputSchema).output(pageOf(gitTreeEntrySchema)) },
+		blob: { get: ocBase.input(anonBlobInputSchema).output(z.union([gitBlobSchema, gitBlobTooLargeSchema])) },
+		workspace: { commit: ocBase.input(anonWorkspaceCommitInputSchema).output(z.object({
+			commit: gitCommitSchema,
+			ref: gitRefSchema
+		})) }
+	}
+};
+//#endregion
+//#region src/health.ts
+const health = { ping: ocBase.input(z.void()).output(z.object({
+	ok: z.literal(true),
+	ts: z.number()
+})) };
+//#endregion
+//#region src/scopes.ts
+const scopeSchema = z.enum([
+	"repos:read",
+	"repos:write",
+	"tokens:read",
+	"tokens:mint",
+	"tokens:revoke",
+	"orgs:read",
+	"orgs:write",
+	"members:read",
+	"members:write",
+	"keys:read",
+	"keys:write",
+	"agents:invoke"
+]);
+//#endregion
+//#region src/keys.ts
+const apiKeyViewSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	prefix: z.string(),
+	scopes: z.array(scopeSchema),
+	enabled: z.boolean(),
+	expiresAt: z.number().int().nullable(),
+	lastUsedAt: z.number().int().nullable(),
+	createdAt: z.number().int()
+});
+const apiKeyCreateInputSchema = z.object({
+	name: z.string().min(1).max(120),
+	scopes: z.array(scopeSchema).min(1),
+	expiresIn: z.number().int().min(86400).optional()
+});
+const apiKeyCreateOutputSchema = z.object({
+	key: apiKeyViewSchema,
+	plaintext: z.string()
+});
+const apiKeyListOutputSchema = z.object({ items: z.array(apiKeyViewSchema) });
+const apiKeyDeleteInputSchema = z.object({ id: z.string().min(1) });
+const apiKeyDeleteOutputSchema = z.object({ deleted: z.literal(true) });
+const keys = {
+	create: ocBase.input(apiKeyCreateInputSchema).output(apiKeyCreateOutputSchema),
+	list: ocBase.output(apiKeyListOutputSchema),
+	delete: ocBase.input(apiKeyDeleteInputSchema).output(apiKeyDeleteOutputSchema)
+};
+//#endregion
+//#region src/members.ts
+const memberRoleSchema = z.enum([
+	"owner",
+	"admin",
+	"member"
+]);
+const mutableMemberRoleSchema = z.enum(["admin", "member"]);
+const memberViewSchema = z.object({
+	id: z.string(),
+	organizationId: z.string(),
+	userId: z.string(),
+	email: z.string().nullable(),
+	name: z.string().nullable(),
+	role: memberRoleSchema,
+	createdAt: z.number()
+});
+const invitationViewSchema = z.object({
+	id: z.string(),
+	organizationId: z.string(),
+	email: z.string(),
+	role: mutableMemberRoleSchema.or(z.literal("owner")),
+	status: z.string(),
+	inviterId: z.string(),
+	expiresAt: z.number()
+});
+const orgInputSchema = z.object({ orgSlug: orgSlugSchema });
+const memberListOutputSchema = z.object({ items: z.array(memberViewSchema) });
+const members = {
+	list: ocBase.input(orgInputSchema).output(memberListOutputSchema),
+	invite: ocBase.input(orgInputSchema.extend({
+		email: z.email(),
+		role: mutableMemberRoleSchema
+	})).output(invitationViewSchema),
+	remove: ocBase.input(orgInputSchema.extend({ userId: z.string().min(1) })).output(z.object({ removed: z.boolean() })),
+	setRole: ocBase.input(orgInputSchema.extend({
+		userId: z.string().min(1),
+		role: mutableMemberRoleSchema
+	})).output(memberViewSchema),
+	acceptInvite: ocBase.input(z.object({ invitationId: z.string().min(1) })).output(z.object({ accepted: z.boolean() })),
+	setActive: ocBase.input(orgInputSchema).output(z.object({ activeOrganizationId: z.string() }))
+};
+//#endregion
+//#region src/me.ts
+const meViewSchema = z.object({
+	userId: z.string(),
+	email: z.string(),
+	name: z.string(),
+	image: z.string().nullable(),
+	activeOrg: z.object({
+		id: z.string(),
+		slug: z.string(),
+		name: z.string(),
+		role: memberRoleSchema
+	}).nullable(),
+	apiKey: z.object({
+		id: z.string(),
+		name: z.string(),
+		prefix: z.string(),
+		scopes: z.array(scopeSchema)
+	}).nullable()
+});
+const me = { get: ocBase.output(meViewSchema) };
+//#endregion
+//#region src/anon-id-store.ts
+const ANON_ID_STORE_VERSION = 1;
+function parseAnonIdFile(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const anonId = typeof parsed.anonId === "string" ? parsed.anonId.trim() : "";
+	if (!anonId) return null;
+	const version = parsed.version;
+	if (version !== void 0 && version !== 1) return null;
+	return {
+		version: 1,
+		anonId
+	};
+}
+function serializeAnonIdRecord(record) {
+	return `${JSON.stringify(record, null, 2)}\n`;
+}
+//#endregion
+//#region src/index.ts
+const contract = {
+	anon,
+	health,
+	git,
+	keys,
+	me,
+	orgs,
+	members,
+	repos,
+	tokens
+};
+//#endregion
+export { ANON_ID_STORE_VERSION, anonRepoSchema, apiKeyViewSchema, commonErrors, compareViewSchema, contract, diffFileSchema, diffViewSchema, gitBlobSchema, gitCommitSchema, gitRefSchema, gitTreeEntrySchema, invitationViewSchema, meViewSchema, memberRoleSchema, memberViewSchema, mutableMemberRoleSchema, orgSlugHint, orgSlugSchema, orgViewSchema, parseAnonIdFile, parseRepoName, repoNameHint, repoNameSchema, repoSchema, scopeSchema, serializeAnonIdRecord, tokenScopeSchema, tokenViewSchema };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@repome/api",
+  "version": "0.1.2",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": "./dist/index.mjs",
+      "./package.json": "./package.json"
+    }
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "typecheck": "tsgo -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@orpc/contract": "catalog:",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "@typescript/native-preview": "catalog:",
+    "vite-plus": "catalog:"
+  }
+}