npm - @eide/foir-cli - Versions diffs - 0.3.0 → 0.3.2 - Mend

@eide/foir-cli 0.3.0 → 0.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/cli.js +2324 -82
package/package.json +3 -3

package/dist/cli.js CHANGED Viewed

@@ -345,12 +345,14 @@ async function loginAction(globalOpts) {
   const port = await findAvailablePort(9876, 9900);
   const redirectUri = `http://localhost:${port}/callback`;
   const authCode = await new Promise((resolve7, reject) => {
+    let timeoutId;
     const server = http.createServer((req, res) => {
       const url = new URL(req.url, `http://localhost:${port}`);
       if (url.pathname === "/callback") {
         const code = url.searchParams.get("code");
         const returnedState = url.searchParams.get("state");
         const error = url.searchParams.get("error");
+        clearTimeout(timeoutId);
         if (error) {
           res.writeHead(400, { "Content-Type": "text/html" });
           res.end(
@@ -372,16 +374,20 @@ async function loginAction(globalOpts) {
         const apiHost = new URL(apiUrl).host;
         const mainHost = apiHost.replace(/^api\./, "");
         const mainUrl = `https://${mainHost}`;
-        res.writeHead(200, { "Content-Type": "text/html" });
+        res.writeHead(200, {
+          "Content-Type": "text/html",
+          "Connection": "close"
+        });
         res.end(
           `<html><head><meta http-equiv="refresh" content="2;url=${mainUrl}"></head><body style="font-family:system-ui;text-align:center;padding:50px"><h1>Authentication successful!</h1><p>You can close this window.</p></body></html>`
         );
+        server.closeAllConnections();
         server.close();
         resolve7(code);
       }
     });
     server.listen(port);
-    setTimeout(
+    timeoutId = setTimeout(
       () => {
         server.close();
         reject(new Error("Authentication timed out after 5 minutes"));
@@ -416,58 +422,2271 @@ async function loginAction(globalOpts) {
     expiresAt: new Date(Date.now() + tokens.expiresIn * 1e3).toISOString(),
     user: tokens.user
   };
-  await writeCredentials(credentials);
-  console.log(`
-\u2713 Logged in as ${tokens.user.email}`);
-  console.log("\nRun `foir select-project` to choose a project.");
+  await writeCredentials(credentials);
+  console.log(`
+\u2713 Logged in as ${tokens.user.email}`);
+  console.log("\nRun `foir select-project` to choose a project.");
+}
+function registerLoginCommand(program2, globalOpts) {
+  program2.command("login").description("Authenticate via browser OAuth").action(
+    withErrorHandler(globalOpts, async () => {
+      await loginAction(globalOpts());
+    })
+  );
+}
+// src/commands/logout.ts
+function registerLogoutCommand(program2, globalOpts) {
+  program2.command("logout").description("Clear stored credentials").action(
+    withErrorHandler(globalOpts, async () => {
+      const credentials = await getCredentials();
+      if (!credentials) {
+        console.log("Not logged in.");
+        return;
+      }
+      await deleteCredentials();
+      console.log(`\u2713 Logged out (was ${credentials.user.email})`);
+    })
+  );
+}
+// src/commands/select-project.ts
+import inquirer from "inquirer";
+// src/lib/client.ts
+import { createClient as createRpcClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-node";
+import { IdentityService as IdentityService2 } from "@eide/foir-proto-ts/identity/v1/identity_pb";
+import { ModelsService as ModelsService2 } from "@eide/foir-proto-ts/models/v1/models_pb";
+import { RecordsService as RecordsService2 } from "@eide/foir-proto-ts/records/v1/records_pb";
+import { ConfigsService as ConfigsService2 } from "@eide/foir-proto-ts/configs/v1/configs_pb";
+import { SegmentsService as SegmentsService2 } from "@eide/foir-proto-ts/segments/v1/segments_pb";
+import { ExperimentsService as ExperimentsService2 } from "@eide/foir-proto-ts/experiments/v1/experiments_pb";
+import { SettingsService as SettingsService2 } from "@eide/foir-proto-ts/settings/v1/settings_pb";
+import { StorageService as StorageService2 } from "@eide/foir-proto-ts/storage/v1/storage_pb";
+// src/lib/rpc/identity.ts
+import { create } from "@bufbuild/protobuf";
+import {
+  LoginRequestSchema,
+  LoginWithOTPRequestSchema,
+  RequestOTPRequestSchema,
+  LogoutRequestSchema,
+  GetMeRequestSchema,
+  GetSessionContextRequestSchema,
+  SwitchTenantRequestSchema,
+  SwitchProjectRequestSchema,
+  ClearSessionContextRequestSchema,
+  RefreshTokenRequestSchema,
+  RegisterRequestSchema,
+  VerifyEmailRequestSchema,
+  ResendVerificationEmailRequestSchema,
+  UpdatePasswordRequestSchema,
+  RequestPasswordResetRequestSchema,
+  ResetPasswordRequestSchema,
+  SendEmailVerificationCodeRequestSchema,
+  VerifyEmailCodeRequestSchema,
+  CreateAdminUserRequestSchema,
+  GetAdminUserRequestSchema,
+  UpdateAdminUserRequestSchema,
+  ListAdminUsersRequestSchema,
+  GrantAccessRequestSchema,
+  RevokeAccessRequestSchema,
+  CreateCustomerRequestSchema,
+  GetCustomerRequestSchema,
+  UpdateCustomerRequestSchema,
+  DeleteCustomerRequestSchema,
+  ListCustomersRequestSchema,
+  SuspendCustomerRequestSchema,
+  CreateTenantRequestSchema,
+  GetTenantRequestSchema,
+  UpdateTenantRequestSchema,
+  ListTenantsRequestSchema,
+  DeleteTenantRequestSchema,
+  CreateProjectRequestSchema,
+  GetProjectRequestSchema,
+  UpdateProjectRequestSchema,
+  ListProjectsRequestSchema,
+  DeleteProjectRequestSchema,
+  GetDefaultProjectRequestSchema,
+  SetDefaultProjectRequestSchema,
+  CreateInvitationRequestSchema,
+  ListInvitationsRequestSchema,
+  RevokeInvitationRequestSchema,
+  AcceptInvitationRequestSchema,
+  ValidateInvitationRequestSchema,
+  CreateApiKeyRequestSchema,
+  GetApiKeyRequestSchema,
+  ListApiKeysRequestSchema,
+  UpdateApiKeyRequestSchema,
+  RotateApiKeyRequestSchema,
+  RevokeApiKeyRequestSchema,
+  MintServiceTokenRequestSchema,
+  ListAuthProvidersRequestSchema,
+  GetAuthProviderRequestSchema,
+  CreateAuthProviderRequestSchema,
+  UpdateAuthProviderRequestSchema,
+  DeleteAuthProviderRequestSchema,
+  EnabledOAuthProvidersRequestSchema,
+  CheckEmailAvailabilityRequestSchema,
+  CompleteAccountSetupRequestSchema,
+  CreateSignupSessionRequestSchema,
+  UpdateMyProfileRequestSchema,
+  ListMyOAuthConnectionsRequestSchema,
+  UnlinkOAuthProviderRequestSchema,
+  ResendInvitationRequestSchema,
+  GetCustomerAuthConfigRequestSchema,
+  VerifyCustomerTokenRequestSchema,
+  GetCustomerManagementStatusRequestSchema
+} from "@eide/foir-proto-ts/identity/v1/identity_pb";
+import {
+  InviteType,
+  AccessRole,
+  CustomerStatus,
+  AdminUserStatus,
+  TenantStatus,
+  ProjectStatus,
+  InvitationStatus
+} from "@eide/foir-proto-ts/identity/v1/identity_pb";
+function createIdentityMethods(client) {
+  return {
+    // ── Auth ──────────────────────────────────────────────
+    async login(email, password, tenantId, projectId) {
+      const resp = await client.login(
+        create(LoginRequestSchema, { email, password, tenantId, projectId })
+      );
+      return {
+        sessionId: resp.sessionId,
+        user: resp.user ?? null
+      };
+    },
+    async loginWithOTP(email, otp, tenantId, projectId) {
+      const resp = await client.loginWithOTP(
+        create(LoginWithOTPRequestSchema, { email, otp, tenantId, projectId })
+      );
+      return {
+        sessionId: resp.sessionId,
+        user: resp.user ?? null
+      };
+    },
+    async requestOTP(email, tenantId, projectId) {
+      const resp = await client.requestOTP(
+        create(RequestOTPRequestSchema, { email, tenantId, projectId })
+      );
+      return { success: resp.success };
+    },
+    async logout() {
+      const resp = await client.logout(create(LogoutRequestSchema, {}));
+      return { success: resp.success };
+    },
+    async register(params) {
+      const resp = await client.register(
+        create(RegisterRequestSchema, {
+          email: params.email,
+          password: params.password,
+          tenantId: params.tenantId,
+          projectId: params.projectId,
+          role: params.role
+        })
+      );
+      return { user: resp.user ?? null };
+    },
+    // ── Email Verification ────────────────────────────────
+    async verifyEmail(token) {
+      const resp = await client.verifyEmail(
+        create(VerifyEmailRequestSchema, { token })
+      );
+      return { success: resp.success };
+    },
+    async resendVerificationEmail() {
+      const resp = await client.resendVerificationEmail(
+        create(ResendVerificationEmailRequestSchema, {})
+      );
+      return { success: resp.success };
+    },
+    async sendEmailVerificationCode(email) {
+      const resp = await client.sendEmailVerificationCode(
+        create(SendEmailVerificationCodeRequestSchema, { email })
+      );
+      return { success: resp.success };
+    },
+    async verifyEmailCode(email, code) {
+      const resp = await client.verifyEmailCode(
+        create(VerifyEmailCodeRequestSchema, { email, code })
+      );
+      return { success: resp.success, verified: resp.verified };
+    },
+    // ── Password ──────────────────────────────────────────
+    async updatePassword(currentPassword, newPassword) {
+      const resp = await client.updatePassword(
+        create(UpdatePasswordRequestSchema, { currentPassword, newPassword })
+      );
+      return { success: resp.success };
+    },
+    async requestPasswordReset(email) {
+      const resp = await client.requestPasswordReset(
+        create(RequestPasswordResetRequestSchema, { email })
+      );
+      return { success: resp.success };
+    },
+    async resetPassword(token, newPassword) {
+      const resp = await client.resetPassword(
+        create(ResetPasswordRequestSchema, { token, newPassword })
+      );
+      return { success: resp.success };
+    },
+    // ── Session Context ───────────────────────────────────
+    async getMe() {
+      const resp = await client.getMe(create(GetMeRequestSchema, {}));
+      return { user: resp.user ?? null };
+    },
+    async getSessionContext() {
+      const resp = await client.getSessionContext(
+        create(GetSessionContextRequestSchema, {})
+      );
+      return resp.context ?? null;
+    },
+    async switchTenant(tenantId) {
+      const resp = await client.switchTenant(
+        create(SwitchTenantRequestSchema, { tenantId })
+      );
+      return resp.context ?? null;
+    },
+    async switchProject(projectId) {
+      const resp = await client.switchProject(
+        create(SwitchProjectRequestSchema, { projectId })
+      );
+      return resp.context ?? null;
+    },
+    async clearSessionContext() {
+      await client.clearSessionContext(
+        create(ClearSessionContextRequestSchema, {})
+      );
+      return { success: true };
+    },
+    async refreshToken(refreshToken) {
+      const resp = await client.refreshToken(
+        create(RefreshTokenRequestSchema, { refreshToken })
+      );
+      return { accessToken: resp.accessToken, refreshToken: resp.refreshToken };
+    },
+    // ── Admin Users ───────────────────────────────────────
+    async createAdminUser(params) {
+      const resp = await client.createAdminUser(
+        create(CreateAdminUserRequestSchema, params)
+      );
+      return { user: resp.user ?? null };
+    },
+    async getAdminUser(id) {
+      const resp = await client.getAdminUser(
+        create(GetAdminUserRequestSchema, { id })
+      );
+      return { user: resp.user ?? null };
+    },
+    async updateAdminUser(params) {
+      const resp = await client.updateAdminUser(
+        create(UpdateAdminUserRequestSchema, params)
+      );
+      return { user: resp.user ?? null };
+    },
+    async listAdminUsers(params = {}) {
+      const resp = await client.listAdminUsers(
+        create(ListAdminUsersRequestSchema, {
+          search: params.search,
+          status: params.status,
+          role: params.role,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async grantAccess(params) {
+      const resp = await client.grantAccess(
+        create(GrantAccessRequestSchema, params)
+      );
+      return { access: resp.access ?? null };
+    },
+    async revokeAccess(accessId) {
+      const resp = await client.revokeAccess(
+        create(RevokeAccessRequestSchema, { accessId })
+      );
+      return { success: resp.success };
+    },
+    // ── Customers ─────────────────────────────────────────
+    async createCustomer(params) {
+      const resp = await client.createCustomer(
+        create(CreateCustomerRequestSchema, {
+          email: params.email,
+          password: params.password
+        })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    async getCustomer(id) {
+      const resp = await client.getCustomer(
+        create(GetCustomerRequestSchema, { id })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    async updateCustomer(params) {
+      const resp = await client.updateCustomer(
+        create(UpdateCustomerRequestSchema, {
+          id: params.id,
+          email: params.email,
+          status: params.status
+        })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    async deleteCustomer(id) {
+      const resp = await client.deleteCustomer(
+        create(DeleteCustomerRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    async listCustomers(params = {}) {
+      const resp = await client.listCustomers(
+        create(ListCustomersRequestSchema, {
+          search: params.search,
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async suspendCustomer(id) {
+      const resp = await client.suspendCustomer(
+        create(SuspendCustomerRequestSchema, { id })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    // ── Tenants ───────────────────────────────────────────
+    async createTenant(params) {
+      const resp = await client.createTenant(
+        create(CreateTenantRequestSchema, { name: params.name })
+      );
+      return { tenant: resp.tenant ?? null };
+    },
+    async getTenant(id) {
+      const resp = await client.getTenant(
+        create(GetTenantRequestSchema, { id })
+      );
+      return { tenant: resp.tenant ?? null };
+    },
+    async updateTenant(params) {
+      const resp = await client.updateTenant(
+        create(UpdateTenantRequestSchema, {
+          id: params.id,
+          name: params.name,
+          status: params.status
+        })
+      );
+      return { tenant: resp.tenant ?? null };
+    },
+    async listTenants(params = {}) {
+      const resp = await client.listTenants(
+        create(ListTenantsRequestSchema, {
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async deleteTenant(id) {
+      const resp = await client.deleteTenant(
+        create(DeleteTenantRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    // ── Projects ──────────────────────────────────────────
+    async createProject(params) {
+      const resp = await client.createProject(
+        create(CreateProjectRequestSchema, {
+          tenantId: params.tenantId,
+          name: params.name,
+          description: params.description
+        })
+      );
+      return { project: resp.project ?? null };
+    },
+    async getProject(id) {
+      const resp = await client.getProject(
+        create(GetProjectRequestSchema, { id })
+      );
+      return { project: resp.project ?? null };
+    },
+    async updateProject(params) {
+      const resp = await client.updateProject(
+        create(UpdateProjectRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description
+        })
+      );
+      return { project: resp.project ?? null };
+    },
+    async listProjects(params) {
+      const resp = await client.listProjects(
+        create(ListProjectsRequestSchema, {
+          tenantId: params.tenantId,
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async deleteProject(id) {
+      const resp = await client.deleteProject(
+        create(DeleteProjectRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    async getDefaultProject(tenantId) {
+      const resp = await client.getDefaultProject(
+        create(GetDefaultProjectRequestSchema, { tenantId })
+      );
+      return { project: resp.project ?? null };
+    },
+    async setDefaultProject(params) {
+      const resp = await client.setDefaultProject(
+        create(SetDefaultProjectRequestSchema, {
+          projectId: params.projectId
+        })
+      );
+      return { project: resp.project ?? null };
+    },
+    // ── Invitations ───────────────────────────────────────
+    async createInvitation(params) {
+      const resp = await client.createInvitation(
+        create(CreateInvitationRequestSchema, {
+          email: params.email,
+          tenantId: params.tenantId,
+          projectIds: params.projectIds ?? [],
+          role: params.role,
+          inviteType: params.inviteType,
+          message: params.message
+        })
+      );
+      return {
+        invitation: resp.invitation ?? null
+      };
+    },
+    async listInvitations(params) {
+      const resp = await client.listInvitations(
+        create(ListInvitationsRequestSchema, {
+          tenantId: params.tenantId,
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async revokeInvitation(invitationId) {
+      const resp = await client.revokeInvitation(
+        create(RevokeInvitationRequestSchema, { invitationId })
+      );
+      return { success: resp.success };
+    },
+    async acceptInvitation(params) {
+      const resp = await client.acceptInvitation(
+        create(AcceptInvitationRequestSchema, {
+          token: params.token,
+          password: params.password
+        })
+      );
+      return {
+        user: resp.user ?? null,
+        sessionId: resp.sessionId
+      };
+    },
+    async validateInvitation(params) {
+      const resp = await client.validateInvitation(
+        create(ValidateInvitationRequestSchema, { token: params.token })
+      );
+      return {
+        invitation: resp.invitation ?? null
+      };
+    },
+    // ── API Keys ──────────────────────────────────────────
+    async createApiKey(params) {
+      const resp = await client.createApiKey(
+        create(CreateApiKeyRequestSchema, {
+          name: params.name,
+          keyType: params.keyType,
+          rateLimitPerHour: params.rateLimitPerHour
+        })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async getApiKey(id) {
+      const resp = await client.getApiKey(
+        create(GetApiKeyRequestSchema, { id })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async listApiKeys(params = {}) {
+      const resp = await client.listApiKeys(
+        create(ListApiKeysRequestSchema, {
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async updateApiKey(params) {
+      const resp = await client.updateApiKey(
+        create(UpdateApiKeyRequestSchema, {
+          id: params.id,
+          name: params.name,
+          isActive: params.isActive,
+          rateLimitPerHour: params.rateLimitPerHour
+        })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async rotateApiKey(id) {
+      const resp = await client.rotateApiKey(
+        create(RotateApiKeyRequestSchema, { id })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async revokeApiKey(id) {
+      const resp = await client.revokeApiKey(
+        create(RevokeApiKeyRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    // ── Service Tokens ──────────────────────────────────────────
+    async mintServiceToken(purpose) {
+      const resp = await client.mintServiceToken(
+        create(MintServiceTokenRequestSchema, { purpose })
+      );
+      return {
+        token: resp.token,
+        purpose: resp.purpose,
+        expiresAt: resp.expiresAt
+      };
+    },
+    // ── Auth Providers ───────────────────────────────────────
+    async listAuthProviders(params = {}) {
+      const resp = await client.listAuthProviders(
+        create(ListAuthProvidersRequestSchema, {
+          enabled: params.enabled,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.providers ?? [],
+        total: resp.total
+      };
+    },
+    async getAuthProvider(id) {
+      const resp = await client.getAuthProvider(
+        create(GetAuthProviderRequestSchema, { id })
+      );
+      return resp.provider ?? null;
+    },
+    async createAuthProvider(params) {
+      const resp = await client.createAuthProvider(
+        create(CreateAuthProviderRequestSchema, {
+          key: params.key,
+          name: params.name,
+          type: params.type,
+          config: params.config,
+          enabled: params.enabled,
+          isDefault: params.isDefault,
+          priority: params.priority
+        })
+      );
+      return resp.provider ?? null;
+    },
+    async updateAuthProvider(params) {
+      const resp = await client.updateAuthProvider(
+        create(UpdateAuthProviderRequestSchema, {
+          id: params.id,
+          name: params.name,
+          config: params.config,
+          enabled: params.enabled,
+          isDefault: params.isDefault,
+          priority: params.priority
+        })
+      );
+      return resp.provider ?? null;
+    },
+    async deleteAuthProvider(id) {
+      const resp = await client.deleteAuthProvider(
+        create(DeleteAuthProviderRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async enabledOAuthProviders() {
+      const resp = await client.enabledOAuthProviders(
+        create(EnabledOAuthProvidersRequestSchema, {})
+      );
+      return resp.providers ?? [];
+    },
+    // ── Signup / Account Setup ───────────────────────────────
+    async checkEmailAvailability(email) {
+      const resp = await client.checkEmailAvailability(
+        create(CheckEmailAvailabilityRequestSchema, { email })
+      );
+      return { available: resp.available };
+    },
+    async completeAccountSetup(params) {
+      const resp = await client.completeAccountSetup(
+        create(CompleteAccountSetupRequestSchema, {
+          firstName: params.firstName,
+          lastName: params.lastName,
+          password: params.password
+        })
+      );
+      return {
+        success: resp.success,
+        redirectUrl: resp.redirectUrl ?? void 0
+      };
+    },
+    async createSignupSession(userId) {
+      const resp = await client.createSignupSession(
+        create(CreateSignupSessionRequestSchema, { userId })
+      );
+      return { success: resp.success };
+    },
+    // ── Profile / OAuth ───────────────────────────────────────
+    async updateMyProfile(params) {
+      const resp = await client.updateMyProfile(
+        create(UpdateMyProfileRequestSchema, {
+          firstName: params.firstName,
+          lastName: params.lastName,
+          avatarUrl: params.avatarUrl
+        })
+      );
+      return resp.user ?? null;
+    },
+    async listMyOAuthConnections() {
+      const resp = await client.listMyOAuthConnections(
+        create(ListMyOAuthConnectionsRequestSchema, {})
+      );
+      return resp.connections ?? [];
+    },
+    async unlinkOAuthProvider(provider) {
+      const resp = await client.unlinkOAuthProvider(
+        create(UnlinkOAuthProviderRequestSchema, { provider })
+      );
+      return resp.success;
+    },
+    // ── Invitations (additional) ─────────────────────────────
+    async resendInvitation(invitationId) {
+      const resp = await client.resendInvitation(
+        create(ResendInvitationRequestSchema, { invitationId })
+      );
+      return resp.success;
+    },
+    // ── Customer Auth ────────────────────────────────────────
+    async getCustomerAuthConfig() {
+      const resp = await client.getCustomerAuthConfig(
+        create(GetCustomerAuthConfigRequestSchema, {})
+      );
+      return resp.config ?? null;
+    },
+    async verifyCustomerToken(token) {
+      const resp = await client.verifyCustomerToken(
+        create(VerifyCustomerTokenRequestSchema, { token })
+      );
+      return resp;
+    },
+    async getCustomerManagementStatus() {
+      const resp = await client.getCustomerManagementStatus(
+        create(GetCustomerManagementStatusRequestSchema, {})
+      );
+      return resp.status ?? null;
+    }
+  };
+}
+// src/lib/rpc/models.ts
+import { create as create2 } from "@bufbuild/protobuf";
+import {
+  FieldSchema as ProtoFieldSchema,
+  SharingConfigSchema as ProtoSharingConfigSchema,
+  ModelConfigSchema as ProtoModelConfigSchema,
+  CreateModelRequestSchema,
+  GetModelRequestSchema,
+  GetModelByKeyRequestSchema,
+  ListModelsRequestSchema,
+  UpdateModelRequestSchema,
+  DeleteModelRequestSchema,
+  DuplicateModelRequestSchema,
+  ListModelVersionsRequestSchema,
+  RestoreModelVersionRequestSchema
+} from "@eide/foir-proto-ts/models/v1/models_pb";
+function jsFieldToProto(f) {
+  return create2(ProtoFieldSchema, {
+    id: f.id,
+    key: f.key,
+    label: f.label,
+    type: f.type,
+    required: f.required,
+    helpText: f.helpText,
+    placeholder: f.placeholder,
+    config: f.config && Object.keys(f.config).length > 0 ? f.config : void 0,
+    itemType: f.itemType,
+    storage: f.storage,
+    templateZone: f.templateZone,
+    zoneOrder: f.zoneOrder
+  });
+}
+function jsConfigToProto(c) {
+  return create2(ProtoModelConfigSchema, {
+    versioning: c.versioning ?? false,
+    publishing: c.publishing ?? false,
+    variants: c.variants ?? false,
+    inline: c.inline ?? false,
+    customerScoped: c.customerScoped ?? false,
+    sharing: c.sharing ? create2(ProtoSharingConfigSchema, {
+      enabled: c.sharing.enabled,
+      requireAcceptance: c.sharing.requireAcceptance
+    }) : void 0,
+    pluralName: c.pluralName,
+    description: c.description,
+    category: c.category,
+    icon: c.icon,
+    displayField: c.displayField,
+    naturalKeyField: c.naturalKeyField,
+    systemEntity: c.systemEntity ?? false,
+    deletable: c.deletable,
+    editable: c.editable
+  });
+}
+function createModelsMethods(client) {
+  return {
+    // ── Queries ──────────────────────────────────────────────
+    async getModel(id) {
+      const resp = await client.getModel(create2(GetModelRequestSchema, { id }));
+      return resp.model ?? null;
+    },
+    async getModelByKey(key) {
+      const resp = await client.getModelByKey(
+        create2(GetModelByKeyRequestSchema, { key })
+      );
+      return resp.model ?? null;
+    },
+    async listModels(params = {}) {
+      const resp = await client.listModels(
+        create2(ListModelsRequestSchema, {
+          search: params.search,
+          category: params.category,
+          configId: params.configId,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.models ?? [],
+        total: resp.total
+      };
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createModel(params) {
+      const resp = await client.createModel(
+        create2(CreateModelRequestSchema, {
+          key: params.key,
+          name: params.name,
+          fields: params.fields.map(jsFieldToProto),
+          config: params.config ? jsConfigToProto(params.config) : void 0,
+          configId: params.configId
+        })
+      );
+      return resp.model ?? null;
+    },
+    async updateModel(params) {
+      const resp = await client.updateModel(
+        create2(UpdateModelRequestSchema, {
+          id: params.id,
+          name: params.name,
+          updateFields: params.fields != null,
+          fields: params.fields?.map(jsFieldToProto) ?? [],
+          config: params.config ? jsConfigToProto(params.config) : void 0,
+          changeDescription: params.changeDescription
+        })
+      );
+      return resp.model ?? null;
+    },
+    async deleteModel(id) {
+      const resp = await client.deleteModel(
+        create2(DeleteModelRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async duplicateModel(params) {
+      const resp = await client.duplicateModel(
+        create2(DuplicateModelRequestSchema, params)
+      );
+      return resp.model ?? null;
+    },
+    // ── Versioning ───────────────────────────────────────────
+    async listModelVersions(modelId, params = {}) {
+      const resp = await client.listModelVersions(
+        create2(ListModelVersionsRequestSchema, {
+          modelId,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    async restoreModelVersion(modelId, versionId) {
+      const resp = await client.restoreModelVersion(
+        create2(RestoreModelVersionRequestSchema, { modelId, versionId })
+      );
+      return resp.model ?? null;
+    }
+  };
+}
+// src/lib/rpc/records.ts
+import { create as create3 } from "@bufbuild/protobuf";
+import {
+  CreateRecordRequestSchema,
+  GetRecordRequestSchema,
+  GetRecordByKeyRequestSchema,
+  GetRecordByKeyOrIdRequestSchema,
+  ListRecordsRequestSchema,
+  UpdateRecordRequestSchema,
+  DeleteRecordRequestSchema,
+  DuplicateRecordRequestSchema,
+  DuplicateRecordsBulkRequestSchema,
+  BatchRecordOperationsRequestSchema,
+  BatchOperationSchema,
+  RecordFilterSchema,
+  BulkUpdateRecordsRequestSchema,
+  CreateVersionRequestSchema,
+  PublishVersionRequestSchema,
+  UnpublishRecordRequestSchema,
+  RevertToVersionRequestSchema,
+  ListRecordVersionsRequestSchema,
+  SaveContentRequestSchema,
+  CreateVariantRequestSchema,
+  UpdateVariantRequestSchema,
+  DeleteVariantRequestSchema,
+  SetDefaultVariantRequestSchema,
+  ListRecordVariantsRequestSchema,
+  ScheduleRecordPublishRequestSchema,
+  CancelScheduledRecordPublishRequestSchema,
+  ListScheduledPublishesRequestSchema,
+  ListDraftVersionsRequestSchema,
+  BatchPublishVersionsRequestSchema,
+  CreatePublishBatchRequestSchema,
+  UpdatePublishBatchRequestSchema,
+  CancelPublishBatchRequestSchema,
+  RollbackPublishBatchRequestSchema,
+  RetryFailedBatchItemsRequestSchema,
+  AddItemsToPublishBatchRequestSchema,
+  RemoveItemsFromPublishBatchRequestSchema,
+  ListPublishBatchesRequestSchema,
+  GetPublishBatchRequestSchema,
+  GlobalSearchRequestSchema,
+  GetEmbeddingStatsRequestSchema,
+  GetRecordEmbeddingsRequestSchema,
+  FindSimilarRecordsRequestSchema
+} from "@eide/foir-proto-ts/records/v1/records_pb";
+import { RecordType, BatchStatus } from "@eide/foir-proto-ts/records/v1/records_pb";
+function sanitizeData(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = sanitizeData(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => {
+        if (item === void 0) return null;
+        if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+          return sanitizeData(item);
+        }
+        return item;
+      });
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function createRecordsMethods(client) {
+  return {
+    // ── CRUD ──────────────────────────────────────────────────
+    async createRecord(params) {
+      const resp = await client.createRecord(
+        create3(CreateRecordRequestSchema, {
+          modelKey: params.modelKey,
+          naturalKey: params.naturalKey,
+          data: params.data ? sanitizeData(params.data) : void 0,
+          customerId: params.customerId,
+          metadata: params.metadata ? sanitizeData(params.metadata) : void 0,
+          changeDescription: params.changeDescription
+        })
+      );
+      return {
+        record: resp.record ?? null,
+        variant: resp.variant ?? null,
+        version: resp.version ?? null
+      };
+    },
+    async getRecord(id) {
+      const resp = await client.getRecord(
+        create3(GetRecordRequestSchema, { id })
+      );
+      return resp.record ?? null;
+    },
+    async getRecordByKey(modelKey, naturalKey) {
+      const resp = await client.getRecordByKey(
+        create3(GetRecordByKeyRequestSchema, { modelKey, naturalKey })
+      );
+      return resp.record ?? null;
+    },
+    async getRecordByKeyOrId(modelKey, identifier) {
+      const resp = await client.getRecordByKeyOrId(
+        create3(GetRecordByKeyOrIdRequestSchema, { modelKey, identifier })
+      );
+      return resp.record ?? null;
+    },
+    async listRecords(params) {
+      const resp = await client.listRecords(
+        create3(ListRecordsRequestSchema, {
+          modelKey: params.modelKey,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0,
+          customerId: params.customerId,
+          search: params.search,
+          filters: params.filters?.map(
+            (f) => create3(RecordFilterSchema, {
+              field: f.field,
+              operator: f.operator
+            })
+          )
+        })
+      );
+      return {
+        items: resp.records ?? [],
+        total: resp.total
+      };
+    },
+    async updateRecord(params) {
+      const resp = await client.updateRecord(
+        create3(UpdateRecordRequestSchema, {
+          id: params.id,
+          data: sanitizeData(params.data),
+          naturalKey: params.naturalKey
+        })
+      );
+      return resp.record ?? null;
+    },
+    async deleteRecord(id) {
+      const resp = await client.deleteRecord(
+        create3(DeleteRecordRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async duplicateRecord(id, newNaturalKey) {
+      const resp = await client.duplicateRecord(
+        create3(DuplicateRecordRequestSchema, { id, newNaturalKey })
+      );
+      return resp.record ?? null;
+    },
+    async duplicateRecordsBulk(ids, modelKey) {
+      const resp = await client.duplicateRecordsBulk(
+        create3(DuplicateRecordsBulkRequestSchema, { ids, modelKey })
+      );
+      return resp.records ?? [];
+    },
+    async batchRecordOperations(operations) {
+      const typeMap = { create: 1, update: 2, delete: 3 };
+      const resp = await client.batchRecordOperations(
+        create3(BatchRecordOperationsRequestSchema, {
+          operations: operations.map(
+            (op) => create3(BatchOperationSchema, {
+              type: typeMap[op.type],
+              id: op.id,
+              modelKey: op.modelKey,
+              naturalKey: op.naturalKey,
+              data: op.data ? sanitizeData(
+                op.data
+              ) : void 0,
+              customerId: op.customerId
+            })
+          )
+        })
+      );
+      return resp.results ?? [];
+    },
+    async bulkUpdateRecords(params) {
+      const resp = await client.bulkUpdateRecords(
+        create3(BulkUpdateRecordsRequestSchema, {
+          modelKey: params.modelKey,
+          data: sanitizeData(params.data)
+        })
+      );
+      return { count: resp.count };
+    },
+    // ── Versioning ────────────────────────────────────────────
+    async createVersion(parentId, data, changeDescription) {
+      const resp = await client.createVersion(
+        create3(CreateVersionRequestSchema, {
+          parentId,
+          data: data ? sanitizeData(data) : void 0,
+          changeDescription
+        })
+      );
+      return resp.version ?? null;
+    },
+    async publishVersion(versionId) {
+      const resp = await client.publishVersion(
+        create3(PublishVersionRequestSchema, { versionId })
+      );
+      return resp.record ?? null;
+    },
+    async unpublishRecord(recordId) {
+      const resp = await client.unpublishRecord(
+        create3(UnpublishRecordRequestSchema, { recordId })
+      );
+      return resp.success;
+    },
+    async revertToVersion(versionId) {
+      const resp = await client.revertToVersion(
+        create3(RevertToVersionRequestSchema, { versionId })
+      );
+      return resp.record ?? null;
+    },
+    async listRecordVersions(parentId, params) {
+      const resp = await client.listRecordVersions(
+        create3(ListRecordVersionsRequestSchema, {
+          parentId,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    async saveContent(params) {
+      const resp = await client.saveContent(
+        create3(SaveContentRequestSchema, {
+          recordId: params.recordId,
+          data: sanitizeData(params.data),
+          variantKey: params.variantKey,
+          changeDescription: params.changeDescription
+        })
+      );
+      return {
+        record: resp.record ?? null,
+        version: resp.version ?? null
+      };
+    },
+    // ── Variants ──────────────────────────────────────────────
+    async createVariant(recordId, variantKey, data) {
+      const resp = await client.createVariant(
+        create3(CreateVariantRequestSchema, {
+          recordId,
+          variantKey,
+          data: data ? sanitizeData(data) : void 0
+        })
+      );
+      return resp.variant ?? null;
+    },
+    async updateVariant(variantId, data) {
+      const resp = await client.updateVariant(
+        create3(UpdateVariantRequestSchema, {
+          variantId,
+          data: sanitizeData(data)
+        })
+      );
+      return resp.variant ?? null;
+    },
+    async deleteVariant(variantId) {
+      const resp = await client.deleteVariant(
+        create3(DeleteVariantRequestSchema, { variantId })
+      );
+      return resp.success;
+    },
+    async setDefaultVariant(recordId, variantId) {
+      const resp = await client.setDefaultVariant(
+        create3(SetDefaultVariantRequestSchema, { recordId, variantId })
+      );
+      return resp.record ?? null;
+    },
+    async listRecordVariants(recordId, params) {
+      const resp = await client.listRecordVariants(
+        create3(ListRecordVariantsRequestSchema, {
+          recordId,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.variants ?? [],
+        total: resp.total
+      };
+    },
+    // ── Scheduling ────────────────────────────────────────────
+    async scheduleRecordPublish(versionId, publishAt, unpublishAt) {
+      const resp = await client.scheduleRecordPublish(
+        create3(ScheduleRecordPublishRequestSchema, {
+          versionId,
+          publishAt: {
+            seconds: BigInt(Math.floor(publishAt.getTime() / 1e3)),
+            nanos: 0
+          },
+          unpublishAt: unpublishAt ? {
+            seconds: BigInt(Math.floor(unpublishAt.getTime() / 1e3)),
+            nanos: 0
+          } : void 0
+        })
+      );
+      return resp.version ?? null;
+    },
+    async cancelScheduledRecordPublish(versionId) {
+      const resp = await client.cancelScheduledRecordPublish(
+        create3(CancelScheduledRecordPublishRequestSchema, { versionId })
+      );
+      return resp.version ?? null;
+    },
+    async listScheduledPublishes(params) {
+      const resp = await client.listScheduledPublishes(
+        create3(ListScheduledPublishesRequestSchema, {
+          from: params?.from ? {
+            seconds: BigInt(Math.floor(params.from.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          to: params?.to ? {
+            seconds: BigInt(Math.floor(params.to.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          modelKey: params?.modelKey,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    async listDraftVersions(params) {
+      const resp = await client.listDraftVersions(
+        create3(ListDraftVersionsRequestSchema, {
+          modelKey: params?.modelKey,
+          search: params?.search,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    // ── Batch Publishing ──────────────────────────────────────
+    async batchPublishVersions(versionIds) {
+      const resp = await client.batchPublishVersions(
+        create3(BatchPublishVersionsRequestSchema, { versionIds })
+      );
+      return {
+        records: resp.records ?? [],
+        publishedCount: resp.publishedCount
+      };
+    },
+    // ── Publish Batches ───────────────────────────────────────
+    async createPublishBatch(params) {
+      const resp = await client.createPublishBatch(
+        create3(CreatePublishBatchRequestSchema, {
+          name: params.name,
+          versionIds: params.versionIds,
+          scheduledAt: params.scheduledAt ? {
+            seconds: BigInt(
+              Math.floor(params.scheduledAt.getTime() / 1e3)
+            ),
+            nanos: 0
+          } : void 0
+        })
+      );
+      return resp.batch ?? null;
+    },
+    async updatePublishBatch(params) {
+      const resp = await client.updatePublishBatch(
+        create3(UpdatePublishBatchRequestSchema, {
+          batchId: params.batchId,
+          name: params.name,
+          scheduledAt: params.scheduledAt ? {
+            seconds: BigInt(
+              Math.floor(params.scheduledAt.getTime() / 1e3)
+            ),
+            nanos: 0
+          } : void 0
+        })
+      );
+      return resp.batch ?? null;
+    },
+    async cancelPublishBatch(batchId) {
+      const resp = await client.cancelPublishBatch(
+        create3(CancelPublishBatchRequestSchema, { batchId })
+      );
+      return resp.batch ?? null;
+    },
+    async rollbackPublishBatch(batchId) {
+      const resp = await client.rollbackPublishBatch(
+        create3(RollbackPublishBatchRequestSchema, { batchId })
+      );
+      return resp.batch ?? null;
+    },
+    async retryFailedBatchItems(batchId) {
+      const resp = await client.retryFailedBatchItems(
+        create3(RetryFailedBatchItemsRequestSchema, { batchId })
+      );
+      return {
+        batch: resp.batch ?? null,
+        retriedCount: resp.retriedCount
+      };
+    },
+    async addItemsToPublishBatch(batchId, versionIds) {
+      const resp = await client.addItemsToPublishBatch(
+        create3(AddItemsToPublishBatchRequestSchema, { batchId, versionIds })
+      );
+      return resp.batch ?? null;
+    },
+    async removeItemsFromPublishBatch(batchId, versionIds) {
+      const resp = await client.removeItemsFromPublishBatch(
+        create3(RemoveItemsFromPublishBatchRequestSchema, {
+          batchId,
+          versionIds
+        })
+      );
+      return resp.batch ?? null;
+    },
+    async listPublishBatches(params) {
+      const resp = await client.listPublishBatches(
+        create3(ListPublishBatchesRequestSchema, {
+          status: params?.status,
+          from: params?.from ? {
+            seconds: BigInt(Math.floor(params.from.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          to: params?.to ? {
+            seconds: BigInt(Math.floor(params.to.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.batches ?? [],
+        total: resp.total
+      };
+    },
+    async getPublishBatch(batchId) {
+      const resp = await client.getPublishBatch(
+        create3(GetPublishBatchRequestSchema, { batchId })
+      );
+      return {
+        batch: resp.batch ?? null,
+        versions: resp.versions ?? []
+      };
+    },
+    // ── Search & Embeddings ──────────────────────────────────
+    async globalSearch(params) {
+      const resp = await client.globalSearch(
+        create3(GlobalSearchRequestSchema, {
+          query: params.query,
+          modelKeys: params.modelKeys ?? [],
+          limit: params.limit ?? 20
+        })
+      );
+      return {
+        items: resp.records ?? [],
+        total: resp.total
+      };
+    },
+    async getEmbeddingStats(modelKey) {
+      const resp = await client.getEmbeddingStats(
+        create3(GetEmbeddingStatsRequestSchema, {
+          modelKey
+        })
+      );
+      return resp.stats ?? [];
+    },
+    async getRecordEmbeddings(recordId) {
+      const resp = await client.getRecordEmbeddings(
+        create3(GetRecordEmbeddingsRequestSchema, { recordId })
+      );
+      return resp.embeddings ?? [];
+    },
+    async findSimilarRecords(params) {
+      const resp = await client.findSimilarRecords(
+        create3(FindSimilarRecordsRequestSchema, {
+          recordId: params.recordId,
+          modelKey: params.modelKey,
+          limit: params.limit ?? 10
+        })
+      );
+      return resp.records ?? [];
+    }
+  };
+}
+// src/lib/rpc/configs.ts
+import { create as create4 } from "@bufbuild/protobuf";
+import {
+  CreateConfigRequestSchema,
+  GetConfigRequestSchema,
+  GetConfigByKeyRequestSchema,
+  ListConfigsRequestSchema,
+  UpdateConfigRequestSchema,
+  DeleteConfigRequestSchema,
+  ConfigDirection,
+  ListOperationsRequestSchema,
+  ApplyConfigRequestSchema
+} from "@eide/foir-proto-ts/configs/v1/configs_pb";
+import { ConfigDirection as ConfigDirection2 } from "@eide/foir-proto-ts/configs/v1/configs_pb";
+var DIRECTION_TO_PROTO = {
+  read: ConfigDirection.READ,
+  write: ConfigDirection.WRITE,
+  bidirectional: ConfigDirection.BIDIRECTIONAL
+};
+function createConfigsMethods(client) {
+  return {
+    // ── Operations ────────────────────────────────────────────
+    async listOperations(params = {}) {
+      return client.listOperations(
+        create4(ListOperationsRequestSchema, {
+          category: params.category,
+          isActive: params.isActive,
+          search: params.search,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Queries ──────────────────────────────────────────────
+    async getConfig(id) {
+      const resp = await client.getConfig(
+        create4(GetConfigRequestSchema, { id })
+      );
+      return resp.config ?? null;
+    },
+    async getConfigByKey(key) {
+      const resp = await client.getConfigByKey(
+        create4(GetConfigByKeyRequestSchema, { key })
+      );
+      return resp.config ?? null;
+    },
+    async listConfigs(params = {}) {
+      return client.listConfigs(
+        create4(ListConfigsRequestSchema, {
+          configType: params.configType,
+          enabled: params.enabled,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createConfig(params) {
+      const resp = await client.createConfig(
+        create4(CreateConfigRequestSchema, {
+          key: params.key,
+          configType: params.configType,
+          direction: DIRECTION_TO_PROTO[params.direction ?? "read"] ?? ConfigDirection.READ,
+          name: params.name,
+          description: params.description,
+          config: params.config,
+          enabled: params.enabled
+        })
+      );
+      return resp.config ?? null;
+    },
+    async updateConfig(params) {
+      const resp = await client.updateConfig(
+        create4(UpdateConfigRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          config: params.config,
+          enabled: params.enabled,
+          webhooks: params.webhooks,
+          hooks: params.hooks
+        })
+      );
+      return resp.config ?? null;
+    },
+    async applyConfig(configKey, configData) {
+      const resp = await client.applyConfig(
+        create4(ApplyConfigRequestSchema, {
+          configKey,
+          configData
+        })
+      );
+      return resp.config ?? null;
+    },
+    async deleteConfig(id) {
+      const resp = await client.deleteConfig(
+        create4(DeleteConfigRequestSchema, { id })
+      );
+      return resp.success;
+    }
+  };
+}
+// src/lib/rpc/segments.ts
+import { create as create5 } from "@bufbuild/protobuf";
+import {
+  CreateSegmentRequestSchema,
+  GetSegmentRequestSchema,
+  GetSegmentByKeyRequestSchema,
+  ListSegmentsRequestSchema,
+  UpdateSegmentRequestSchema,
+  DeleteSegmentRequestSchema,
+  GetCustomerMembershipsRequestSchema,
+  PreviewSegmentRulesRequestSchema,
+  TestSegmentEvaluationRequestSchema,
+  SetGlobalOptOutRequestSchema,
+  OptOutOfSegmentRequestSchema,
+  OptBackIntoSegmentRequestSchema
+} from "@eide/foir-proto-ts/segments/v1/segments_pb";
+function createSegmentsMethods(client) {
+  return {
+    // ── Queries ──────────────────────────────────────────────
+    async getSegment(id) {
+      const resp = await client.getSegment(
+        create5(GetSegmentRequestSchema, { id })
+      );
+      return resp.segment ?? null;
+    },
+    async getSegmentByKey(key) {
+      const resp = await client.getSegmentByKey(
+        create5(GetSegmentByKeyRequestSchema, { key })
+      );
+      return resp.segment ?? null;
+    },
+    async listSegments(params = {}) {
+      return client.listSegments(
+        create5(ListSegmentsRequestSchema, {
+          isActive: params.isActive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createSegment(params) {
+      const resp = await client.createSegment(
+        create5(CreateSegmentRequestSchema, {
+          key: params.key,
+          name: params.name,
+          description: params.description,
+          rules: params.rules,
+          evaluationMode: params.evaluationMode,
+          isActive: params.isActive
+        })
+      );
+      return resp.segment ?? null;
+    },
+    async updateSegment(params) {
+      const resp = await client.updateSegment(
+        create5(UpdateSegmentRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          rules: params.rules,
+          evaluationMode: params.evaluationMode,
+          isActive: params.isActive
+        })
+      );
+      return resp.segment ?? null;
+    },
+    async deleteSegment(id) {
+      const resp = await client.deleteSegment(
+        create5(DeleteSegmentRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Customer Operations ──────────────────────────────────
+    async getCustomerMemberships(customerId) {
+      return client.getCustomerMemberships(
+        create5(GetCustomerMembershipsRequestSchema, { customerId })
+      );
+    },
+    async previewSegmentRules(rules, sampleSize) {
+      const resp = await client.previewSegmentRules(
+        create5(PreviewSegmentRulesRequestSchema, {
+          rules,
+          sampleSize: sampleSize ?? 10
+        })
+      );
+      return resp.preview ?? null;
+    },
+    async testSegmentEvaluation(segmentId, customerId) {
+      const resp = await client.testSegmentEvaluation(
+        create5(TestSegmentEvaluationRequestSchema, { segmentId, customerId })
+      );
+      return resp.result ?? null;
+    },
+    // ── Opt-out Management ───────────────────────────────────
+    async setGlobalOptOut(customerId, optedOut) {
+      const resp = await client.setGlobalOptOut(
+        create5(SetGlobalOptOutRequestSchema, { customerId, optedOut })
+      );
+      return resp.success;
+    },
+    async optOutOfSegment(customerId, segmentId) {
+      const resp = await client.optOutOfSegment(
+        create5(OptOutOfSegmentRequestSchema, { customerId, segmentId })
+      );
+      return resp.success;
+    },
+    async optBackIntoSegment(customerId, segmentId) {
+      const resp = await client.optBackIntoSegment(
+        create5(OptBackIntoSegmentRequestSchema, { customerId, segmentId })
+      );
+      return resp.success;
+    }
+  };
 }
-function registerLoginCommand(program2, globalOpts) {
-  program2.command("login").description("Authenticate via browser OAuth").action(
-    withErrorHandler(globalOpts, async () => {
-      await loginAction(globalOpts());
-    })
-  );
+// src/lib/rpc/experiments.ts
+import { create as create6 } from "@bufbuild/protobuf";
+import {
+  ExperimentStatus,
+  CreateExperimentRequestSchema,
+  GetExperimentRequestSchema,
+  GetExperimentByKeyRequestSchema,
+  ListExperimentsRequestSchema,
+  UpdateExperimentRequestSchema,
+  DeleteExperimentRequestSchema,
+  StartExperimentRequestSchema,
+  PauseExperimentRequestSchema,
+  ResumeExperimentRequestSchema,
+  EndExperimentRequestSchema,
+  GetExperimentStatsRequestSchema,
+  ForceAssignExperimentRequestSchema,
+  RemoveExperimentAssignmentRequestSchema,
+  ApplyExperimentWinnerRequestSchema,
+  GetCustomerAssignmentsRequestSchema,
+  ExperimentVariantSchema
+} from "@eide/foir-proto-ts/experiments/v1/experiments_pb";
+import { ExperimentStatus as ExperimentStatus2 } from "@eide/foir-proto-ts/experiments/v1/experiments_pb";
+var STATUS_TO_PROTO = {
+  draft: ExperimentStatus.DRAFT,
+  running: ExperimentStatus.RUNNING,
+  paused: ExperimentStatus.PAUSED,
+  ended: ExperimentStatus.COMPLETED,
+  completed: ExperimentStatus.COMPLETED
+};
+function createExperimentsMethods(client) {
+  return {
+    // ── Queries ──────────────────────────────────────────────
+    async getExperiment(id) {
+      const resp = await client.getExperiment(
+        create6(GetExperimentRequestSchema, { id })
+      );
+      return resp.experiment ?? null;
+    },
+    async getExperimentByKey(key) {
+      const resp = await client.getExperimentByKey(
+        create6(GetExperimentByKeyRequestSchema, { key })
+      );
+      return resp.experiment ?? null;
+    },
+    async listExperiments(params = {}) {
+      return client.listExperiments(
+        create6(ListExperimentsRequestSchema, {
+          status: params.status ? STATUS_TO_PROTO[params.status] : void 0,
+          isActive: params.isActive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getExperimentStats(experimentId) {
+      const resp = await client.getExperimentStats(
+        create6(GetExperimentStatsRequestSchema, { experimentId })
+      );
+      return resp.stats ?? null;
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createExperiment(params) {
+      const resp = await client.createExperiment(
+        create6(CreateExperimentRequestSchema, {
+          key: params.key,
+          name: params.name,
+          description: params.description,
+          targeting: params.targeting,
+          controlPercent: params.controlPercent,
+          variants: params.variants?.map(
+            (v) => create6(ExperimentVariantSchema, {
+              key: v.key,
+              name: v.name,
+              percent: v.percent
+            })
+          ) ?? []
+        })
+      );
+      return resp.experiment ?? null;
+    },
+    async updateExperiment(params) {
+      const resp = await client.updateExperiment(
+        create6(UpdateExperimentRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          targeting: params.targeting,
+          controlPercent: params.controlPercent,
+          variants: params.variants?.map(
+            (v) => create6(ExperimentVariantSchema, {
+              key: v.key,
+              name: v.name,
+              percent: v.percent
+            })
+          )
+        })
+      );
+      return resp.experiment ?? null;
+    },
+    async deleteExperiment(id) {
+      const resp = await client.deleteExperiment(
+        create6(DeleteExperimentRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Lifecycle ────────────────────────────────────────────
+    async startExperiment(experimentId) {
+      const resp = await client.startExperiment(
+        create6(StartExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async pauseExperiment(experimentId) {
+      const resp = await client.pauseExperiment(
+        create6(PauseExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async resumeExperiment(experimentId) {
+      const resp = await client.resumeExperiment(
+        create6(ResumeExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async endExperiment(experimentId) {
+      const resp = await client.endExperiment(
+        create6(EndExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async applyExperimentWinner(experimentId, winnerVariantKey) {
+      const resp = await client.applyExperimentWinner(
+        create6(ApplyExperimentWinnerRequestSchema, {
+          experimentId,
+          winnerVariantKey
+        })
+      );
+      return resp.experiment ?? null;
+    },
+    // ── Assignments ──────────────────────────────────────────
+    async forceAssignExperiment(customerId, experimentId, variantKey) {
+      const resp = await client.forceAssignExperiment(
+        create6(ForceAssignExperimentRequestSchema, {
+          customerId,
+          experimentId,
+          variantKey
+        })
+      );
+      return resp.assignment ?? null;
+    },
+    async removeExperimentAssignment(customerId, experimentId) {
+      const resp = await client.removeExperimentAssignment(
+        create6(RemoveExperimentAssignmentRequestSchema, {
+          customerId,
+          experimentId
+        })
+      );
+      return resp.success;
+    },
+    async getCustomerAssignments(customerId) {
+      const resp = await client.getCustomerAssignments(
+        create6(GetCustomerAssignmentsRequestSchema, { customerId })
+      );
+      return resp.assignments ?? [];
+    }
+  };
 }
-// src/commands/logout.ts
-function registerLogoutCommand(program2, globalOpts) {
-  program2.command("logout").description("Clear stored credentials").action(
-    withErrorHandler(globalOpts, async () => {
-      const credentials = await getCredentials();
-      if (!credentials) {
-        console.log("Not logged in.");
-        return;
-      }
-      await deleteCredentials();
-      console.log(`\u2713 Logged out (was ${credentials.user.email})`);
-    })
-  );
+// src/lib/rpc/settings.ts
+import { create as create7 } from "@bufbuild/protobuf";
+import {
+  GetSettingsRequestSchema,
+  UpdateSettingRequestSchema,
+  ListContextDimensionsRequestSchema,
+  GetContextDimensionRequestSchema,
+  CreateContextDimensionRequestSchema,
+  UpdateContextDimensionRequestSchema,
+  DeleteContextDimensionRequestSchema,
+  GetContextDimensionValuesRequestSchema,
+  GetCustomerProfileSchemaRequestSchema,
+  GetCustomerProfileRequestSchema,
+  SetCustomerProfileRequestSchema,
+  UpdateCustomerProfileSchemaRequestSchema,
+  GetCustomerResolutionAttributesRequestSchema,
+  GetEditorConfigsRequestSchema,
+  ListEmailActionsRequestSchema,
+  ListResendTemplatesRequestSchema,
+  UpdateEmailActionRequestSchema,
+  ListVariantCatalogRequestSchema,
+  GetVariantCatalogEntryRequestSchema,
+  CreateVariantCatalogEntryRequestSchema,
+  UpdateVariantCatalogEntryRequestSchema,
+  DeleteVariantCatalogEntryRequestSchema,
+  CreateNoteRequestSchema,
+  GetNoteRequestSchema,
+  ListNotesRequestSchema,
+  UpdateNoteRequestSchema,
+  DeleteNoteRequestSchema,
+  ListMyMentionsRequestSchema,
+  UpdateMentionStatusRequestSchema,
+  ListLocalesRequestSchema,
+  GetLocaleRequestSchema,
+  CreateLocaleRequestSchema,
+  UpdateLocaleRequestSchema,
+  DeleteLocaleRequestSchema,
+  GetNavPreferencesRequestSchema,
+  UpdateNavPreferencesRequestSchema,
+  ListRecentlyOpenedRequestSchema,
+  TrackRecentlyOpenedRequestSchema,
+  RemoveRecentlyOpenedRequestSchema,
+  ClearRecentlyOpenedRequestSchema
+} from "@eide/foir-proto-ts/settings/v1/settings_pb";
+function createSettingsMethods(client) {
+  return {
+    // ── Settings ─────────────────────────────────────────────
+    async getSettings(params = {}) {
+      const resp = await client.getSettings(
+        create7(GetSettingsRequestSchema, {
+          category: params.category,
+          key: params.key
+        })
+      );
+      return resp.settings ?? [];
+    },
+    async updateSetting(params) {
+      const resp = await client.updateSetting(
+        create7(UpdateSettingRequestSchema, {
+          key: params.key,
+          value: params.value
+        })
+      );
+      return resp.setting ?? null;
+    },
+    // ── Mentions ─────────────────────────────────────────────
+    async listMyMentions(params = {}) {
+      return client.listMyMentions(
+        create7(ListMyMentionsRequestSchema, {
+          status: params.status ?? [],
+          entityType: params.entityType,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async updateMentionStatus(params) {
+      const resp = await client.updateMentionStatus(
+        create7(UpdateMentionStatusRequestSchema, {
+          mentionId: params.mentionId,
+          status: params.status,
+          completedNote: params.completedNote,
+          dismissReason: params.dismissReason
+        })
+      );
+      return resp.mention ?? null;
+    },
+    // ── Notes ────────────────────────────────────────────────
+    async createNote(params) {
+      const resp = await client.createNote(
+        create7(CreateNoteRequestSchema, {
+          ...params,
+          content: params.content
+        })
+      );
+      return resp.note ?? null;
+    },
+    async getNote(id) {
+      const resp = await client.getNote(create7(GetNoteRequestSchema, { id }));
+      return resp.note ?? null;
+    },
+    async listNotes(params) {
+      return client.listNotes(
+        create7(ListNotesRequestSchema, {
+          entityType: params.entityType,
+          entityId: params.entityId,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async updateNote(params) {
+      const resp = await client.updateNote(
+        create7(UpdateNoteRequestSchema, {
+          id: params.id,
+          content: params.content,
+          isResolved: params.isResolved
+        })
+      );
+      return resp.note ?? null;
+    },
+    async deleteNote(id) {
+      const resp = await client.deleteNote(
+        create7(DeleteNoteRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Context Dimensions ───────────────────────────────────
+    async listContextDimensions(params = {}) {
+      return client.listContextDimensions(
+        create7(ListContextDimensionsRequestSchema, {
+          search: params.search,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getContextDimension(id) {
+      const resp = await client.getContextDimension(
+        create7(GetContextDimensionRequestSchema, { id })
+      );
+      return resp.dimension ?? null;
+    },
+    async createContextDimension(params) {
+      const resp = await client.createContextDimension(
+        create7(CreateContextDimensionRequestSchema, params)
+      );
+      return resp.dimension ?? null;
+    },
+    async updateContextDimension(params) {
+      const resp = await client.updateContextDimension(
+        create7(UpdateContextDimensionRequestSchema, params)
+      );
+      return resp.dimension ?? null;
+    },
+    async deleteContextDimension(id) {
+      const resp = await client.deleteContextDimension(
+        create7(DeleteContextDimensionRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async getContextDimensionValues(dimensionKey, params = {}) {
+      return client.getContextDimensionValues(
+        create7(GetContextDimensionValuesRequestSchema, {
+          dimensionKey,
+          search: params.search,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Customer Profile Schema ──────────────────────────────
+    async getCustomerProfileSchema() {
+      const resp = await client.getCustomerProfileSchema(
+        create7(GetCustomerProfileSchemaRequestSchema, {})
+      );
+      return resp.schema ?? null;
+    },
+    async getCustomerProfile(customerId) {
+      const resp = await client.getCustomerProfile(
+        create7(GetCustomerProfileRequestSchema, { customerId })
+      );
+      return resp.data ?? null;
+    },
+    async setCustomerProfile(params) {
+      const resp = await client.setCustomerProfile(
+        create7(SetCustomerProfileRequestSchema, {
+          customerId: params.customerId,
+          data: params.data
+        })
+      );
+      return resp.success;
+    },
+    async updateCustomerProfileSchema(params) {
+      const resp = await client.updateCustomerProfileSchema(
+        create7(UpdateCustomerProfileSchemaRequestSchema, {
+          fields: params.fields.map((f) => ({
+            id: f.id,
+            key: f.key,
+            type: f.type,
+            label: f.label,
+            required: f.required,
+            helpText: f.helpText,
+            placeholder: f.placeholder,
+            config: f.config
+          })),
+          publicFields: params.publicFields
+        })
+      );
+      return resp.schema ?? null;
+    },
+    async getCustomerResolutionAttributes(customerId) {
+      return client.getCustomerResolutionAttributes(
+        create7(GetCustomerResolutionAttributesRequestSchema, { customerId })
+      );
+    },
+    async getEditorConfigs(modelKey) {
+      const resp = await client.getEditorConfigs(
+        create7(GetEditorConfigsRequestSchema, { modelKey })
+      );
+      return resp.placements ?? [];
+    },
+    // ── Variant Catalog ──────────────────────────────────────
+    async listVariantCatalog(params = {}) {
+      return client.listVariantCatalog(
+        create7(ListVariantCatalogRequestSchema, {
+          isActive: params.isActive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getVariantCatalogEntry(id) {
+      const resp = await client.getVariantCatalogEntry(
+        create7(GetVariantCatalogEntryRequestSchema, { id })
+      );
+      return resp.entry ?? null;
+    },
+    async createVariantCatalogEntry(params) {
+      const resp = await client.createVariantCatalogEntry(
+        create7(CreateVariantCatalogEntryRequestSchema, {
+          key: params.key,
+          name: params.name,
+          description: params.description,
+          targetingRules: params.targetingRules,
+          priority: params.priority,
+          isDefault: params.isDefault,
+          isActive: params.isActive
+        })
+      );
+      return resp.entry ?? null;
+    },
+    async updateVariantCatalogEntry(params) {
+      const resp = await client.updateVariantCatalogEntry(
+        create7(UpdateVariantCatalogEntryRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          targetingRules: params.targetingRules,
+          priority: params.priority,
+          isDefault: params.isDefault,
+          isActive: params.isActive
+        })
+      );
+      return resp.entry ?? null;
+    },
+    async deleteVariantCatalogEntry(id) {
+      const resp = await client.deleteVariantCatalogEntry(
+        create7(DeleteVariantCatalogEntryRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Locales ──────────────────────────────────────────────
+    async listLocales(params = {}) {
+      return client.listLocales(
+        create7(ListLocalesRequestSchema, {
+          includeInactive: params.includeInactive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getLocale(id) {
+      const resp = await client.getLocale(
+        create7(GetLocaleRequestSchema, { id })
+      );
+      return resp.locale ?? null;
+    },
+    async createLocale(params) {
+      const resp = await client.createLocale(
+        create7(CreateLocaleRequestSchema, {
+          locale: params.locale,
+          displayName: params.displayName,
+          nativeName: params.nativeName,
+          isDefault: params.isDefault,
+          isRtl: params.isRtl,
+          fallbackLocale: params.fallbackLocale
+        })
+      );
+      return resp.locale ?? null;
+    },
+    async updateLocale(params) {
+      const resp = await client.updateLocale(
+        create7(UpdateLocaleRequestSchema, {
+          id: params.id,
+          displayName: params.displayName,
+          nativeName: params.nativeName,
+          isDefault: params.isDefault,
+          isActive: params.isActive,
+          isRtl: params.isRtl,
+          fallbackLocale: params.fallbackLocale
+        })
+      );
+      return resp.locale ?? null;
+    },
+    async deleteLocale(id) {
+      const resp = await client.deleteLocale(
+        create7(DeleteLocaleRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Nav Preferences ─────────────────────────────────────
+    async getNavPreferences() {
+      const resp = await client.getNavPreferences(
+        create7(GetNavPreferencesRequestSchema, {})
+      );
+      return resp.preferences ?? null;
+    },
+    async updateNavPreferences(params) {
+      const resp = await client.updateNavPreferences(
+        create7(UpdateNavPreferencesRequestSchema, {
+          preferences: params.preferences ? {
+            favoriteProjects: params.preferences.favoriteProjects,
+            favoriteNavItems: params.preferences.favoriteNavItems,
+            collapsedSections: params.preferences.collapsedSections,
+            navItemOrder: params.preferences.navItemOrder
+          } : void 0,
+          toggleProjectId: params.toggleProjectId,
+          toggleNavItem: params.toggleNavItem,
+          toggleSection: params.toggleSection
+        })
+      );
+      return resp.preferences ?? null;
+    },
+    // ── Recently Opened ─────────────────────────────────────
+    async listRecentlyOpened(limit) {
+      const resp = await client.listRecentlyOpened(
+        create7(ListRecentlyOpenedRequestSchema, {
+          limit: limit ?? 20
+        })
+      );
+      return resp.items ?? [];
+    },
+    async trackRecentlyOpened(params) {
+      const resp = await client.trackRecentlyOpened(
+        create7(TrackRecentlyOpenedRequestSchema, {
+          type: params.type,
+          id: params.id,
+          label: params.label,
+          path: params.path
+        })
+      );
+      return resp.success;
+    },
+    async removeRecentlyOpened(params) {
+      const resp = await client.removeRecentlyOpened(
+        create7(RemoveRecentlyOpenedRequestSchema, {
+          type: params.type,
+          id: params.id
+        })
+      );
+      return resp.success;
+    },
+    async clearRecentlyOpened() {
+      const resp = await client.clearRecentlyOpened(
+        create7(ClearRecentlyOpenedRequestSchema, {})
+      );
+      return resp.success;
+    },
+    // ── Email Actions ──────────────────────────────────────────
+    async listEmailActions(params = {}) {
+      return client.listEmailActions(
+        create7(ListEmailActionsRequestSchema, {
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async updateEmailAction(params) {
+      const resp = await client.updateEmailAction(
+        create7(UpdateEmailActionRequestSchema, {
+          key: params.key,
+          resendTemplateId: params.resendTemplateId,
+          defaultFrom: params.defaultFrom,
+          defaultSubject: params.defaultSubject,
+          customData: params.customData,
+          isActive: params.isActive
+        })
+      );
+      return resp.action ?? null;
+    },
+    async listResendTemplates() {
+      const resp = await client.listResendTemplates(
+        create7(ListResendTemplatesRequestSchema, {})
+      );
+      return resp.templates ?? [];
+    }
+  };
 }
-// src/commands/select-project.ts
-import inquirer from "inquirer";
+// src/lib/rpc/storage.ts
+import { create as create8 } from "@bufbuild/protobuf";
+import {
+  CreateFileUploadRequestSchema,
+  ConfirmFileUploadRequestSchema,
+  GetFileRequestSchema,
+  ListFilesRequestSchema,
+  GetStorageUsageRequestSchema,
+  UpdateFileRequestSchema,
+  UpdateFileMetadataRequestSchema,
+  DeleteFileRequestSchema,
+  PermanentlyDeleteFileRequestSchema,
+  RestoreFileRequestSchema,
+  TrackFileUsageRequestSchema,
+  RemoveFileUsageRequestSchema,
+  CleanupOrphanedFilesRequestSchema
+} from "@eide/foir-proto-ts/storage/v1/storage_pb";
+function createStorageMethods(client) {
+  return {
+    async createFileUpload(params) {
+      return client.createFileUpload(
+        create8(CreateFileUploadRequestSchema, {
+          filename: params.filename,
+          mimeType: params.mimeType,
+          size: BigInt(params.size),
+          folder: params.folder
+        })
+      );
+    },
+    async confirmFileUpload(uploadId) {
+      const resp = await client.confirmFileUpload(
+        create8(ConfirmFileUploadRequestSchema, { uploadId })
+      );
+      return resp.file ?? null;
+    },
+    async getFile(id) {
+      const resp = await client.getFile(create8(GetFileRequestSchema, { id }));
+      return resp.file ?? null;
+    },
+    async listFiles(params) {
+      return client.listFiles(
+        create8(ListFilesRequestSchema, {
+          folder: params.folder,
+          mimeType: params.mimeType,
+          search: params.search,
+          includeDeleted: params.includeDeleted ?? false,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getStorageUsage() {
+      const resp = await client.getStorageUsage(
+        create8(GetStorageUsageRequestSchema, {})
+      );
+      return resp.usage ?? null;
+    },
+    async updateFile(params) {
+      const resp = await client.updateFile(
+        create8(UpdateFileRequestSchema, {
+          id: params.id,
+          filename: params.filename,
+          folder: params.folder,
+          tags: params.tags ?? []
+        })
+      );
+      return resp.file ?? null;
+    },
+    async updateFileMetadata(params) {
+      const resp = await client.updateFileMetadata(
+        create8(UpdateFileMetadataRequestSchema, {
+          id: params.id,
+          altText: params.altText,
+          caption: params.caption,
+          description: params.description
+        })
+      );
+      return resp.file ?? null;
+    },
+    async deleteFile(id) {
+      const resp = await client.deleteFile(
+        create8(DeleteFileRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async permanentlyDeleteFile(id) {
+      const resp = await client.permanentlyDeleteFile(
+        create8(PermanentlyDeleteFileRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async restoreFile(id) {
+      const resp = await client.restoreFile(
+        create8(RestoreFileRequestSchema, { id })
+      );
+      return resp.file ?? null;
+    },
+    async trackFileUsage(fileId, entityType) {
+      const resp = await client.trackFileUsage(
+        create8(TrackFileUsageRequestSchema, { fileId, entityType })
+      );
+      return resp.file ?? null;
+    },
+    async removeFileUsage(fileId, entityType) {
+      const resp = await client.removeFileUsage(
+        create8(RemoveFileUsageRequestSchema, { fileId, entityType })
+      );
+      return resp.success;
+    },
+    async cleanupOrphanedFiles(params) {
+      return client.cleanupOrphanedFiles(
+        create8(CleanupOrphanedFilesRequestSchema, {
+          orphanThresholdDays: params?.orphanThresholdDays ?? 30,
+          dryRun: params?.dryRun ?? false,
+          limit: params?.limit ?? 100
+        })
+      );
+    }
+  };
+}
 // src/lib/client.ts
-import { createClient as createRpcClient } from "@connectrpc/connect";
-import { createConnectTransport } from "@connectrpc/connect-node";
-import {
-  IdentityService,
-  ModelsService,
-  RecordsService,
-  ConfigsService,
-  SegmentsService,
-  ExperimentsService,
-  SettingsService,
-  StorageService
-} from "@eide/foir-connect-clients/services";
-import { createIdentityMethods } from "@eide/foir-connect-clients/identity";
-import { createModelsMethods } from "@eide/foir-connect-clients/models";
-import { createRecordsMethods } from "@eide/foir-connect-clients/records";
-import { createConfigsMethods } from "@eide/foir-connect-clients/configs";
-import { createSegmentsMethods } from "@eide/foir-connect-clients/segments";
-import { createExperimentsMethods } from "@eide/foir-connect-clients/experiments";
-import { createSettingsMethods } from "@eide/foir-connect-clients/settings";
-import { createStorageMethods } from "@eide/foir-connect-clients/storage";
 import { GraphQLClient } from "graphql-request";
 async function createPlatformClient(options) {
   const apiUrl = getApiUrl(options);
@@ -504,16 +2723,16 @@ async function createPlatformClient(options) {
     interceptors: [authInterceptor]
   });
   return {
-    identity: createIdentityMethods(createRpcClient(IdentityService, transport)),
-    models: createModelsMethods(createRpcClient(ModelsService, transport)),
-    records: createRecordsMethods(createRpcClient(RecordsService, transport)),
-    configs: createConfigsMethods(createRpcClient(ConfigsService, transport)),
-    segments: createSegmentsMethods(createRpcClient(SegmentsService, transport)),
+    identity: createIdentityMethods(createRpcClient(IdentityService2, transport)),
+    models: createModelsMethods(createRpcClient(ModelsService2, transport)),
+    records: createRecordsMethods(createRpcClient(RecordsService2, transport)),
+    configs: createConfigsMethods(createRpcClient(ConfigsService2, transport)),
+    segments: createSegmentsMethods(createRpcClient(SegmentsService2, transport)),
     experiments: createExperimentsMethods(
-      createRpcClient(ExperimentsService, transport)
+      createRpcClient(ExperimentsService2, transport)
     ),
-    settings: createSettingsMethods(createRpcClient(SettingsService, transport)),
-    storage: createStorageMethods(createRpcClient(StorageService, transport))
+    settings: createSettingsMethods(createRpcClient(SettingsService2, transport)),
+    storage: createStorageMethods(createRpcClient(StorageService2, transport))
   };
 }
 function createPlatformClientWithHeaders(apiUrl, headers) {
@@ -529,16 +2748,16 @@ function createPlatformClientWithHeaders(apiUrl, headers) {
     interceptors: [authInterceptor]
   });
   return {
-    identity: createIdentityMethods(createRpcClient(IdentityService, transport)),
-    models: createModelsMethods(createRpcClient(ModelsService, transport)),
-    records: createRecordsMethods(createRpcClient(RecordsService, transport)),
-    configs: createConfigsMethods(createRpcClient(ConfigsService, transport)),
-    segments: createSegmentsMethods(createRpcClient(SegmentsService, transport)),
+    identity: createIdentityMethods(createRpcClient(IdentityService2, transport)),
+    models: createModelsMethods(createRpcClient(ModelsService2, transport)),
+    records: createRecordsMethods(createRpcClient(RecordsService2, transport)),
+    configs: createConfigsMethods(createRpcClient(ConfigsService2, transport)),
+    segments: createSegmentsMethods(createRpcClient(SegmentsService2, transport)),
     experiments: createExperimentsMethods(
-      createRpcClient(ExperimentsService, transport)
+      createRpcClient(ExperimentsService2, transport)
     ),
-    settings: createSettingsMethods(createRpcClient(SettingsService, transport)),
-    storage: createStorageMethods(createRpcClient(StorageService, transport))
+    settings: createSettingsMethods(createRpcClient(SettingsService2, transport)),
+    storage: createStorageMethods(createRpcClient(StorageService2, transport))
   };
 }
 async function getStorageAuth(options) {
@@ -620,11 +2839,24 @@ function registerSelectProjectCommand(program2, globalOpts) {
             name: t.name
           })
         );
-        const projects = (sessionContext.availableProjects ?? []).map((p) => ({
-          id: p.id,
-          name: p.name,
-          tenantId: p.tenantId
-        }));
+        if (tenants.length === 0) {
+          console.log(
+            "No workspaces found. Create one in the platform first."
+          );
+          throw new Error("No workspaces available");
+        }
+        const projects = [];
+        for (const tenant of tenants) {
+          const { items } = await client.identity.listProjects({
+            tenantId: tenant.id,
+            status: 1,
+            // PROJECT_STATUS_ACTIVE
+            limit: 100
+          });
+          for (const p of items) {
+            projects.push({ id: p.id, name: p.name, tenantId: p.tenantId });
+          }
+        }
         if (projects.length === 0) {
           console.log("No projects found. Create one in the platform first.");
           throw new Error("No projects available");
@@ -873,7 +3105,9 @@ function registerWhoamiCommand(program2, globalOpts) {
 import { promises as fs2 } from "fs";
 import { basename } from "path";
 import chalk3 from "chalk";
-import { createStorageClient } from "@eide/foir-connect-clients/storage";
+import { createClient } from "@connectrpc/connect";
+import { createConnectTransport as createConnectTransport2 } from "@connectrpc/connect-node";
+import { StorageService as StorageService3 } from "@eide/foir-proto-ts/storage/v1/storage_pb";
 // src/lib/input.ts
 import inquirer2 from "inquirer";
@@ -967,11 +3201,19 @@ function guessMimeType(filename) {
 function getStorageUrl() {
   return process.env.FOIR_STORAGE_URL ?? "https://storage.foir.dev";
 }
-function createClient(getToken) {
-  return createStorageClient({
+function createStorageRpcClient(getToken) {
+  const transport = createConnectTransport2({
     baseUrl: getStorageUrl(),
-    getAuthToken: getToken
+    httpVersion: "1.1",
+    interceptors: [
+      (next) => async (req) => {
+        const token = await getToken();
+        if (token) req.header.set("Authorization", `Bearer ${token}`);
+        return next(req);
+      }
+    ]
   });
+  return createStorageMethods(createClient(StorageService3, transport));
 }
 function registerMediaCommands(program2, globalOpts) {
   const media = program2.command("media").description("Media file operations");
@@ -981,7 +3223,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (filepath, flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient(getToken);
+        const storage = createStorageRpcClient(getToken);
         const fileBuffer = await fs2.readFile(filepath);
         const filename = basename(filepath);
         const mimeType = guessMimeType(filename);
@@ -1022,7 +3264,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient(getToken);
+        const storage = createStorageRpcClient(getToken);
         const result = await storage.listFiles({
           folder: flags.folder,
           mimeType: flags["mime-type"] ?? flags.mimeType,
@@ -1064,7 +3306,7 @@ function registerMediaCommands(program2, globalOpts) {
     withErrorHandler(globalOpts, async (id) => {
       const opts = globalOpts();
       const { getToken } = await getStorageAuth(opts);
-      const storage = createClient(getToken);
+      const storage = createStorageRpcClient(getToken);
       const file = await storage.getFile(id);
       formatOutput(file, opts);
     })
@@ -1073,7 +3315,7 @@ function registerMediaCommands(program2, globalOpts) {
     withErrorHandler(globalOpts, async () => {
       const opts = globalOpts();
       const { getToken } = await getStorageAuth(opts);
-      const storage = createClient(getToken);
+      const storage = createStorageRpcClient(getToken);
       const usage = await storage.getStorageUsage();
       if (opts.json || opts.jsonl) {
         formatOutput(usage, opts);
@@ -1092,7 +3334,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (id, flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient(getToken);
+        const storage = createStorageRpcClient(getToken);
         const file = await storage.updateFile({
           id,
           filename: flags.filename,
@@ -1113,7 +3355,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (id, flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient(getToken);
+        const storage = createStorageRpcClient(getToken);
         const file = await storage.updateFileMetadata({
           id,
           altText: flags.altText ?? flags["alt-text"],
@@ -1141,7 +3383,7 @@ function registerMediaCommands(program2, globalOpts) {
           return;
         }
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient(getToken);
+        const storage = createStorageRpcClient(getToken);
         if (flags.permanent) {
           await storage.permanentlyDeleteFile(id);
           success("Permanently deleted file");
@@ -1156,7 +3398,7 @@ function registerMediaCommands(program2, globalOpts) {
     withErrorHandler(globalOpts, async (id) => {
       const opts = globalOpts();
       const { getToken } = await getStorageAuth(opts);
-      const storage = createClient(getToken);
+      const storage = createStorageRpcClient(getToken);
       const file = await storage.restoreFile(id);
       if (opts.json || opts.jsonl) {
         formatOutput(file, opts);
@@ -3721,7 +5963,7 @@ import {
 } from "graphql";
 // src/commands/register-commands.ts
-import { RecordType } from "@eide/foir-connect-clients/records";
+import { RecordType as RecordType2 } from "@eide/foir-proto-ts/records/v1/records_pb";
 function buildDispatchTable() {
   return {
     // ── Models ──────────────────────────────────────────────────
@@ -4367,7 +6609,7 @@ function registerDynamicCommands(program2, globalOpts) {
             } else {
               try {
                 const record = await client.records.getRecord(versionIdValue);
-                if (record?.recordType === RecordType.RECORD && record?.currentVersionId) {
+                if (record?.recordType === RecordType2.RECORD && record?.currentVersionId) {
                   variables.versionId = record.currentVersionId;
                 }
               } catch {