@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/entities-3JIHDIOK.js

@@ -0,0 +1,361 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  paramNumber,
+  paramString,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/entities.ts
+import {
+  accountAdd,
+  accountList,
+  accountRemove,
+  modelQuery,
+  modelShow,
+  profileCreate,
+  profileList,
+  profilePin,
+  profileUse,
+  providerConnect,
+  providerList,
+  providerShow
+} from "@cleocode/core/internal";
+async function runEntityOp(op, gateway, domain, operation, startTime) {
+  try {
+    return wrapResult(await op(), gateway, domain, operation, startTime);
+  } catch (err) {
+    return wrapResult(
+      {
+        success: false,
+        error: { code: "E_INTERNAL", message: err instanceof Error ? err.message : String(err) }
+      },
+      gateway,
+      domain,
+      operation,
+      startTime
+    );
+  }
+}
+function authTypeOf(params) {
+  const v = paramString(params, "authType");
+  return v === "api_key" || v === "oauth" || v === "aws_sdk" ? v : void 0;
+}
+var AccountHandler = class {
+  /** Execute an `account` query (`list`). */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (operation === "list") {
+      const provider = paramString(params, "provider");
+      return runEntityOp(
+        () => accountList(provider !== void 0 ? { provider } : {}),
+        "query",
+        "account",
+        "list",
+        startTime
+      );
+    }
+    return unsupportedOp("query", "account", operation, startTime);
+  }
+  /** Execute an `account` mutation (`add` — secret-bearing — / `remove`). */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    switch (operation) {
+      case "add": {
+        const provider = paramString(params, "provider");
+        const token = paramString(params, "token");
+        if (!provider || !token) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: { code: "E_INVALID_INPUT", message: "provider and token are required" }
+            }),
+            "mutate",
+            "account",
+            "add",
+            startTime
+          );
+        }
+        const authType = authTypeOf(params);
+        const baseUrl = paramString(params, "baseUrl");
+        const priority = paramNumber(params, "priority");
+        const label = paramString(params, "label");
+        return runEntityOp(
+          () => accountAdd({
+            provider,
+            token,
+            ...label !== void 0 ? { label } : {},
+            ...baseUrl !== void 0 ? { baseUrl } : {},
+            ...authType !== void 0 ? { authType } : {},
+            ...priority !== void 0 ? { priority } : {}
+          }),
+          "mutate",
+          "account",
+          "add",
+          startTime
+        );
+      }
+      case "remove": {
+        const provider = paramString(params, "provider");
+        const label = paramString(params, "label");
+        if (!provider || !label) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: { code: "E_INVALID_INPUT", message: "provider and label are required" }
+            }),
+            "mutate",
+            "account",
+            "remove",
+            startTime
+          );
+        }
+        return runEntityOp(
+          () => accountRemove({ provider, label }),
+          "mutate",
+          "account",
+          "remove",
+          startTime
+        );
+      }
+      default:
+        return unsupportedOp("mutate", "account", operation, startTime);
+    }
+  }
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return { query: ["list"], mutate: ["add", "remove"] };
+  }
+};
+var ProviderHandler = class {
+  /** Execute a `provider` query (`list` / `show`). */
+  async query(operation, params) {
+    const startTime = Date.now();
+    switch (operation) {
+      case "list":
+        return runEntityOp(() => providerList({}), "query", "provider", "list", startTime);
+      case "show": {
+        const provider = paramString(params, "provider");
+        if (!provider) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: { code: "E_INVALID_INPUT", message: "provider is required" }
+            }),
+            "query",
+            "provider",
+            "show",
+            startTime
+          );
+        }
+        return runEntityOp(
+          () => providerShow({ provider }),
+          "query",
+          "provider",
+          "show",
+          startTime
+        );
+      }
+      default:
+        return unsupportedOp("query", "provider", operation, startTime);
+    }
+  }
+  /** Execute a `provider` mutation (`connect` — secret-bearing). */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (operation === "connect") {
+      const provider = paramString(params, "provider");
+      if (!provider) {
+        return runEntityOp(
+          async () => ({
+            success: false,
+            error: { code: "E_INVALID_INPUT", message: "provider is required" }
+          }),
+          "mutate",
+          "provider",
+          "connect",
+          startTime
+        );
+      }
+      const token = paramString(params, "token");
+      const label = paramString(params, "label");
+      const authType = authTypeOf(params);
+      return runEntityOp(
+        () => providerConnect({
+          provider,
+          ...token !== void 0 ? { token } : {},
+          ...label !== void 0 ? { label } : {},
+          ...authType !== void 0 ? { authType } : {}
+        }),
+        "mutate",
+        "provider",
+        "connect",
+        startTime
+      );
+    }
+    return unsupportedOp("mutate", "provider", operation, startTime);
+  }
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return { query: ["list", "show"], mutate: ["connect"] };
+  }
+};
+var ModelHandler = class {
+  /** Execute a `model` query (`query` / `show`). */
+  async query(operation, params) {
+    const startTime = Date.now();
+    switch (operation) {
+      case "query": {
+        const provider = paramString(params, "provider");
+        const limit = paramNumber(params, "limit");
+        return runEntityOp(
+          () => modelQuery({
+            ...provider !== void 0 ? { provider } : {},
+            ...limit !== void 0 ? { limit } : {}
+          }),
+          "query",
+          "model",
+          "query",
+          startTime
+        );
+      }
+      case "show": {
+        const model = paramString(params, "model");
+        if (!model) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: { code: "E_INVALID_INPUT", message: "model is required" }
+            }),
+            "query",
+            "model",
+            "show",
+            startTime
+          );
+        }
+        return runEntityOp(() => modelShow({ model }), "query", "model", "show", startTime);
+      }
+      default:
+        return unsupportedOp("query", "model", operation, startTime);
+    }
+  }
+  /** `model` is query-only — every mutation is unsupported. */
+  async mutate(operation, _params) {
+    return unsupportedOp("mutate", "model", operation, Date.now());
+  }
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return { query: ["query", "show"], mutate: [] };
+  }
+};
+var ProfileHandler = class {
+  /** Execute a `profile` query (`list`). */
+  async query(operation, _params) {
+    const startTime = Date.now();
+    if (operation === "list") {
+      return runEntityOp(() => profileList({}), "query", "profile", "list", startTime);
+    }
+    return unsupportedOp("query", "profile", operation, startTime);
+  }
+  /** Execute a `profile` mutation (`create` / `pin` / `use`). */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    switch (operation) {
+      case "create": {
+        const name = paramString(params, "name");
+        const provider = paramString(params, "provider");
+        const model = paramString(params, "model");
+        if (!name || !provider || !model) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: {
+                code: "E_INVALID_INPUT",
+                message: "name, provider, and model are required"
+              }
+            }),
+            "mutate",
+            "profile",
+            "create",
+            startTime
+          );
+        }
+        const label = paramString(params, "label");
+        const role = paramString(params, "role");
+        return runEntityOp(
+          () => profileCreate({
+            name,
+            provider,
+            model,
+            ...label !== void 0 ? { label } : {},
+            ...role !== void 0 ? { role } : {}
+          }),
+          "mutate",
+          "profile",
+          "create",
+          startTime
+        );
+      }
+      case "pin": {
+        const name = paramString(params, "name");
+        const role = paramString(params, "role");
+        if (!name || !role) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: { code: "E_INVALID_INPUT", message: "name and role are required" }
+            }),
+            "mutate",
+            "profile",
+            "pin",
+            startTime
+          );
+        }
+        return runEntityOp(() => profilePin({ name, role }), "mutate", "profile", "pin", startTime);
+      }
+      case "use": {
+        const name = paramString(params, "name");
+        if (!name) {
+          return runEntityOp(
+            async () => ({
+              success: false,
+              error: { code: "E_INVALID_INPUT", message: "name is required" }
+            }),
+            "mutate",
+            "profile",
+            "use",
+            startTime
+          );
+        }
+        return runEntityOp(() => profileUse({ name }), "mutate", "profile", "use", startTime);
+      }
+      default:
+        return unsupportedOp("mutate", "profile", operation, startTime);
+    }
+  }
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return { query: ["list"], mutate: ["create", "pin", "use"] };
+  }
+};
+export {
+  AccountHandler,
+  ModelHandler,
+  ProfileHandler,
+  ProviderHandler
+};
+//# sourceMappingURL=entities-3JIHDIOK.js.map