@eide/foir-cli 0.1.46 → 0.2.0

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { config } from "dotenv";
-import { resolve as resolve6, dirname as dirname5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { resolve as resolve6, dirname as dirname4 } from "path";
+import { fileURLToPath } from "url";
 import { createRequire } from "module";
 import { Command } from "commander";
 
@@ -237,23 +237,15 @@ var DEFAULT_API_URL = "https://api.foir.dev";
 function getApiUrl(options) {
   return process.env.FOIR_API_URL ?? options?.apiUrl ?? DEFAULT_API_URL;
 }
-function getGraphQLEndpoint(apiUrl) {
-  const base = apiUrl.replace(/\/$/, "").replace(/\/graphql$/, "");
-  return `${base}/graphql`;
-}
 
 // src/lib/errors.ts
 import chalk from "chalk";
+import { ConnectError, Code } from "@connectrpc/connect";
 function extractErrorMessage(error) {
   if (!error || typeof error !== "object")
     return String(error ?? "Unknown error");
-  const err = error;
-  const gqlErrors = err.response?.errors;
-  if (gqlErrors && gqlErrors.length > 0) {
-    return gqlErrors[0].message;
-  }
-  if (err.message && err.message !== "undefined") {
-    return err.message;
+  if (error instanceof ConnectError) {
+    return error.message;
   }
   if (error instanceof Error && error.message) {
     return error.message;
@@ -266,44 +258,25 @@ function withErrorHandler(optsFn, fn) {
       await fn(...args);
     } catch (error) {
       const opts = optsFn();
-      const gqlErr = error;
-      const gqlErrors = gqlErr?.response?.errors;
-      if (gqlErrors && gqlErrors.length > 0) {
-        const first = gqlErrors[0];
-        const code = first.extensions?.code;
-        const validationErrors = first.extensions?.validationErrors;
+      if (error instanceof ConnectError) {
+        const code = error.code;
+        const message2 = error.message;
         if (opts?.json || opts?.jsonl) {
           console.error(
             JSON.stringify({
               error: {
-                message: first.message,
-                code: code ?? "GRAPHQL_ERROR",
-                ...validationErrors ? { validationErrors } : {},
-                ...gqlErrors.length > 1 ? {
-                  additionalErrors: gqlErrors.slice(1).map((e) => e.message)
-                } : {}
+                message: message2,
+                code: Code[code] ?? "UNKNOWN"
               }
             })
           );
         } else {
-          console.error(chalk.red("Error:"), first.message);
-          for (const extra of gqlErrors.slice(1)) {
-            console.error(chalk.red("  \u2022"), extra.message);
-          }
-          if (validationErrors && Object.keys(validationErrors).length > 0) {
-            console.error("");
-            console.error(chalk.yellow("Field errors:"));
-            for (const [field, messages] of Object.entries(validationErrors)) {
-              for (const msg of messages) {
-                console.error(chalk.gray(`  \u2022 ${field}:`), msg);
-              }
-            }
-          }
-          if (code === "UNAUTHENTICATED") {
+          console.error(chalk.red("Error:"), message2);
+          if (code === Code.Unauthenticated) {
             console.error(
               chalk.gray("\nHint: Run `foir login` to authenticate.")
             );
-          } else if (code === "FORBIDDEN") {
+          } else if (code === Code.PermissionDenied) {
             console.error(
               chalk.gray(
                 "\nHint: You may not have permission. Check your API key scopes."
@@ -313,22 +286,6 @@ function withErrorHandler(optsFn, fn) {
         }
         process.exit(1);
       }
-      const status = gqlErr?.response?.status;
-      if (status === 401 || status === 403) {
-        if (opts?.json || opts?.jsonl) {
-          console.error(
-            JSON.stringify({
-              error: { message: "Authentication failed", code: "AUTH_ERROR" }
-            })
-          );
-        } else {
-          console.error(chalk.red("Error:"), "Authentication failed.");
-          console.error(
-            chalk.gray("Hint: Run `foir login` or set FOIR_API_KEY.")
-          );
-        }
-        process.exit(1);
-      }
       const message = extractErrorMessage(error);
       if (opts?.json || opts?.jsonl) {
         console.error(JSON.stringify({ error: { message } }));
@@ -489,102 +446,153 @@ function registerLogoutCommand(program2, globalOpts) {
 
 // src/commands/select-project.ts
 import inquirer from "inquirer";
-var CLI_API_KEY_NAME = "Foir CLI";
-var CLI_API_KEY_SCOPES = [
-  "records:read",
-  "records:write",
-  "records:delete",
-  "records:publish",
-  "files:read",
-  "files:write",
-  "configs:read",
-  "operations:read",
-  "operations:execute"
-];
-async function gqlRequest(apiUrl, accessToken, query, variables, extraHeaders) {
-  const response = await fetch(getGraphQLEndpoint(apiUrl), {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${accessToken}`,
-      ...extraHeaders
-    },
-    body: JSON.stringify({ query, variables })
-  });
-  if (!response.ok) {
-    throw new Error(`GraphQL request failed: ${response.statusText}`);
+
+// src/lib/client.ts
+import { createClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-node";
+import {
+  IdentityService,
+  ModelsService,
+  RecordsService,
+  ConfigsService,
+  SegmentsService,
+  ExperimentsService,
+  SettingsService,
+  StorageService
+} from "@foir/connect-clients/services";
+import { createIdentityMethods } from "@foir/connect-clients/identity";
+import { createModelsMethods } from "@foir/connect-clients/models";
+import { createRecordsMethods } from "@foir/connect-clients/records";
+import { createConfigsMethods } from "@foir/connect-clients/configs";
+import { createSegmentsMethods } from "@foir/connect-clients/segments";
+import { createExperimentsMethods } from "@foir/connect-clients/experiments";
+import { createSettingsMethods } from "@foir/connect-clients/settings";
+import { createStorageMethods } from "@foir/connect-clients/storage";
+async function createPlatformClient(options) {
+  const apiUrl = getApiUrl(options);
+  const headers = {};
+  const envApiKey = process.env.FOIR_API_KEY;
+  if (envApiKey) {
+    headers["x-api-key"] = envApiKey;
+  } else {
+    const credentials = await getCredentials();
+    if (!credentials) {
+      throw new Error(
+        "Not authenticated. Run `foir login` or set FOIR_API_KEY."
+      );
+    }
+    if (isTokenExpired(credentials)) {
+      throw new Error("Session expired. Run `foir login` to re-authenticate.");
+    }
+    headers["Authorization"] = `Bearer ${credentials.accessToken}`;
   }
-  const result = await response.json();
-  if (result.errors?.length) {
-    throw new Error(`GraphQL error: ${result.errors[0].message}`);
+  const resolved = await resolveProjectContext(options);
+  if (resolved) {
+    headers["x-tenant-id"] = resolved.project.tenantId;
+    headers["x-project-id"] = resolved.project.id;
   }
-  return result.data;
-}
-async function fetchSessionContext(apiUrl, accessToken) {
-  const data = await gqlRequest(
-    apiUrl,
-    accessToken,
-    `query { sessionContext { tenantId projectId availableTenants { id name } availableProjects { id name tenantId } } }`
-  );
-  return data.sessionContext;
-}
-async function fetchApiKeys(apiUrl, accessToken, projectId, tenantId) {
-  const data = await gqlRequest(
-    apiUrl,
-    accessToken,
-    `query { listApiKeys(includeInactive: false, limit: 100) { items { id name isActive } } }`,
-    void 0,
-    { "x-tenant-id": tenantId, "x-project-id": projectId }
-  );
-  return data.listApiKeys?.items ?? [];
-}
-async function createApiKey(apiUrl, accessToken, projectId, tenantId) {
-  const data = await gqlRequest(
-    apiUrl,
-    accessToken,
-    `mutation($input: CreateApiKeyInput!) { createApiKey(input: $input) { apiKey { id name isActive } plainKey } }`,
-    {
-      input: {
-        name: CLI_API_KEY_NAME,
-        projectId,
-        keyType: "SECRET",
-        scopes: CLI_API_KEY_SCOPES
-      }
-    },
-    { "x-tenant-id": tenantId, "x-project-id": projectId }
-  );
-  return data.createApiKey;
+  const authInterceptor = (next) => async (req) => {
+    for (const [key, value] of Object.entries(headers)) {
+      req.header.set(key, value);
+    }
+    return next(req);
+  };
+  const transport = createConnectTransport({
+    baseUrl: apiUrl.replace(/\/$/, ""),
+    httpVersion: "1.1",
+    interceptors: [authInterceptor]
+  });
+  return {
+    identity: createIdentityMethods(createClient(IdentityService, transport)),
+    models: createModelsMethods(createClient(ModelsService, transport)),
+    records: createRecordsMethods(createClient(RecordsService, transport)),
+    configs: createConfigsMethods(createClient(ConfigsService, transport)),
+    segments: createSegmentsMethods(createClient(SegmentsService, transport)),
+    experiments: createExperimentsMethods(
+      createClient(ExperimentsService, transport)
+    ),
+    settings: createSettingsMethods(createClient(SettingsService, transport)),
+    storage: createStorageMethods(createClient(StorageService, transport))
+  };
 }
-async function rotateApiKey(apiUrl, accessToken, projectId, tenantId, keyId) {
-  const data = await gqlRequest(
-    apiUrl,
-    accessToken,
-    `mutation($id: ID!) { rotateApiKey(id: $id) { apiKey { id name isActive } plainKey } }`,
-    { id: keyId },
-    { "x-tenant-id": tenantId, "x-project-id": projectId }
-  );
-  return data.rotateApiKey;
+function createPlatformClientWithHeaders(apiUrl, headers) {
+  const authInterceptor = (next) => async (req) => {
+    for (const [key, value] of Object.entries(headers)) {
+      req.header.set(key, value);
+    }
+    return next(req);
+  };
+  const transport = createConnectTransport({
+    baseUrl: apiUrl.replace(/\/$/, ""),
+    httpVersion: "1.1",
+    interceptors: [authInterceptor]
+  });
+  return {
+    identity: createIdentityMethods(createClient(IdentityService, transport)),
+    models: createModelsMethods(createClient(ModelsService, transport)),
+    records: createRecordsMethods(createClient(RecordsService, transport)),
+    configs: createConfigsMethods(createClient(ConfigsService, transport)),
+    segments: createSegmentsMethods(createClient(SegmentsService, transport)),
+    experiments: createExperimentsMethods(
+      createClient(ExperimentsService, transport)
+    ),
+    settings: createSettingsMethods(createClient(SettingsService, transport)),
+    storage: createStorageMethods(createClient(StorageService, transport))
+  };
 }
-async function provisionApiKey(apiUrl, accessToken, projectId, tenantId) {
-  const apiKeys = await fetchApiKeys(apiUrl, accessToken, projectId, tenantId);
-  const existing = apiKeys.find(
-    (k) => k.name === CLI_API_KEY_NAME && k.isActive
-  );
-  if (existing) {
-    console.log("  Rotating existing CLI API key...");
-    const rotated = await rotateApiKey(
-      apiUrl,
-      accessToken,
-      projectId,
-      tenantId,
-      existing.id
-    );
-    return { apiKey: rotated.plainKey, apiKeyId: rotated.apiKey.id };
+async function getStorageAuth(options) {
+  const apiUrl = getApiUrl(options);
+  const baseHeaders = {
+    "Content-Type": "application/json"
+  };
+  const envApiKey = process.env.FOIR_API_KEY;
+  if (envApiKey) {
+    baseHeaders["x-api-key"] = envApiKey;
+  } else {
+    const credentials = await getCredentials();
+    if (!credentials) {
+      throw new Error(
+        "Not authenticated. Run `foir login` or set FOIR_API_KEY."
+      );
+    }
+    if (isTokenExpired(credentials)) {
+      throw new Error("Session expired. Run `foir login` to re-authenticate.");
+    }
+    baseHeaders["Authorization"] = `Bearer ${credentials.accessToken}`;
   }
-  console.log("  Creating CLI API key...");
-  const created = await createApiKey(apiUrl, accessToken, projectId, tenantId);
-  return { apiKey: created.plainKey, apiKeyId: created.apiKey.id };
+  const resolved = await resolveProjectContext(options);
+  if (resolved) {
+    baseHeaders["x-tenant-id"] = resolved.project.tenantId;
+    baseHeaders["x-project-id"] = resolved.project.id;
+  }
+  let cachedToken = null;
+  const getToken = async () => {
+    if (cachedToken && Date.now() < cachedToken.expiresAt - 3e4) {
+      return cachedToken.token;
+    }
+    const tokenUrl = `${apiUrl.replace(/\/$/, "")}/api/auth/token`;
+    const res = await fetch(tokenUrl, {
+      method: "POST",
+      headers: baseHeaders,
+      body: JSON.stringify({ purpose: "storage" })
+    });
+    if (!res.ok) {
+      throw new Error(
+        `Failed to get storage token (${res.status}): ${await res.text()}`
+      );
+    }
+    const data = await res.json();
+    cachedToken = {
+      token: data.token,
+      expiresAt: new Date(data.expiresAt).getTime()
+    };
+    return cachedToken.token;
+  };
+  return { getToken };
 }
+
+// src/commands/select-project.ts
+var CLI_API_KEY_NAME = "Foir CLI";
 function registerSelectProjectCommand(program2, globalOpts) {
   program2.command("select-project").description("Choose which project to work with").option("--project-id <id>", "Project ID to select directly").option("--save-as <name>", "Save as a named profile").action(
     withErrorHandler(
@@ -598,11 +606,24 @@ function registerSelectProjectCommand(program2, globalOpts) {
           throw new Error("Not authenticated");
         }
         console.log("Fetching your projects...\n");
-        const sessionContext = await fetchSessionContext(
-          apiUrl,
-          credentials.accessToken
+        const client = createPlatformClientWithHeaders(apiUrl, {
+          Authorization: `Bearer ${credentials.accessToken}`
+        });
+        const sessionContext = await client.identity.getSessionContext();
+        if (!sessionContext) {
+          throw new Error("Could not fetch session context");
+        }
+        const tenants = (sessionContext.availableTenants ?? []).map(
+          (t) => ({
+            id: t.id,
+            name: t.name
+          })
         );
-        const { availableTenants: tenants, availableProjects: projects } = sessionContext;
+        const projects = (sessionContext.availableProjects ?? []).map((p) => ({
+          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");
@@ -651,12 +672,12 @@ function registerSelectProjectCommand(program2, globalOpts) {
           selectedProject = projects.find((p) => p.id === projectId);
         }
         console.log("\nProvisioning API key for CLI access...");
-        const { apiKey, apiKeyId } = await provisionApiKey(
-          apiUrl,
-          credentials.accessToken,
-          selectedProject.id,
-          selectedProject.tenantId
-        );
+        const projectClient = createPlatformClientWithHeaders(apiUrl, {
+          Authorization: `Bearer ${credentials.accessToken}`,
+          "x-tenant-id": selectedProject.tenantId,
+          "x-project-id": selectedProject.id
+        });
+        const { apiKey, apiKeyId } = await provisionApiKey(projectClient);
         await writeProjectContext(
           {
             id: selectedProject.id,
@@ -681,6 +702,26 @@ function registerSelectProjectCommand(program2, globalOpts) {
     )
   );
 }
+async function provisionApiKey(client) {
+  const { items: apiKeys } = await client.identity.listApiKeys({ limit: 100 });
+  const existing = apiKeys.find(
+    (k) => k.name === CLI_API_KEY_NAME && k.isActive
+  );
+  if (existing) {
+    console.log("  Rotating existing CLI API key...");
+    const result2 = await client.identity.rotateApiKey(existing.id);
+    if (!result2.apiKey?.rawKey) {
+      throw new Error("Failed to rotate API key \u2014 no raw key returned");
+    }
+    return { apiKey: result2.apiKey.rawKey, apiKeyId: result2.apiKey.id };
+  }
+  console.log("  Creating CLI API key...");
+  const result = await client.identity.createApiKey({ name: CLI_API_KEY_NAME });
+  if (!result.apiKey?.rawKey) {
+    throw new Error("Failed to create API key \u2014 no raw key returned");
+  }
+  return { apiKey: result.apiKey.rawKey, apiKeyId: result.apiKey.id };
+}
 
 // src/lib/output.ts
 import chalk2 from "chalk";
@@ -734,11 +775,11 @@ function formatList(items, options, config2) {
 ${items.length} of ${config2.total} shown`));
   }
 }
-function pad(str, width) {
-  if (str.length > width) {
-    return str.slice(0, width - 1) + "\u2026";
+function pad(str2, width) {
+  if (str2.length > width) {
+    return str2.slice(0, width - 1) + "\u2026";
   }
-  return str.padEnd(width);
+  return str2.padEnd(width);
 }
 function timeAgo(dateStr) {
   if (!dateStr) return "\u2014";
@@ -831,99 +872,303 @@ function registerWhoamiCommand(program2, globalOpts) {
 import { promises as fs2 } from "fs";
 import { basename } from "path";
 import chalk3 from "chalk";
+import { createStorageClient } from "@foir/connect-clients/storage";
 
-// src/lib/client.ts
-import { GraphQLClient } from "graphql-request";
-async function createClient(options) {
-  const apiUrl = getApiUrl(options);
-  const endpoint = getGraphQLEndpoint(apiUrl);
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  const envApiKey = process.env.FOIR_API_KEY;
-  if (envApiKey) {
-    headers["x-api-key"] = envApiKey;
-    return new GraphQLClient(endpoint, { headers });
-  }
-  const credentials = await getCredentials();
-  if (!credentials) {
-    throw new Error("Not authenticated. Run `foir login` or set FOIR_API_KEY.");
+// src/lib/input.ts
+import inquirer2 from "inquirer";
+
+// src/lib/config-loader.ts
+import { readFile } from "fs/promises";
+import { pathToFileURL } from "url";
+import { resolve } from "path";
+async function loadConfig(filePath) {
+  const absPath = resolve(filePath);
+  if (filePath.endsWith(".ts")) {
+    const configModule = await import(pathToFileURL(absPath).href);
+    return configModule.default;
   }
-  if (isTokenExpired(credentials)) {
-    throw new Error("Session expired. Run `foir login` to re-authenticate.");
+  if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
+    const configModule = await import(pathToFileURL(absPath).href);
+    return configModule.default;
   }
-  headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-  const resolved = await resolveProjectContext(options);
-  if (resolved) {
-    headers["x-tenant-id"] = resolved.project.tenantId;
-    headers["x-project-id"] = resolved.project.id;
+  if (filePath.endsWith(".json")) {
+    const content = await readFile(absPath, "utf-8");
+    return JSON.parse(content);
   }
-  return new GraphQLClient(endpoint, { headers });
+  throw new Error(
+    `Unsupported file extension for "${filePath}". Supported: .ts, .js, .mjs, .json`
+  );
 }
-async function getRestAuth(options) {
-  const apiUrl = getApiUrl(options);
-  const headers = {};
-  const envApiKey = process.env.FOIR_API_KEY;
-  if (envApiKey) {
-    headers["x-api-key"] = envApiKey;
-    return { apiUrl, headers };
-  }
-  const credentials = await getCredentials();
-  if (!credentials) {
-    throw new Error("Not authenticated. Run `foir login` or set FOIR_API_KEY.");
+
+// src/lib/input.ts
+async function parseInputData(opts) {
+  if (opts.data) {
+    return JSON.parse(opts.data);
   }
-  if (isTokenExpired(credentials)) {
-    throw new Error("Session expired. Run `foir login` to re-authenticate.");
+  if (opts.file) {
+    return await loadConfig(opts.file);
   }
-  headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-  const resolved = await resolveProjectContext(options);
-  if (resolved) {
-    headers["x-tenant-id"] = resolved.project.tenantId;
-    headers["x-project-id"] = resolved.project.id;
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
+    if (stdinContent) {
+      return JSON.parse(stdinContent);
+    }
   }
-  return { apiUrl, headers };
+  throw new Error(
+    "No input data provided. Use --data, --file, or pipe via stdin."
+  );
+}
+function isUUID(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    value
+  ) || /^c[a-z0-9]{24,}$/.test(value);
+}
+async function confirmAction(message, opts) {
+  if (opts?.confirm) return true;
+  const { confirmed } = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: false
+    }
+  ]);
+  return confirmed;
 }
 
 // src/commands/media.ts
+var MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".txt": "text/plain"
+};
+function guessMimeType(filename) {
+  const ext = filename.slice(filename.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+function getStorageUrl() {
+  return process.env.FOIR_STORAGE_URL ?? "https://storage.foir.dev";
+}
+function createClient2(getToken) {
+  return createStorageClient({
+    baseUrl: getStorageUrl(),
+    getAuthToken: getToken
+  });
+}
 function registerMediaCommands(program2, globalOpts) {
   const media = program2.command("media").description("Media file operations");
-  media.command("upload <filepath>").description("Upload a file").action(
-    withErrorHandler(globalOpts, async (filepath) => {
-      const opts = globalOpts();
-      const { apiUrl, headers } = await getRestAuth(opts);
-      const fileBuffer = await fs2.readFile(filepath);
-      const fileName = basename(filepath);
-      const formData = new FormData();
-      formData.append("file", new Blob([fileBuffer]), fileName);
-      const uploadUrl = `${apiUrl.replace(/\/$/, "")}/api/files/upload`;
-      const response = await fetch(uploadUrl, {
-        method: "POST",
-        headers,
-        body: formData
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Upload failed (${response.status}): ${errorText}`);
+  media.command("upload <filepath>").description("Upload a file").option("--folder <folder>", "Target folder").action(
+    withErrorHandler(
+      globalOpts,
+      async (filepath, flags) => {
+        const opts = globalOpts();
+        const { getToken } = await getStorageAuth(opts);
+        const storage = createClient2(getToken);
+        const fileBuffer = await fs2.readFile(filepath);
+        const filename = basename(filepath);
+        const mimeType = guessMimeType(filename);
+        const upload = await storage.createFileUpload({
+          filename,
+          mimeType,
+          size: fileBuffer.byteLength,
+          folder: flags.folder
+        });
+        const uploadResp = await fetch(upload.uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": mimeType },
+          body: fileBuffer
+        });
+        if (!uploadResp.ok) {
+          throw new Error(
+            `Upload to storage failed (${uploadResp.status}): ${await uploadResp.text()}`
+          );
+        }
+        const file = await storage.confirmFileUpload(upload.uploadId);
+        if (opts.json || opts.jsonl) {
+          formatOutput(file, opts);
+        } else {
+          success(`Uploaded ${filename}`);
+          if (file?.url) {
+            console.log(chalk3.bold(`  URL: ${file.url}`));
+          }
+          if (file?.storageKey) {
+            console.log(chalk3.gray(`  Key: ${file.storageKey}`));
+          }
+        }
       }
-      const result = await response.json();
+    )
+  );
+  media.command("list").description("List files").option("--folder <folder>", "Filter by folder").option("--mime-type <type>", "Filter by MIME type").option("--search <query>", "Search files").option("--include-deleted", "Include soft-deleted files").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset", "0").action(
+    withErrorHandler(
+      globalOpts,
+      async (flags) => {
+        const opts = globalOpts();
+        const { getToken } = await getStorageAuth(opts);
+        const storage = createClient2(getToken);
+        const result = await storage.listFiles({
+          folder: flags.folder,
+          mimeType: flags["mime-type"] ?? flags.mimeType,
+          search: flags.search,
+          includeDeleted: !!flags.includeDeleted,
+          limit: Number(flags.limit) || 50,
+          offset: Number(flags.offset) || 0
+        });
+        formatList(result.items, opts, {
+          columns: [
+            { key: "id", header: "ID", width: 28 },
+            { key: "filename", header: "Filename", width: 24 },
+            { key: "mimeType", header: "Type", width: 16 },
+            {
+              key: "size",
+              header: "Size",
+              width: 10,
+              format: (v) => {
+                const num2 = Number(v);
+                if (num2 < 1024) return `${num2} B`;
+                if (num2 < 1024 * 1024) return `${(num2 / 1024).toFixed(1)} KB`;
+                return `${(num2 / (1024 * 1024)).toFixed(1)} MB`;
+              }
+            },
+            { key: "folder", header: "Folder", width: 16 },
+            {
+              key: "createdAt",
+              header: "Created",
+              width: 12,
+              format: (v) => timeAgo(v)
+            }
+          ],
+          total: result.total
+        });
+      }
+    )
+  );
+  media.command("get <id>").description("Get file details").action(
+    withErrorHandler(globalOpts, async (id) => {
+      const opts = globalOpts();
+      const { getToken } = await getStorageAuth(opts);
+      const storage = createClient2(getToken);
+      const file = await storage.getFile(id);
+      formatOutput(file, opts);
+    })
+  );
+  media.command("usage").description("Get storage usage").action(
+    withErrorHandler(globalOpts, async () => {
+      const opts = globalOpts();
+      const { getToken } = await getStorageAuth(opts);
+      const storage = createClient2(getToken);
+      const usage = await storage.getStorageUsage();
       if (opts.json || opts.jsonl) {
-        formatOutput(result, opts);
+        formatOutput(usage, opts);
       } else {
-        success(`Uploaded ${fileName}`);
-        if (result.url) {
-          console.log(chalk3.bold(`  URL: ${result.url}`));
+        const mb = (Number(usage?.totalBytes ?? 0) / (1024 * 1024)).toFixed(
+          1
+        );
+        console.log(chalk3.bold(`Files: ${usage?.totalFiles ?? 0}`));
+        console.log(chalk3.bold(`Storage: ${mb} MB`));
+      }
+    })
+  );
+  media.command("update <id>").description("Update a file").option("--filename <name>", "New filename").option("--folder <folder>", "Move to folder").option("--tags <tags>", "Comma-separated tags").action(
+    withErrorHandler(
+      globalOpts,
+      async (id, flags) => {
+        const opts = globalOpts();
+        const { getToken } = await getStorageAuth(opts);
+        const storage = createClient2(getToken);
+        const file = await storage.updateFile({
+          id,
+          filename: flags.filename,
+          folder: flags.folder,
+          tags: flags.tags?.split(",").map((t) => t.trim())
+        });
+        if (opts.json || opts.jsonl) {
+          formatOutput(file, opts);
+        } else {
+          success("Updated file");
         }
-        if (result.storageKey) {
-          console.log(chalk3.gray(`  Key: ${result.storageKey}`));
+      }
+    )
+  );
+  media.command("update-metadata <id>").description("Update file metadata (alt text, caption, description)").option("--alt-text <text>", "Alt text").option("--caption <text>", "Caption").option("--description <text>", "Description").action(
+    withErrorHandler(
+      globalOpts,
+      async (id, flags) => {
+        const opts = globalOpts();
+        const { getToken } = await getStorageAuth(opts);
+        const storage = createClient2(getToken);
+        const file = await storage.updateFileMetadata({
+          id,
+          altText: flags.altText ?? flags["alt-text"],
+          caption: flags.caption,
+          description: flags.description
+        });
+        if (opts.json || opts.jsonl) {
+          formatOutput(file, opts);
+        } else {
+          success("Updated file metadata");
         }
       }
+    )
+  );
+  media.command("delete <id>").description("Delete a file").option("--confirm", "Skip confirmation prompt").option("--permanent", "Permanently delete (cannot be restored)").action(
+    withErrorHandler(
+      globalOpts,
+      async (id, flags) => {
+        const opts = globalOpts();
+        const confirmed = await confirmAction("Delete this file?", {
+          confirm: !!flags.confirm
+        });
+        if (!confirmed) {
+          console.log("Aborted.");
+          return;
+        }
+        const { getToken } = await getStorageAuth(opts);
+        const storage = createClient2(getToken);
+        if (flags.permanent) {
+          await storage.permanentlyDeleteFile(id);
+          success("Permanently deleted file");
+        } else {
+          await storage.deleteFile(id);
+          success("Deleted file");
+        }
+      }
+    )
+  );
+  media.command("restore <id>").description("Restore a deleted file").action(
+    withErrorHandler(globalOpts, async (id) => {
+      const opts = globalOpts();
+      const { getToken } = await getStorageAuth(opts);
+      const storage = createClient2(getToken);
+      const file = await storage.restoreFile(id);
+      if (opts.json || opts.jsonl) {
+        formatOutput(file, opts);
+      } else {
+        success("Restored file");
+      }
     })
   );
 }
 
 // src/commands/create-config.ts
 import chalk4 from "chalk";
-import inquirer2 from "inquirer";
+import inquirer3 from "inquirer";
 
 // src/scaffold/scaffold.ts
 import * as fs4 from "fs";
@@ -1347,7 +1592,7 @@ function getApiTsconfig() {
   return JSON.stringify(config2, null, 2) + "\n";
 }
 function getApiEnvExample(apiUrl) {
-  const baseUrl = apiUrl.replace(/\/graphql$/, "");
+  const baseUrl = apiUrl.replace(/\/$/, "");
   return `# Platform API
 PLATFORM_BASE_URL=${baseUrl}
 PLATFORM_API_KEY=sk_your_api_key_here
@@ -1425,11 +1670,7 @@ function isValidConfigType(value) {
   return CONFIG_TYPES.includes(value);
 }
 function registerCreateConfigCommand(program2, globalOpts) {
-  program2.command("create-config [name]").description("Scaffold a new Foir config").option("--type <type>", "Config type: custom-editor, workflow, widget").option(
-    "--api-url <url>",
-    "Platform API URL",
-    "http://localhost:4000/graphql"
-  ).action(
+  program2.command("create-config [name]").description("Scaffold a new Foir config").option("--type <type>", "Config type: custom-editor, workflow, widget").option("--api-url <url>", "Platform API URL", "http://localhost:4011").action(
     withErrorHandler(
       globalOpts,
       async (name, cmdOpts) => {
@@ -1439,7 +1680,7 @@ function registerCreateConfigCommand(program2, globalOpts) {
         console.log();
         let configName = name;
         if (!configName) {
-          const { inputName } = await inquirer2.prompt([
+          const { inputName } = await inquirer3.prompt([
             {
               type: "input",
               name: "inputName",
@@ -1453,7 +1694,7 @@ function registerCreateConfigCommand(program2, globalOpts) {
         if (cmdOpts?.type && isValidConfigType(cmdOpts.type)) {
           configType = cmdOpts.type;
         } else {
-          const { selectedType } = await inquirer2.prompt([
+          const { selectedType } = await inquirer3.prompt([
             {
               type: "list",
               name: "selectedType",
@@ -1464,7 +1705,7 @@ function registerCreateConfigCommand(program2, globalOpts) {
           ]);
           configType = selectedType;
         }
-        const apiUrl = cmdOpts?.apiUrl ?? "http://localhost:4000/graphql";
+        const apiUrl = cmdOpts?.apiUrl ?? "http://localhost:4011";
         console.log();
         console.log(
           `  Scaffolding ${chalk4.cyan(`"${configName}"`)} (${configType})...`
@@ -1476,224 +1717,53 @@ function registerCreateConfigCommand(program2, globalOpts) {
   );
 }
 
-// src/graphql/generated.ts
-var GlobalSearchDocument = {
-  kind: "Document",
-  definitions: [
-    {
-      kind: "OperationDefinition",
-      operation: "query",
-      name: { kind: "Name", value: "GlobalSearch" },
-      variableDefinitions: [
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "query" }
-          },
-          type: {
-            kind: "NonNullType",
-            type: {
-              kind: "NamedType",
-              name: { kind: "Name", value: "String" }
-            }
-          }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "limit" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "modelKeys" }
-          },
-          type: {
-            kind: "ListType",
-            type: {
-              kind: "NonNullType",
-              type: {
-                kind: "NamedType",
-                name: { kind: "Name", value: "String" }
-              }
-            }
-          }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "includeMedia" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "Boolean" } }
-        }
-      ],
-      selectionSet: {
-        kind: "SelectionSet",
-        selections: [
-          {
-            kind: "Field",
-            name: { kind: "Name", value: "globalSearch" },
-            arguments: [
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "query" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "query" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "limit" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "limit" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "modelKeys" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "modelKeys" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "includeMedia" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "includeMedia" }
-                }
-              }
-            ],
-            selectionSet: {
-              kind: "SelectionSet",
-              selections: [
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "records" },
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                      { kind: "Field", name: { kind: "Name", value: "id" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "modelKey" }
-                      },
-                      { kind: "Field", name: { kind: "Name", value: "title" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "naturalKey" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "subtitle" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "updatedAt" }
-                      }
-                    ]
-                  }
-                },
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "media" },
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                      { kind: "Field", name: { kind: "Name", value: "id" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "fileName" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "altText" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "fileUrl" }
-                      }
-                    ]
-                  }
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ]
-};
-
 // src/commands/search.ts
 function registerSearchCommands(program2, globalOpts) {
-  program2.command("search <query>").description("Search across all records and media").option(
+  program2.command("search <query>").description("Search across all records").option(
     "--models <keys>",
     "Filter to specific model keys (comma-separated)"
-  ).option("--limit <n>", "Max results", "20").option("--no-media", "Exclude media results").action(
+  ).option("--limit <n>", "Max results", "20").action(
     withErrorHandler(
       globalOpts,
       async (query, cmdOpts) => {
         const opts = globalOpts();
-        const client = await createClient(opts);
+        const client = await createPlatformClient(opts);
         const modelKeys = typeof cmdOpts.models === "string" ? cmdOpts.models.split(",").map((k) => k.trim()) : void 0;
-        const data = await client.request(GlobalSearchDocument, {
+        const result = await client.records.globalSearch({
           query,
           limit: parseInt(String(cmdOpts.limit ?? "20"), 10),
-          modelKeys,
-          includeMedia: cmdOpts.media !== false
+          modelKeys
         });
         if (opts.json || opts.jsonl) {
-          formatOutput(data.globalSearch, opts);
+          formatOutput(result, opts);
           return;
         }
-        if (data.globalSearch.records.length > 0) {
+        if (result.items.length > 0) {
           console.log(`
-Records (${data.globalSearch.records.length}):`);
+Records (${result.items.length}):`);
           formatList(
-            data.globalSearch.records,
+            result.items.map((item) => ({
+              id: item.id,
+              modelKey: item.modelKey,
+              naturalKey: item.naturalKey ?? "",
+              score: item.score
+            })),
             opts,
             {
               columns: [
                 { key: "id", header: "ID", width: 28 },
                 { key: "modelKey", header: "Model", width: 18 },
-                { key: "title", header: "Title", width: 28 },
                 { key: "naturalKey", header: "Key", width: 20 },
                 {
-                  key: "updatedAt",
-                  header: "Updated",
-                  width: 12,
-                  format: (v) => timeAgo(v)
+                  key: "score",
+                  header: "Score",
+                  width: 8,
+                  format: (v) => Number(v).toFixed(2)
                 }
               ]
             }
           );
-        }
-        if (data.globalSearch.media.length > 0) {
-          console.log(`
-Media (${data.globalSearch.media.length}):`);
-          formatList(
-            data.globalSearch.media,
-            opts,
-            {
-              columns: [
-                { key: "id", header: "ID", width: 28 },
-                { key: "fileName", header: "File", width: 30 },
-                { key: "altText", header: "Alt", width: 24 }
-              ]
-            }
-          );
-        }
-        if (data.globalSearch.records.length === 0 && data.globalSearch.media.length === 0) {
+        } else {
           console.log("No results found.");
         }
       }
@@ -1704,9 +1774,9 @@ Media (${data.globalSearch.media.length}):`);
 // src/commands/init.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { writeFile } from "fs/promises";
-import { resolve as resolve2, join as join4 } from "path";
+import { resolve as resolve3, join as join4 } from "path";
 import chalk5 from "chalk";
-import inquirer3 from "inquirer";
+import inquirer4 from "inquirer";
 var FIELD_DEFAULTS = {
   text: "",
   richtext: "",
@@ -1768,9 +1838,9 @@ function generateRecordSeed(model) {
     )) {
       continue;
     }
-    if (field.type === "list" && field.items) {
+    if (field.type === "list" && field.itemType) {
       data[field.key] = [
-        defaultValueForField({ key: field.key, type: field.items.type })
+        defaultValueForField({ key: field.key, type: field.itemType })
       ];
     } else {
       data[field.key] = defaultValueForField(field);
@@ -1795,7 +1865,7 @@ function registerInitCommands(program2, globalOpts) {
       async (key, opts) => {
         const globalFlags = globalOpts();
         const template = generateModelTemplate(key);
-        const outDir = resolve2(opts.output);
+        const outDir = resolve3(opts.output);
         if (!existsSync3(outDir)) {
           mkdirSync2(outDir, { recursive: true });
         }
@@ -1826,10 +1896,19 @@ Edit the file, then run:
       globalOpts,
       async (opts) => {
         const globalFlags = globalOpts();
-        const client = await createClient(globalFlags);
-        const query = `query { models(limit: 100) { items { key name fields } total } }`;
-        const result = await client.request(query);
-        const models = result.models.items;
+        const client = await createPlatformClient(globalFlags);
+        const result = await client.models.listModels({ limit: 100 });
+        const models = result.items.map((m) => ({
+          key: m.key,
+          name: m.name,
+          fields: (m.fields ?? []).map((f) => ({
+            key: f.key,
+            type: f.type,
+            label: f.label,
+            required: f.required,
+            itemType: f.itemType
+          }))
+        }));
         if (models.length === 0) {
           console.log(
             chalk5.yellow(
@@ -1854,7 +1933,7 @@ Edit the file, then run:
             selectedModels.push(found);
           }
         } else {
-          const { selected } = await inquirer3.prompt([
+          const { selected } = await inquirer4.prompt([
             {
               type: "checkbox",
               name: "selected",
@@ -1873,7 +1952,7 @@ Edit the file, then run:
           console.log("No models selected.");
           return;
         }
-        const outDir = resolve2(opts.output);
+        const outDir = resolve3(opts.output);
         if (!existsSync3(outDir)) {
           mkdirSync2(outDir, { recursive: true });
         }
@@ -1909,64 +1988,12 @@ Edit the files, then run:
 import chalk6 from "chalk";
 import { existsSync as existsSync4 } from "fs";
 import { resolve as resolve4 } from "path";
-
-// src/lib/config-loader.ts
-import { readFile } from "fs/promises";
-import { pathToFileURL } from "url";
-import { resolve as resolve3 } from "path";
-async function loadConfig(filePath) {
-  const absPath = resolve3(filePath);
-  if (filePath.endsWith(".ts")) {
-    const configModule = await import(pathToFileURL(absPath).href);
-    return configModule.default;
-  }
-  if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
-    const configModule = await import(pathToFileURL(absPath).href);
-    return configModule.default;
-  }
-  if (filePath.endsWith(".json")) {
-    const content = await readFile(absPath, "utf-8");
-    return JSON.parse(content);
-  }
-  throw new Error(
-    `Unsupported file extension for "${filePath}". Supported: .ts, .js, .mjs, .json`
-  );
-}
-
-// src/commands/push.ts
 var CONFIG_FILE_NAMES = [
   "foir.config.ts",
   "foir.config.js",
   "foir.config.mjs",
   "foir.config.json"
 ];
-var APPLY_CONFIG_MUTATION = (
-  /* GraphQL */
-  `
-  mutation ApplyConfig($input: ApplyConfigInput!) {
-    applyConfig(input: $input) {
-      configId
-      configKey
-      credentials {
-        platformApiKey
-        platformEditorKey
-        webhookSecret
-      }
-      modelsCreated
-      modelsUpdated
-      operationsCreated
-      operationsUpdated
-      segmentsCreated
-      segmentsUpdated
-      schedulesCreated
-      schedulesUpdated
-      hooksCreated
-      hooksUpdated
-      isUpdate
-    }
-  }
-`
-);
 function discoverConfigFile() {
   for (const name of CONFIG_FILE_NAMES) {
     const path3 = resolve4(process.cwd(), name);
@@ -1991,69 +2018,32 @@ function registerPushCommand(program2, globalOpts) {
         console.log(chalk6.dim(`Loading ${configPath}...`));
         const config2 = await loadConfig(configPath);
         if (!config2?.key || !config2?.name) {
-          throw new Error(
-            'Config must have at least "key" and "name" fields.'
-          );
-        }
-        if (opts.force) {
-          config2.force = true;
-        }
-        const client = await createClient(globalOpts());
-        console.log(
-          chalk6.dim(`Pushing config "${config2.key}" to platform...`)
-        );
-        const data = await client.request(
-          APPLY_CONFIG_MUTATION,
-          { input: config2 }
-        );
-        const result = data.applyConfig;
-        console.log();
-        if (result.isUpdate) {
-          console.log(chalk6.green("Config updated successfully."));
-        } else {
-          console.log(chalk6.green("Config applied successfully."));
-        }
-        console.log();
-        console.log(`  Config ID:  ${chalk6.cyan(result.configId)}`);
-        console.log(`  Config Key: ${chalk6.cyan(result.configKey)}`);
-        console.log();
-        const stats = [
-          ["Models", result.modelsCreated, result.modelsUpdated],
-          ["Operations", result.operationsCreated, result.operationsUpdated],
-          ["Segments", result.segmentsCreated, result.segmentsUpdated],
-          ["Schedules", result.schedulesCreated, result.schedulesUpdated],
-          ["Hooks", result.hooksCreated, result.hooksUpdated]
-        ].filter(([, c, u]) => c > 0 || u > 0);
-        if (stats.length > 0) {
-          for (const [label, created, updated] of stats) {
-            const parts = [];
-            if (created > 0)
-              parts.push(chalk6.green(`${created} created`));
-            if (updated > 0)
-              parts.push(chalk6.yellow(`${updated} updated`));
-            console.log(`  ${label}: ${parts.join(", ")}`);
-          }
-          console.log();
-        }
-        if (result.credentials) {
-          console.log(chalk6.bold.yellow("Credentials (save these now):"));
-          console.log();
-          console.log(
-            `  PLATFORM_API_KEY:    ${chalk6.cyan(result.credentials.platformApiKey)}`
-          );
-          console.log(
-            `  PLATFORM_EDITOR_KEY: ${chalk6.cyan(result.credentials.platformEditorKey)}`
-          );
-          console.log(
-            `  WEBHOOK_SECRET:      ${chalk6.cyan(result.credentials.webhookSecret)}`
+          throw new Error(
+            'Config must have at least "key" and "name" fields.'
           );
-          console.log();
-          console.log(
-            chalk6.dim(
-              "These credentials are only shown once. Store them securely."
-            )
+        }
+        if (opts.force) {
+          config2.force = true;
+        }
+        const client = await createPlatformClient(globalOpts());
+        console.log(
+          chalk6.dim(`Pushing config "${config2.key}" to platform...`)
+        );
+        const result = await client.configs.applyConfig(
+          config2.key,
+          config2
+        );
+        if (!result) {
+          throw new Error(
+            "Failed to apply config \u2014 no response from server."
           );
         }
+        console.log();
+        console.log(chalk6.green("Config applied successfully."));
+        console.log();
+        console.log(`  Config ID:  ${chalk6.cyan(result.id)}`);
+        console.log(`  Config Key: ${chalk6.cyan(result.key)}`);
+        console.log();
       }
     )
   );
@@ -2061,40 +2051,19 @@ function registerPushCommand(program2, globalOpts) {
 
 // src/commands/remove.ts
 import chalk7 from "chalk";
-import inquirer4 from "inquirer";
-var GET_CONFIG_QUERY = (
-  /* GraphQL */
-  `
-  query GetConfigByKey($key: String!) {
-    configByKey(key: $key) {
-      id
-      key
-      name
-      configType
-    }
-  }
-`
-);
-var UNREGISTER_MUTATION = (
-  /* GraphQL */
-  `
-  mutation UnregisterConfig($id: ID!) {
-    unregisterConfig(id: $id)
-  }
-`
-);
+import inquirer5 from "inquirer";
 function registerRemoveCommand(program2, globalOpts) {
   program2.command("remove <key>").description("Remove a config and all its provisioned resources").option("--force", "Skip confirmation prompt", false).action(
     withErrorHandler(
       globalOpts,
       async (key, opts) => {
-        const client = await createClient(globalOpts());
-        const { configByKey: config2 } = await client.request(GET_CONFIG_QUERY, { key });
+        const client = await createPlatformClient(globalOpts());
+        const config2 = await client.configs.getConfigByKey(key);
         if (!config2) {
           throw new Error(`Config not found: ${key}`);
         }
         if (!opts.force) {
-          const { confirmed } = await inquirer4.prompt([
+          const { confirmed } = await inquirer5.prompt([
             {
               type: "confirm",
               name: "confirmed",
@@ -2107,7 +2076,7 @@ function registerRemoveCommand(program2, globalOpts) {
             return;
           }
         }
-        await client.request(UNREGISTER_MUTATION, { id: config2.id });
+        await client.configs.deleteConfig(config2.id);
         console.log(
           chalk7.green(`Removed config "${config2.name}" (${config2.key}).`)
         );
@@ -2118,49 +2087,6 @@ function registerRemoveCommand(program2, globalOpts) {
 
 // src/commands/profiles.ts
 import chalk8 from "chalk";
-
-// src/lib/input.ts
-import inquirer5 from "inquirer";
-async function parseInputData(opts) {
-  if (opts.data) {
-    return JSON.parse(opts.data);
-  }
-  if (opts.file) {
-    return await loadConfig(opts.file);
-  }
-  if (!process.stdin.isTTY) {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    const stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
-    if (stdinContent) {
-      return JSON.parse(stdinContent);
-    }
-  }
-  throw new Error(
-    "No input data provided. Use --data, --file, or pipe via stdin."
-  );
-}
-function isUUID(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
-    value
-  ) || /^c[a-z0-9]{24,}$/.test(value);
-}
-async function confirmAction(message, opts) {
-  if (opts?.confirm) return true;
-  const { confirmed } = await inquirer5.prompt([
-    {
-      type: "confirm",
-      name: "confirmed",
-      message,
-      default: false
-    }
-  ]);
-  return confirmed;
-}
-
-// src/commands/profiles.ts
 function registerProfilesCommand(program2, globalOpts) {
   const profiles = program2.command("profiles").description("Manage named project profiles");
   profiles.command("list").description("List all saved project profiles").action(
@@ -2328,9 +2254,8 @@ function registerProfilesCommand(program2, globalOpts) {
 }
 
 // src/commands/register-commands.ts
-import { readFileSync, readdirSync } from "fs";
-import { resolve as resolve5, dirname as dirname4 } from "path";
-import { fileURLToPath } from "url";
+import { readdirSync } from "fs";
+import { resolve as resolve5 } from "path";
 import chalk9 from "chalk";
 
 // ../command-registry/src/command-map.ts
@@ -3108,68 +3033,6 @@ var COMMANDS = [
     successMessage: "Updated customer profile"
   },
   // =========================================================================
-  // FILES
-  // =========================================================================
-  {
-    group: "files",
-    name: "list",
-    description: "List files",
-    operation: "files",
-    operationType: "query",
-    columns: [
-      { key: "id", header: "ID", width: 28 },
-      { key: "filename", header: "Filename", width: 24 },
-      { key: "mimeType", header: "Type", width: 16 },
-      { key: "size", header: "Size", width: 10, format: "bytes" },
-      { key: "folder", header: "Folder", width: 16 },
-      { key: "createdAt", header: "Created", width: 12, format: "timeAgo" }
-    ]
-  },
-  {
-    group: "files",
-    name: "get",
-    description: "Get a file",
-    operation: "file",
-    operationType: "query",
-    positionalArgs: [{ name: "id", graphqlArg: "id" }]
-  },
-  {
-    group: "files",
-    name: "usage",
-    description: "Get file storage usage",
-    operation: "fileStorageUsage",
-    operationType: "query"
-  },
-  {
-    group: "files",
-    name: "update",
-    description: "Update a file",
-    operation: "updateFile",
-    operationType: "mutation",
-    positionalArgs: [{ name: "id", graphqlArg: "id" }],
-    successMessage: "Updated file"
-  },
-  {
-    group: "files",
-    name: "update-metadata",
-    description: "Update file metadata",
-    operation: "updateFileMetadata",
-    operationType: "mutation",
-    positionalArgs: [{ name: "id", graphqlArg: "id" }],
-    successMessage: "Updated file metadata"
-  },
-  {
-    group: "files",
-    name: "delete",
-    description: "Delete a file",
-    operation: "deleteFile",
-    operationType: "mutation",
-    positionalArgs: [{ name: "id", graphqlArg: "id" }],
-    requiresConfirmation: true,
-    scalarResult: true,
-    successMessage: "Deleted file"
-  },
-  // =========================================================================
   // OPERATIONS
   // =========================================================================
   {
@@ -3737,230 +3600,397 @@ var COMMANDS = [
   }
 ];
 
-// ../command-registry/src/schema-engine.ts
-import {
-  buildSchema,
-  isObjectType,
-  isInputObjectType,
-  isListType,
-  isNonNullType,
-  isScalarType,
-  isEnumType
-} from "graphql";
-function unwrapType(type) {
-  if (isNonNullType(type)) return unwrapType(type.ofType);
-  if (isListType(type)) return unwrapType(type.ofType);
-  return type;
-}
-function typeToString(type) {
-  if (isNonNullType(type)) return `${typeToString(type.ofType)}!`;
-  if (isListType(type)) return `[${typeToString(type.ofType)}]`;
-  return type.name;
-}
-function detectListWrapper(type) {
-  if (!isObjectType(type)) return null;
-  const fields = type.getFields();
-  const fieldNames = Object.keys(fields);
-  let listField = null;
-  let totalField = null;
-  let itemType = null;
-  for (const name of fieldNames) {
-    const fieldType = fields[name].type;
-    const unwrapped = isNonNullType(fieldType) ? fieldType.ofType : fieldType;
-    if (isListType(unwrapped) || isNonNullType(unwrapped) && isListType(unwrapped)) {
-      listField = name;
-      itemType = unwrapType(fieldType);
-    } else {
-      const namedType = unwrapType(fieldType);
-      if (namedType.name === "Int" && (name === "total" || name === "totalCount")) {
-        totalField = name;
-      }
-    }
-  }
-  if (listField && totalField && itemType) {
-    return { listField, itemType };
-  }
-  return null;
-}
-function buildSelectionSet(type, isListView, depth = 0) {
-  if (!isObjectType(type)) return "";
-  const fields = type.getFields();
-  const selections = [];
-  for (const [name, field] of Object.entries(fields)) {
-    const namedType = unwrapType(field.type);
-    if (isScalarType(namedType)) {
-      if (isListView && namedType.name === "JSON") continue;
-      selections.push(name);
-    } else if (isEnumType(namedType)) {
-      selections.push(name);
-    } else if (isObjectType(namedType) && depth === 0 && !isListView) {
-      const subSelection = buildSelectionSet(namedType, false, depth + 1);
-      if (subSelection) {
-        selections.push(`${name} { ${subSelection} }`);
-      }
-    }
-  }
-  return selections.join(" ");
-}
-function createSchemaEngine(sdl) {
-  const schema = buildSchema(sdl);
-  function getField(operationName, operationType) {
-    const rootType = operationType === "query" ? schema.getQueryType() : schema.getMutationType();
-    if (!rootType) return null;
-    const fields = rootType.getFields();
-    return fields[operationName] ?? null;
-  }
-  function getOperationArgs(operationName, operationType) {
-    const field = getField(operationName, operationType);
-    if (!field) return [];
-    return field.args.map((arg) => {
-      const namedType = unwrapType(arg.type);
-      const rawType = isNonNullType(arg.type) ? arg.type.ofType : arg.type;
-      return {
-        name: arg.name,
-        type: typeToString(arg.type),
-        required: isNonNullType(arg.type),
-        isList: isListType(rawType) || isNonNullType(rawType) && isListType(rawType.ofType),
-        isInput: namedType.name.endsWith("Input")
-      };
-    });
-  }
-  function coerceArgs(operationName, operationType, rawArgs) {
-    const field = getField(operationName, operationType);
-    if (!field) return rawArgs;
-    const coerced = {};
-    const argMap = new Map(field.args.map((a) => [a.name, a]));
-    for (const [key, value] of Object.entries(rawArgs)) {
-      const argDef = argMap.get(key);
-      if (!argDef) {
-        coerced[key] = value;
-        continue;
+// src/commands/register-commands.ts
+import { RecordType } from "@foir/connect-clients/records";
+function buildDispatchTable() {
+  return {
+    // ── Models ──────────────────────────────────────────────────
+    models: {
+      models: async (_v, c) => wrapList(
+        await c.models.listModels({
+          limit: num(_v.limit, 50),
+          search: str(_v.search),
+          category: str(_v.category),
+          offset: num(_v.offset, 0)
+        })
+      ),
+      modelByKey: async (v, c) => await c.models.getModelByKey(str(v.key)),
+      model: async (v, c) => await c.models.getModel(str(v.id)),
+      createModel: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required (--data or --file)");
+        return await c.models.createModel({
+          key: str(input.key),
+          name: str(input.name),
+          fields: input.fields ?? [],
+          config: input.config,
+          configId: str(input.configId)
+        });
+      },
+      updateModel: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required (--data or --file)");
+        return await c.models.updateModel({
+          id: str(input.id ?? v.id),
+          name: str(input.name),
+          fields: input.fields,
+          config: input.config,
+          changeDescription: str(input.changeDescription)
+        });
+      },
+      deleteModel: async (v, c) => await c.models.deleteModel(str(v.id)),
+      modelVersions: async (v, c) => wrapList(
+        await c.models.listModelVersions(str(v.modelId), {
+          limit: num(v.limit, 50)
+        })
+      )
+    },
+    // ── Records ─────────────────────────────────────────────────
+    records: {
+      records: async (v, c) => wrapList(
+        await c.records.listRecords({
+          modelKey: str(v.modelKey),
+          limit: num(v.limit, 50),
+          offset: num(v.offset, 0),
+          search: str(v.search)
+        })
+      ),
+      record: async (v, c) => await c.records.getRecord(str(v.id)),
+      recordByKey: async (v, c) => await c.records.getRecordByKey(str(v.modelKey), str(v.naturalKey)),
+      createRecord: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required (--data or --file)");
+        return await c.records.createRecord({
+          modelKey: str(input.modelKey),
+          naturalKey: str(input.naturalKey),
+          data: input.data,
+          customerId: str(input.customerId),
+          changeDescription: str(input.changeDescription)
+        });
+      },
+      updateRecord: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required (--data or --file)");
+        return await c.records.updateRecord({
+          id: str(input.id ?? v.id),
+          data: input.data ?? input,
+          naturalKey: str(input.naturalKey)
+        });
+      },
+      deleteRecord: async (v, c) => await c.records.deleteRecord(str(v.id)),
+      publishVersion: async (v, c) => await c.records.publishVersion(str(v.versionId)),
+      unpublishRecord: async (v, c) => await c.records.unpublishRecord(str(v.id)),
+      duplicateRecord: async (v, c) => {
+        const input = v.input;
+        return await c.records.duplicateRecord(
+          str(input?.id ?? v.id),
+          str(input?.newNaturalKey)
+        );
+      },
+      recordVersions: async (v, c) => wrapList(
+        await c.records.listRecordVersions(str(v.parentId), {
+          limit: num(v.limit, 50)
+        })
+      ),
+      recordVariants: async (v, c) => wrapList(
+        await c.records.listRecordVariants(str(v.recordId), {
+          limit: num(v.limit, 50)
+        })
+      ),
+      createVersion: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required (--data or --file)");
+        return await c.records.createVersion(
+          str(input.parentId),
+          input.data,
+          str(input.changeDescription)
+        );
+      },
+      createVariant: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required (--data or --file)");
+        return await c.records.createVariant(
+          str(input.recordId),
+          str(input.variantKey),
+          input.data
+        );
       }
-      const namedType = unwrapType(argDef.type);
-      switch (namedType.name) {
-        case "Int":
-          coerced[key] = parseInt(value, 10);
-          break;
-        case "Float":
-          coerced[key] = parseFloat(value);
-          break;
-        case "Boolean":
-          coerced[key] = value === "true" || value === "1";
-          break;
-        case "JSON":
-          try {
-            coerced[key] = JSON.parse(value);
-          } catch {
-            coerced[key] = value;
-          }
-          break;
-        default:
-          coerced[key] = value;
+    },
+    // ── Locales ─────────────────────────────────────────────────
+    locales: {
+      locales: async (v, c) => {
+        const resp = await c.settings.listLocales({ limit: num(v.limit, 50) });
+        return { items: resp.locales ?? [], total: resp.total ?? 0 };
+      },
+      locale: async (v, c) => await c.settings.getLocale(str(v.id)),
+      createLocale: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.settings.createLocale({
+          locale: str(input.locale),
+          displayName: str(input.displayName),
+          nativeName: str(input.nativeName),
+          isDefault: input.isDefault,
+          isRtl: input.isRtl,
+          fallbackLocale: str(input.fallbackLocale)
+        });
+      },
+      updateLocale: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.settings.updateLocale({
+          id: str(input.id ?? v.id),
+          displayName: str(input.displayName),
+          nativeName: str(input.nativeName),
+          isDefault: input.isDefault,
+          isActive: input.isActive,
+          isRtl: input.isRtl,
+          fallbackLocale: str(input.fallbackLocale)
+        });
+      },
+      deleteLocale: async (v, c) => await c.settings.deleteLocale(str(v.id))
+    },
+    // ── Segments ────────────────────────────────────────────────
+    segments: {
+      segments: async (v, c) => {
+        const resp = await c.segments.listSegments({ limit: num(v.limit, 50) });
+        return { items: resp.segments ?? [], total: resp.total ?? 0 };
+      },
+      segment: async (v, c) => await c.segments.getSegment(str(v.id)),
+      segmentByKey: async (v, c) => await c.segments.getSegmentByKey(str(v.key)),
+      createSegment: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.segments.createSegment({
+          key: str(input.key),
+          name: str(input.name),
+          description: str(input.description),
+          rules: input.rules,
+          evaluationMode: str(input.evaluationMode),
+          isActive: input.isActive
+        });
+      },
+      updateSegment: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.segments.updateSegment({
+          id: str(input.id ?? v.id),
+          name: str(input.name),
+          description: str(input.description),
+          rules: input.rules,
+          evaluationMode: str(input.evaluationMode),
+          isActive: input.isActive
+        });
+      },
+      deleteSegment: async (v, c) => await c.segments.deleteSegment(str(v.id)),
+      previewSegmentRules: async (v, c) => {
+        const input = v.rules;
+        return await c.segments.previewSegmentRules(input);
+      },
+      testSegmentEvaluation: async (v, c) => await c.segments.testSegmentEvaluation(
+        str(v.segmentId),
+        str(v.customerId)
+      )
+    },
+    // ── Experiments ─────────────────────────────────────────────
+    experiments: {
+      experiments: async (v, c) => {
+        const resp = await c.experiments.listExperiments({
+          limit: num(v.limit, 50)
+        });
+        return { items: resp.experiments ?? [], total: resp.total ?? 0 };
+      },
+      experiment: async (v, c) => await c.experiments.getExperiment(str(v.id)),
+      experimentByKey: async (v, c) => await c.experiments.getExperimentByKey(str(v.key)),
+      createExperiment: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.experiments.createExperiment({
+          key: str(input.key),
+          name: str(input.name),
+          description: str(input.description),
+          targeting: input.targeting,
+          controlPercent: input.controlPercent,
+          variants: input.variants
+        });
+      },
+      updateExperiment: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.experiments.updateExperiment({
+          id: str(input.id ?? v.id),
+          name: str(input.name),
+          description: str(input.description),
+          targeting: input.targeting,
+          controlPercent: input.controlPercent,
+          variants: input.variants
+        });
+      },
+      deleteExperiment: async (v, c) => await c.experiments.deleteExperiment(str(v.id)),
+      startExperiment: async (v, c) => await c.experiments.startExperiment(str(v.experimentId)),
+      pauseExperiment: async (v, c) => await c.experiments.pauseExperiment(str(v.experimentId)),
+      resumeExperiment: async (v, c) => await c.experiments.resumeExperiment(str(v.experimentId)),
+      endExperiment: async (v, c) => await c.experiments.endExperiment(str(v.experimentId)),
+      experimentStats: async (v, c) => await c.experiments.getExperimentStats(str(v.experimentId))
+    },
+    // ── Settings ────────────────────────────────────────────────
+    settings: {
+      allSettings: async (v, c) => await c.settings.getSettings({
+        category: str(v.category),
+        key: str(v.key)
+      }),
+      setting: async (v, c) => {
+        const settings = await c.settings.getSettings({ key: str(v.key) });
+        return settings[0] ?? null;
+      },
+      setSetting: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.settings.updateSetting({
+          key: str(input.key),
+          value: input.value ?? input
+        });
       }
-    }
-    return coerced;
-  }
-  function buildQuery(entry, variables) {
-    const field = getField(entry.operation, entry.operationType);
-    if (!field) {
-      throw new Error(
-        `Operation "${entry.operation}" not found in schema ${entry.operationType} type`
-      );
-    }
-    const opType = entry.operationType === "query" ? "query" : "mutation";
-    const opName = entry.operation.charAt(0).toUpperCase() + entry.operation.slice(1);
-    const usedArgs = [];
-    for (const argDef of field.args) {
-      const isPositional = entry.positionalArgs?.some(
-        (p) => p.graphqlArg === argDef.name
-      );
-      const isInputArg = entry.acceptsInput && argDef.name === (entry.inputArgName ?? "input");
-      if (isPositional || isInputArg || variables[argDef.name] !== void 0) {
-        usedArgs.push({ argDef, varName: argDef.name });
+    },
+    // ── API Keys ────────────────────────────────────────────────
+    "api-keys": {
+      listApiKeys: async (v, c) => wrapList(await c.identity.listApiKeys({ limit: num(v.limit, 50) })),
+      createApiKey: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.identity.createApiKey({
+          name: str(input.name),
+          keyType: input.keyType,
+          rateLimitPerHour: input.rateLimitPerHour
+        });
+      },
+      rotateApiKey: async (v, c) => await c.identity.rotateApiKey(str(v.id)),
+      revokeApiKey: async (v, c) => await c.identity.revokeApiKey(str(v.id))
+    },
+    // ── Auth Providers ──────────────────────────────────────────
+    "auth-providers": {
+      customerAuthProviders: async (v, c) => {
+        const resp = await c.identity.listAuthProviders({
+          limit: num(v.limit, 50)
+        });
+        return { items: resp.items, total: resp.total };
+      },
+      customerAuthProvider: async (v, c) => await c.identity.getAuthProvider(str(v.id)),
+      createCustomerAuthProvider: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.identity.createAuthProvider({
+          key: str(input.key),
+          name: str(input.name),
+          type: str(input.type),
+          config: input.config,
+          enabled: input.enabled,
+          isDefault: input.isDefault,
+          priority: input.priority
+        });
+      },
+      updateCustomerAuthProvider: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.identity.updateAuthProvider({
+          id: str(input.id ?? v.id),
+          name: str(input.name),
+          config: input.config,
+          enabled: input.enabled,
+          isDefault: input.isDefault,
+          priority: input.priority
+        });
+      },
+      deleteCustomerAuthProvider: async (v, c) => await c.identity.deleteAuthProvider(str(v.id))
+    },
+    // ── Configs ─────────────────────────────────────────────────
+    configs: {
+      configs: async (v, c) => {
+        const resp = await c.configs.listConfigs({ limit: num(v.limit, 50) });
+        return { items: resp.configs ?? [], total: resp.total ?? 0 };
+      },
+      config: async (v, c) => await c.configs.getConfig(str(v.id)),
+      configByKey: async (v, c) => await c.configs.getConfigByKey(str(v.key)),
+      registerConfig: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.configs.createConfig({
+          key: str(input.key),
+          configType: str(input.configType),
+          name: str(input.name),
+          description: str(input.description),
+          config: input.config,
+          enabled: input.enabled,
+          direction: str(input.direction)
+        });
+      },
+      applyConfig: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        return await c.configs.applyConfig(
+          str(input.key ?? input.configKey),
+          input
+        );
+      },
+      unregisterConfig: async (v, c) => await c.configs.deleteConfig(str(v.id)),
+      triggerConfigSync: async (v, _c) => {
+        console.log(
+          chalk9.yellow(
+            `Config sync trigger for ${str(v.configId)} is not yet available via ConnectRPC.`
+          )
+        );
+        return { success: false };
       }
-    }
-    const varDecls = usedArgs.map((a) => `$${a.varName}: ${typeToString(a.argDef.type)}`).join(", ");
-    const fieldArgs = usedArgs.map((a) => `${a.argDef.name}: $${a.varName}`).join(", ");
-    const returnType = unwrapType(field.type);
-    let selectionSet = "";
-    if (isScalarType(returnType) || isEnumType(returnType)) {
-      selectionSet = "";
-    } else if (isObjectType(returnType)) {
-      const wrapper = detectListWrapper(returnType);
-      if (wrapper) {
-        const itemSelection = buildSelectionSet(wrapper.itemType, true);
-        selectionSet = `{ ${wrapper.listField} { ${itemSelection} } total }`;
-      } else {
-        const selection = buildSelectionSet(returnType, false);
-        selectionSet = selection ? `{ ${selection} }` : "";
+    },
+    // ── Customers ───────────────────────────────────────────────
+    customers: {
+      customers: async (v, c) => wrapList(
+        await c.identity.listCustomers({
+          limit: num(v.limit, 50),
+          search: str(v.search)
+        })
+      ),
+      customer: async (v, c) => {
+        const result = await c.identity.getCustomer(str(v.id));
+        return result.customer;
+      },
+      createCustomer: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        const result = await c.identity.createCustomer({
+          email: str(input.email),
+          password: str(input.password)
+        });
+        return result.customer;
+      },
+      updateCustomer: async (v, c) => {
+        const input = v.input;
+        if (!input) throw new Error("Input required");
+        const result = await c.identity.updateCustomer({
+          id: str(input.id ?? v.id),
+          email: str(input.email),
+          status: input.status
+        });
+        return result.customer;
+      },
+      deleteCustomer: async (v, c) => await c.identity.deleteCustomer(str(v.id)),
+      suspendCustomer: async (v, c) => {
+        const result = await c.identity.suspendCustomer(str(v.id));
+        return result.customer;
       }
     }
-    const varPart = varDecls ? `(${varDecls})` : "";
-    const argPart = fieldArgs ? `(${fieldArgs})` : "";
-    return `${opType} ${opName}${varPart} { ${entry.operation}${argPart} ${selectionSet} }`;
-  }
-  function getInputFields(operationName, operationType, inputArgName) {
-    const field = getField(operationName, operationType);
-    if (!field) return [];
-    const argName = inputArgName ?? "input";
-    const arg = field.args.find((a) => a.name === argName);
-    if (!arg) return [];
-    const namedType = unwrapType(arg.type);
-    if (!isInputObjectType(namedType)) return [];
-    const fields = namedType.getFields();
-    return Object.entries(fields).map(([name, f]) => ({
-      name,
-      type: typeToString(f.type),
-      required: isNonNullType(f.type)
-    }));
-  }
-  function getCompletions(partial, commandNames) {
-    return commandNames.filter(
-      (name) => name.toLowerCase().startsWith(partial.toLowerCase())
-    );
-  }
-  return {
-    buildQuery,
-    getOperationArgs,
-    coerceArgs,
-    getInputFields,
-    getCompletions
   };
 }
-
-// src/commands/register-commands.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname4(__filename);
-function loadSchemaSDL() {
-  const bundledPath = resolve5(__dirname, "schema.graphql");
-  try {
-    return readFileSync(bundledPath, "utf-8");
-  } catch {
-    const monorepoPath = resolve5(
-      __dirname,
-      "../../../graphql-core/schema.graphql"
-    );
-    try {
-      return readFileSync(monorepoPath, "utf-8");
-    } catch {
-      throw new Error(
-        "Could not find schema.graphql. Try reinstalling @eide/foir-cli."
-      );
-    }
-  }
+function str(v) {
+  return v != null ? String(v) : void 0;
 }
-function extractResult(result, operationName) {
-  const raw = result[operationName];
-  if (!raw || typeof raw !== "object") return { data: raw };
-  const obj = raw;
-  if ("total" in obj) {
-    for (const [key, val] of Object.entries(obj)) {
-      if (key !== "total" && key !== "__typename" && Array.isArray(val)) {
-        return { data: val, total: obj.total };
-      }
-    }
-  }
-  return { data: raw };
+function num(v, fallback) {
+  if (v == null) return fallback;
+  const n = Number(v);
+  return Number.isNaN(n) ? fallback : n;
+}
+function wrapList(result) {
+  return result;
 }
 function toCliColumns(columns) {
   if (!columns) return void 0;
@@ -3979,8 +4009,8 @@ function toCliColumns(columns) {
         break;
       case "truncate":
         cliCol.format = (v) => {
-          const str = String(v ?? "");
-          return str.length > 40 ? str.slice(0, 39) + "\u2026" : str;
+          const s = String(v ?? "");
+          return s.length > 40 ? s.slice(0, 39) + "\u2026" : s;
         };
         break;
       case "join":
@@ -3988,27 +4018,37 @@ function toCliColumns(columns) {
         break;
       case "bytes":
         cliCol.format = (v) => {
-          const num = Number(v);
-          if (num < 1024) return `${num} B`;
-          if (num < 1024 * 1024) return `${(num / 1024).toFixed(1)} KB`;
-          return `${(num / (1024 * 1024)).toFixed(1)} MB`;
+          const n = Number(v);
+          if (n < 1024) return `${n} B`;
+          if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+          return `${(n / (1024 * 1024)).toFixed(1)} MB`;
         };
         break;
     }
     return cliCol;
   });
 }
-function registerDynamicCommands(program2, globalOpts) {
-  let engine;
-  try {
-    const sdl = loadSchemaSDL();
-    engine = createSchemaEngine(sdl);
-  } catch (err) {
-    console.error(
-      `Warning: Could not load schema for dynamic commands: ${err instanceof Error ? err.message : String(err)}`
+function autoColumns(items) {
+  if (items.length === 0) return [];
+  const first = items[0];
+  return Object.keys(first).filter((k) => k !== "__typename" && k !== "$typeName" && k !== "$unknown").slice(0, 6).map((key) => ({
+    key,
+    header: key,
+    width: 20
+  }));
+}
+var DISPATCH = buildDispatchTable();
+async function executeCommand(entry, variables, client) {
+  const groupHandlers = DISPATCH[entry.group];
+  const handler = groupHandlers?.[entry.operation];
+  if (!handler) {
+    throw new Error(
+      `Command not yet migrated to ConnectRPC: ${entry.group}.${entry.operation}`
     );
-    return;
   }
+  return handler(variables, client);
+}
+function registerDynamicCommands(program2, globalOpts) {
   const groups = /* @__PURE__ */ new Map();
   for (const cmd of COMMANDS) {
     if (!groups.has(cmd.group)) groups.set(cmd.group, []);
@@ -4017,42 +4057,15 @@ function registerDynamicCommands(program2, globalOpts) {
   for (const [groupName, entries] of groups) {
     const group = program2.command(groupName).description(`Manage ${groupName}`);
     for (const entry of entries) {
+      if (!DISPATCH[entry.group]?.[entry.operation]) continue;
       let cmd = group.command(entry.name).description(entry.description);
       for (const pos of entry.positionalArgs ?? []) {
         cmd = cmd.argument(`<${pos.name}>`, pos.description ?? pos.name);
       }
-      const schemaArgs = engine.getOperationArgs(
-        entry.operation,
-        entry.operationType
-      );
-      for (const arg of schemaArgs) {
-        if (entry.positionalArgs?.some((p) => p.graphqlArg === arg.name))
-          continue;
-        if (entry.acceptsInput && arg.name === (entry.inputArgName ?? "input"))
-          continue;
-        const reqStr = arg.required ? " (required)" : "";
-        cmd = cmd.option(`--${arg.name} <value>`, `${arg.name}${reqStr}`);
-      }
+      cmd = cmd.option("--limit <n>", "Max results");
       if (entry.acceptsInput) {
         cmd = cmd.option("-d, --data <json>", "Data as JSON");
         cmd = cmd.option("-f, --file <path>", "Read data from file");
-        const inputFields = engine.getInputFields(
-          entry.operation,
-          entry.operationType,
-          entry.inputArgName
-        );
-        if (inputFields.length > 0) {
-          const required = inputFields.filter((f) => f.required);
-          const optional = inputFields.filter((f) => !f.required);
-          let fieldHelp = "\nInput fields:";
-          if (required.length > 0) {
-            fieldHelp += "\n  Required: " + required.map((f) => `${f.name} (${f.type})`).join(", ");
-          }
-          if (optional.length > 0) {
-            fieldHelp += "\n  Optional: " + optional.map((f) => `${f.name} (${f.type})`).join(", ");
-          }
-          cmd = cmd.addHelpText("after", fieldHelp);
-        }
       }
       for (const cf of entry.customFlags ?? []) {
         cmd = cmd.option(cf.flag, cf.description);
@@ -4063,7 +4076,7 @@ function registerDynamicCommands(program2, globalOpts) {
       cmd.action(
         withErrorHandler(globalOpts, async (...actionArgs) => {
           const opts = globalOpts();
-          const client = await createClient(opts);
+          const client = await createPlatformClient(opts);
           const variables = {};
           const positionals = entry.positionalArgs ?? [];
           for (let i = 0; i < positionals.length; i++) {
@@ -4076,27 +4089,27 @@ function registerDynamicCommands(program2, globalOpts) {
           const flags = actionArgs[positionals.length] ?? {};
           const customFlagNames = new Set(
             (entry.customFlags ?? []).map(
-              (cf) => cf.flag.replace(/ <.*>$/, "").replace(/^--/, "").replace(/-([a-z])/g, (_, c) => c.toUpperCase())
+              (cf) => cf.flag.replace(/ <.*>$/, "").replace(/^--/, "").replace(/-([a-z])/g, (_, ch) => ch.toUpperCase())
             )
           );
-          const rawFlags = {};
           for (const [key, val] of Object.entries(flags)) {
-            if (key === "data" || key === "file" || key === "confirm") continue;
-            if (customFlagNames.has(key)) continue;
-            rawFlags[key] = String(val);
+            if (key === "data" || key === "file" || key === "confirm" || key === "limit")
+              continue;
+            if (customFlagNames.has(key)) {
+              variables[key] = val;
+              continue;
+            }
+            variables[key] = val;
+          }
+          if (flags.limit) {
+            variables.limit = flags.limit;
           }
-          const coerced = engine.coerceArgs(
-            entry.operation,
-            entry.operationType,
-            rawFlags
-          );
-          Object.assign(variables, coerced);
           if (flags.dir && entry.acceptsInput) {
             const dirPath = resolve5(String(flags.dir));
             const files = readdirSync(dirPath).filter((f) => /\.(json|ts|js|mjs)$/.test(f)).sort();
             if (files.length === 0) {
               console.error(
-                chalk9.yellow(`\u26A0 No .json/.ts/.js files found in ${dirPath}`)
+                chalk9.yellow(`No .json/.ts/.js files found in ${dirPath}`)
               );
               return;
             }
@@ -4110,8 +4123,7 @@ function registerDynamicCommands(program2, globalOpts) {
               const fileVars = { ...variables, [argName]: fileData };
               const label = fileData.key ?? fileData.name ?? file;
               try {
-                const q = engine.buildQuery(entry, fileVars);
-                await client.request(q, fileVars);
+                await executeCommand(entry, fileVars, client);
                 created++;
                 if (!(opts.json || opts.jsonl || opts.quiet)) {
                   success(`Created ${label}`);
@@ -4130,8 +4142,7 @@ function registerDynamicCommands(program2, globalOpts) {
                           [updateEntry.positionalArgs[0].graphqlArg]: fileData.key
                         } : {}
                       };
-                      const uq = engine.buildQuery(updateEntry, updateVars);
-                      await client.request(uq, updateVars);
+                      await executeCommand(updateEntry, updateVars, client);
                       updated++;
                       if (!(opts.json || opts.jsonl || opts.quiet)) {
                         success(`Updated ${label}`);
@@ -4165,19 +4176,13 @@ function registerDynamicCommands(program2, globalOpts) {
               data: flags.data,
               file: flags.file
             });
-            const inputFields = engine.getInputFields(
-              entry.operation,
-              entry.operationType,
-              entry.inputArgName
-            );
-            const fieldNames = new Set(inputFields.map((f) => f.name));
-            if (fieldNames.has("projectId") && !inputData.projectId || fieldNames.has("tenantId") && !inputData.tenantId) {
+            if (!inputData.projectId || !inputData.tenantId) {
               const resolved = await resolveProjectContext(opts);
               if (resolved) {
-                if (fieldNames.has("projectId") && !inputData.projectId) {
+                if (!inputData.projectId) {
                   inputData.projectId = resolved.project.id;
                 }
-                if (fieldNames.has("tenantId") && !inputData.tenantId) {
+                if (!inputData.tenantId) {
                   inputData.tenantId = resolved.project.tenantId;
                 }
               }
@@ -4208,12 +4213,7 @@ function registerDynamicCommands(program2, globalOpts) {
               if (flags.modelKey) {
                 variables.modelKey = String(flags.modelKey);
               }
-              const queryStr2 = engine.buildQuery(altEntry, variables);
-              const result2 = await client.request(
-                queryStr2,
-                variables
-              );
-              const { data: data2 } = extractResult(result2, altEntry.operation);
+              const data2 = await executeCommand(altEntry, variables, client);
               formatOutput(data2, opts);
               return;
             }
@@ -4230,13 +4230,10 @@ function registerDynamicCommands(program2, globalOpts) {
           if (entry.group === "records" && entry.name === "publish" && variables.versionId) {
             const versionIdValue = String(variables.versionId);
             if (flags.modelKey) {
-              const modelKey = String(flags.modelKey);
-              const lookupQuery = `query RecordByKey($modelKey: String!, $naturalKey: String!) { recordByKey(modelKey: $modelKey, naturalKey: $naturalKey) { id currentVersionId } }`;
-              const lookupResult = await client.request(lookupQuery, {
-                modelKey,
-                naturalKey: versionIdValue
-              });
-              const record = lookupResult.recordByKey;
+              const record = await client.records.getRecordByKey(
+                String(flags.modelKey),
+                versionIdValue
+              );
               if (!record?.currentVersionId) {
                 throw new Error(
                   `No current version found for record "${versionIdValue}"`
@@ -4249,23 +4246,18 @@ function registerDynamicCommands(program2, globalOpts) {
               );
             } else {
               try {
-                const lookupQuery = `query Record($id: ID!) { record(id: $id) { id recordType currentVersionId } }`;
-                const lookupResult = await client.request(lookupQuery, {
-                  id: versionIdValue
-                });
-                const record = lookupResult.record;
-                if (record?.recordType === "record" && record?.currentVersionId) {
+                const record = await client.records.getRecord(versionIdValue);
+                if (record?.recordType === RecordType.RECORD && record?.currentVersionId) {
                   variables.versionId = record.currentVersionId;
                 }
               } catch {
               }
             }
           }
-          const queryStr = engine.buildQuery(entry, variables);
-          let result;
+          let data;
           let usedUpdate = false;
           try {
-            result = await client.request(queryStr, variables);
+            data = await executeCommand(entry, variables, client);
           } catch (createErr) {
             if (flags.upsert && entry.name === "create") {
               const updateEntry = COMMANDS.find(
@@ -4281,8 +4273,7 @@ function registerDynamicCommands(program2, globalOpts) {
                     [updateEntry.positionalArgs[0].graphqlArg]: inputData.key
                   } : {}
                 };
-                const uq = engine.buildQuery(updateEntry, updateVars);
-                result = await client.request(uq, updateVars);
+                data = await executeCommand(updateEntry, updateVars, client);
                 usedUpdate = true;
               } else {
                 throw createErr;
@@ -4294,8 +4285,14 @@ function registerDynamicCommands(program2, globalOpts) {
           const activeEntry = usedUpdate ? COMMANDS.find(
             (c) => c.group === entry.group && c.name === "update"
           ) ?? entry : entry;
-          const { data, total } = extractResult(result, activeEntry.operation);
-          const responseData = data && typeof data === "object" && !Array.isArray(data) ? data : void 0;
+          let displayData = data;
+          let total;
+          if (data && typeof data === "object" && "items" in data) {
+            const listResult = data;
+            displayData = listResult.items;
+            total = listResult.total;
+          }
+          const responseData = displayData && typeof displayData === "object" && !Array.isArray(displayData) ? displayData : void 0;
           const displayEntry = usedUpdate ? activeEntry : entry;
           if (displayEntry.scalarResult) {
             if (!(opts.json || opts.jsonl || opts.quiet)) {
@@ -4303,16 +4300,16 @@ function registerDynamicCommands(program2, globalOpts) {
                 success(displayEntry.successMessage, responseData);
               }
             } else {
-              formatOutput(data, opts);
+              formatOutput(displayData, opts);
             }
-          } else if (Array.isArray(data)) {
+          } else if (Array.isArray(displayData)) {
             const cliColumns = toCliColumns(displayEntry.columns);
-            formatList(data, opts, {
-              columns: cliColumns ?? autoColumns(data),
+            formatList(displayData, opts, {
+              columns: cliColumns ?? autoColumns(displayData),
               total
             });
           } else {
-            formatOutput(data, opts);
+            formatOutput(displayData, opts);
             if (displayEntry.successMessage && !(opts.json || opts.jsonl || opts.quiet)) {
               success(displayEntry.successMessage, responseData);
             }
@@ -4322,15 +4319,14 @@ function registerDynamicCommands(program2, globalOpts) {
             const record = responseData.record;
             const versionId = version2?.id ?? record?.currentVersionId;
             if (versionId) {
-              const publishQuery = `mutation PublishVersion($versionId: ID!) { publishVersion(versionId: $versionId) }`;
-              await client.request(publishQuery, { versionId });
+              await client.records.publishVersion(versionId);
               if (!(opts.json || opts.jsonl || opts.quiet)) {
                 success("Published version {id}", { id: versionId });
               }
             } else if (!(opts.json || opts.jsonl || opts.quiet)) {
               console.error(
                 chalk9.yellow(
-                  "\u26A0 Could not auto-publish: no version found in response"
+                  "Could not auto-publish: no version found in response"
                 )
               );
             }
@@ -4340,20 +4336,11 @@ function registerDynamicCommands(program2, globalOpts) {
     }
   }
 }
-function autoColumns(items) {
-  if (items.length === 0) return [];
-  const first = items[0];
-  return Object.keys(first).filter((k) => k !== "__typename").slice(0, 6).map((key) => ({
-    key,
-    header: key,
-    width: 20
-  }));
-}
 
 // src/cli.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname5(__filename2);
-config({ path: resolve6(__dirname2, "../.env.local") });
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname4(__filename);
+config({ path: resolve6(__dirname, "../.env.local") });
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var program = new Command();