@kodycodes/cli 1.26.2 → 1.27.0

package/dist/chunk-W2SAFAT4.js

@@ -0,0 +1,1563 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  userCacheDir
+} from "./chunk-DW5UTJ6T.js";
+import {
+  assertTokenSafeApiUrl,
+  capabilityProxyUrl,
+  currentStoredTokenLifetimeAlias,
+  insufficientScopeMessage,
+  readInsufficientScopeDetails,
+  readPackageVersion
+} from "./chunk-5JIRHJQP.js";
+import {
+  describeNetworkError
+} from "./chunk-4GIFJVGT.js";
+import {
+  apiTokenEnvVar,
+  cliName,
+  defaultApiUrl
+} from "./chunk-BTL3PJ2H.js";
+
+// src/open-api-client.ts
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/generated/openapi-routes.ts
+var bakedOpenApiRoutes = [
+  {
+    operationId: "accessGrant",
+    method: "POST",
+    pathTemplate: "/v1/access/grants",
+    pathParamNames: []
+  },
+  {
+    operationId: "accessList",
+    method: "GET",
+    pathTemplate: "/v1/access/grants",
+    pathParamNames: []
+  },
+  {
+    operationId: "accessRevoke",
+    method: "POST",
+    pathTemplate: "/v1/access/grants/{grant_id}/revoke",
+    pathParamNames: ["grant_id"]
+  },
+  {
+    operationId: "accountExportManifest",
+    method: "GET",
+    pathTemplate: "/v1/account/export",
+    pathParamNames: []
+  },
+  {
+    operationId: "accountExportSection",
+    method: "GET",
+    pathTemplate: "/v1/account/export/{section}",
+    pathParamNames: ["section"]
+  },
+  {
+    operationId: "approvalBundleCreate",
+    method: "POST",
+    pathTemplate: "/v1/approval-bundles",
+    pathParamNames: []
+  },
+  {
+    operationId: "approvalPendingList",
+    method: "GET",
+    pathTemplate: "/v1/approvals",
+    pathParamNames: []
+  },
+  {
+    operationId: "capabilityProxyCall",
+    method: "POST",
+    pathTemplate: "/v1/capability-proxy/call",
+    pathParamNames: []
+  },
+  {
+    operationId: "capabilityProxyGatewayFetch",
+    method: "POST",
+    pathTemplate: "/v1/capability-proxy/gateway-fetch",
+    pathParamNames: []
+  },
+  {
+    operationId: "capabilityProxySession",
+    method: "GET",
+    pathTemplate: "/v1/capability-proxy/session",
+    pathParamNames: []
+  },
+  {
+    operationId: "cliCredentialBootstrap",
+    method: "POST",
+    pathTemplate: "/v1/tokens/bootstrap",
+    pathParamNames: []
+  },
+  {
+    operationId: "cliCredentialBootstrapRedeem",
+    method: "POST",
+    pathTemplate: "/v1/tokens/bootstrap/redeem",
+    pathParamNames: []
+  },
+  {
+    operationId: "cliLoginDeviceToken",
+    method: "POST",
+    pathTemplate: "/v1/tokens/device",
+    pathParamNames: []
+  },
+  {
+    operationId: "communityFork",
+    method: "POST",
+    pathTemplate: "/v1/community/listings/{listing_id}/fork",
+    pathParamNames: ["listing_id"]
+  },
+  {
+    operationId: "communityForkAdopt",
+    method: "POST",
+    pathTemplate: "/v1/community/fork-adopt",
+    pathParamNames: []
+  },
+  {
+    operationId: "communityGet",
+    method: "GET",
+    pathTemplate: "/v1/community/listings/{listing_id}",
+    pathParamNames: ["listing_id"]
+  },
+  {
+    operationId: "communityProfileGet",
+    method: "GET",
+    pathTemplate: "/v1/community/profile",
+    pathParamNames: []
+  },
+  {
+    operationId: "communityProfileUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/community/profile",
+    pathParamNames: []
+  },
+  {
+    operationId: "communityPublish",
+    method: "POST",
+    pathTemplate: "/v1/community/listings",
+    pathParamNames: []
+  },
+  {
+    operationId: "communityRate",
+    method: "POST",
+    pathTemplate: "/v1/community/listings/{listing_id}/rate",
+    pathParamNames: ["listing_id"]
+  },
+  {
+    operationId: "communityReport",
+    method: "POST",
+    pathTemplate: "/v1/community/listings/{listing_id}/report",
+    pathParamNames: ["listing_id"]
+  },
+  {
+    operationId: "communitySearch",
+    method: "GET",
+    pathTemplate: "/v1/community/listings",
+    pathParamNames: []
+  },
+  {
+    operationId: "communityUnpublish",
+    method: "DELETE",
+    pathTemplate: "/v1/community/listings/{listing_id}",
+    pathParamNames: ["listing_id"]
+  },
+  {
+    operationId: "credentialList",
+    method: "GET",
+    pathTemplate: "/v1/credentials",
+    pathParamNames: []
+  },
+  {
+    operationId: "credentialMappingPropose",
+    method: "POST",
+    pathTemplate: "/v1/credential-proposals",
+    pathParamNames: []
+  },
+  {
+    operationId: "credentialOrgGrant",
+    method: "PUT",
+    pathTemplate: "/v1/personal-credential-grants/{credential_id}/{org}",
+    pathParamNames: ["credential_id", "org"]
+  },
+  {
+    operationId: "credentialOrgGrantList",
+    method: "GET",
+    pathTemplate: "/v1/personal-credential-grants",
+    pathParamNames: []
+  },
+  {
+    operationId: "credentialOrgRevoke",
+    method: "DELETE",
+    pathTemplate: "/v1/personal-credential-grants/{credential_id}/{org}",
+    pathParamNames: ["credential_id", "org"]
+  },
+  {
+    operationId: "credentialTriggerPickSet",
+    method: "PUT",
+    pathTemplate: "/v1/credential-trigger-picks",
+    pathParamNames: []
+  },
+  {
+    operationId: "credentialUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/credentials/{credential_id}",
+    pathParamNames: ["credential_id"]
+  },
+  {
+    operationId: "emailAttachmentGet",
+    method: "GET",
+    pathTemplate: "/v1/email/attachments/{attachment_id}",
+    pathParamNames: ["attachment_id"]
+  },
+  {
+    operationId: "emailDeliveryEventList",
+    method: "GET",
+    pathTemplate: "/v1/email/delivery-events",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailDestinationAdd",
+    method: "POST",
+    pathTemplate: "/v1/email/destinations",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailDestinationList",
+    method: "GET",
+    pathTemplate: "/v1/email/destinations",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailDestinationRemove",
+    method: "DELETE",
+    pathTemplate: "/v1/email/destinations/{id}",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "emailDestinationSetDefault",
+    method: "POST",
+    pathTemplate: "/v1/email/destinations/{id}/default",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "emailInboxList",
+    method: "GET",
+    pathTemplate: "/v1/email/inboxes",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailMessageClassify",
+    method: "POST",
+    pathTemplate: "/v1/email/messages/{message_id}/classify",
+    pathParamNames: ["message_id"]
+  },
+  {
+    operationId: "emailMessageDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/email/messages/{message_id}",
+    pathParamNames: ["message_id"]
+  },
+  {
+    operationId: "emailMessageGet",
+    method: "GET",
+    pathTemplate: "/v1/email/messages/{message_id}",
+    pathParamNames: ["message_id"]
+  },
+  {
+    operationId: "emailMessageList",
+    method: "GET",
+    pathTemplate: "/v1/email/messages",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailMessageSearch",
+    method: "GET",
+    pathTemplate: "/v1/email/messages/search",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailReply",
+    method: "POST",
+    pathTemplate: "/v1/email/messages/{message_id}/reply",
+    pathParamNames: ["message_id"]
+  },
+  {
+    operationId: "emailSend",
+    method: "POST",
+    pathTemplate: "/v1/email/send",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailSenderRuleDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/email/sender-rules/{rule_id}",
+    pathParamNames: ["rule_id"]
+  },
+  {
+    operationId: "emailSenderRuleList",
+    method: "GET",
+    pathTemplate: "/v1/email/sender-rules",
+    pathParamNames: []
+  },
+  {
+    operationId: "emailSenderRuleSet",
+    method: "POST",
+    pathTemplate: "/v1/email/sender-rules",
+    pathParamNames: []
+  },
+  {
+    operationId: "enablementDisable",
+    method: "POST",
+    pathTemplate: "/v1/enablements/{enablementId}/disable",
+    pathParamNames: ["enablementId"]
+  },
+  {
+    operationId: "enablementEnable",
+    method: "POST",
+    pathTemplate: "/v1/enablements",
+    pathParamNames: []
+  },
+  {
+    operationId: "enablementList",
+    method: "GET",
+    pathTemplate: "/v1/enablements",
+    pathParamNames: []
+  },
+  {
+    operationId: "execute",
+    method: "POST",
+    pathTemplate: "/v1/execute",
+    pathParamNames: []
+  },
+  {
+    operationId: "followAdd",
+    method: "POST",
+    pathTemplate: "/v1/follows",
+    pathParamNames: []
+  },
+  {
+    operationId: "followList",
+    method: "GET",
+    pathTemplate: "/v1/follows",
+    pathParamNames: []
+  },
+  {
+    operationId: "followRemove",
+    method: "DELETE",
+    pathTemplate: "/v1/follows",
+    pathParamNames: []
+  },
+  {
+    operationId: "integrationDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/integrations/{name}",
+    pathParamNames: ["name"]
+  },
+  {
+    operationId: "integrationGet",
+    method: "GET",
+    pathTemplate: "/v1/integrations/{name}",
+    pathParamNames: ["name"]
+  },
+  {
+    operationId: "integrationList",
+    method: "GET",
+    pathTemplate: "/v1/integrations",
+    pathParamNames: []
+  },
+  {
+    operationId: "integrationLock",
+    method: "POST",
+    pathTemplate: "/v1/integrations/{name}/lock",
+    pathParamNames: ["name"]
+  },
+  {
+    operationId: "integrationOauthAppDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/oauth-apps/{slug}",
+    pathParamNames: ["slug"]
+  },
+  {
+    operationId: "integrationOauthAppList",
+    method: "GET",
+    pathTemplate: "/v1/oauth-apps",
+    pathParamNames: []
+  },
+  {
+    operationId: "integrationOauthAppRotateCredentials",
+    method: "POST",
+    pathTemplate: "/v1/oauth-apps/{slug}/rotate-credentials",
+    pathParamNames: ["slug"]
+  },
+  {
+    operationId: "integrationPlatformAppList",
+    method: "GET",
+    pathTemplate: "/v1/platform-apps",
+    pathParamNames: []
+  },
+  {
+    operationId: "integrationSave",
+    method: "PUT",
+    pathTemplate: "/v1/integrations/{name}",
+    pathParamNames: ["name"]
+  },
+  {
+    operationId: "integrationTokenRefresh",
+    method: "POST",
+    pathTemplate: "/v1/integrations/{name}/refresh",
+    pathParamNames: ["name"]
+  },
+  {
+    operationId: "inviteAccept",
+    method: "POST",
+    pathTemplate: "/v1/access/invites/accept",
+    pathParamNames: []
+  },
+  {
+    operationId: "inviteCreate",
+    method: "POST",
+    pathTemplate: "/v1/access/invites",
+    pathParamNames: []
+  },
+  {
+    operationId: "inviteRevoke",
+    method: "POST",
+    pathTemplate: "/v1/access/invites/{invite_id}/revoke",
+    pathParamNames: ["invite_id"]
+  },
+  {
+    operationId: "jobGet",
+    method: "GET",
+    pathTemplate: "/v1/jobs/{id}",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "jobList",
+    method: "GET",
+    pathTemplate: "/v1/jobs",
+    pathParamNames: []
+  },
+  {
+    operationId: "jobRunNow",
+    method: "POST",
+    pathTemplate: "/v1/jobs/{id}/run",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "jobUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/jobs/{id}",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "localExecutePackageGraph",
+    method: "POST",
+    pathTemplate: "/v1/local-execute/package-graph",
+    pathParamNames: []
+  },
+  {
+    operationId: "mcpServerAdd",
+    method: "POST",
+    pathTemplate: "/v1/mcp-servers",
+    pathParamNames: []
+  },
+  {
+    operationId: "mcpServerList",
+    method: "GET",
+    pathTemplate: "/v1/mcp-servers",
+    pathParamNames: []
+  },
+  {
+    operationId: "mcpServerLock",
+    method: "POST",
+    pathTemplate: "/v1/mcp-servers/{server}/lock",
+    pathParamNames: ["server"]
+  },
+  {
+    operationId: "mcpServerReconnect",
+    method: "POST",
+    pathTemplate: "/v1/mcp-servers/{server}/reconnect",
+    pathParamNames: ["server"]
+  },
+  {
+    operationId: "mcpServerRefresh",
+    method: "POST",
+    pathTemplate: "/v1/mcp-servers/{server}/refresh",
+    pathParamNames: ["server"]
+  },
+  {
+    operationId: "mcpServerRemove",
+    method: "DELETE",
+    pathTemplate: "/v1/mcp-servers/{server}",
+    pathParamNames: ["server"]
+  },
+  {
+    operationId: "mcpServerSetEnabled",
+    method: "PUT",
+    pathTemplate: "/v1/mcp-servers/{server}/enabled",
+    pathParamNames: ["server"]
+  },
+  {
+    operationId: "metaGetCurrentUser",
+    method: "GET",
+    pathTemplate: "/v1/me",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaGetMcpServerInstructions",
+    method: "GET",
+    pathTemplate: "/v1/mcp-server-instructions",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaMemoryDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/memories/{memory_id}",
+    pathParamNames: ["memory_id"]
+  },
+  {
+    operationId: "metaMemoryGet",
+    method: "GET",
+    pathTemplate: "/v1/memories/{memory_id}",
+    pathParamNames: ["memory_id"]
+  },
+  {
+    operationId: "metaMemorySearch",
+    method: "GET",
+    pathTemplate: "/v1/memories",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaMemoryUpsert",
+    method: "POST",
+    pathTemplate: "/v1/memories",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaMemoryVerify",
+    method: "POST",
+    pathTemplate: "/v1/memories/verify",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaPlatformFeedbackGet",
+    method: "GET",
+    pathTemplate: "/v1/account/feedback/{feedback_id}",
+    pathParamNames: ["feedback_id"]
+  },
+  {
+    operationId: "metaPlatformFeedbackList",
+    method: "GET",
+    pathTemplate: "/v1/account/feedback",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaPlatformFeedbackSubmit",
+    method: "POST",
+    pathTemplate: "/v1/account/feedback",
+    pathParamNames: []
+  },
+  {
+    operationId: "metaSetMcpServerInstructions",
+    method: "PUT",
+    pathTemplate: "/v1/mcp-server-instructions",
+    pathParamNames: []
+  },
+  {
+    operationId: "orgCreate",
+    method: "POST",
+    pathTemplate: "/v1/orgs",
+    pathParamNames: []
+  },
+  {
+    operationId: "orgMemberList",
+    method: "GET",
+    pathTemplate: "/v1/orgs/members",
+    pathParamNames: []
+  },
+  {
+    operationId: "orgMemberRemove",
+    method: "DELETE",
+    pathTemplate: "/v1/orgs/members/{user_id}",
+    pathParamNames: ["user_id"]
+  },
+  {
+    operationId: "orgMemberUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/orgs/members/{user_id}",
+    pathParamNames: ["user_id"]
+  },
+  {
+    operationId: "orgUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/orgs",
+    pathParamNames: []
+  },
+  {
+    operationId: "packageAppCustomHostnameAdd",
+    method: "POST",
+    pathTemplate: "/v1/orgs/package-app-custom-hostnames",
+    pathParamNames: []
+  },
+  {
+    operationId: "packageAppCustomHostnameDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/orgs/package-app-custom-hostnames/{id}",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "packageAppCustomHostnameList",
+    method: "GET",
+    pathTemplate: "/v1/orgs/package-app-custom-hostnames",
+    pathParamNames: []
+  },
+  {
+    operationId: "packageAppCustomHostnameSync",
+    method: "POST",
+    pathTemplate: "/v1/orgs/package-app-custom-hostnames/{id}/sync",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "packageCollaboratorList",
+    method: "GET",
+    pathTemplate: "/v1/packages/{package_id}/collaborators",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageCollaboratorRemove",
+    method: "DELETE",
+    pathTemplate: "/v1/packages/{package_id}/collaborators/{grant_id}",
+    pathParamNames: ["package_id", "grant_id"]
+  },
+  {
+    operationId: "packageCollaboratorSet",
+    method: "POST",
+    pathTemplate: "/v1/packages/{package_id}/collaborators",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/packages/{package_id}",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageGet",
+    method: "GET",
+    pathTemplate: "/v1/packages/{package_id}",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageGetGitRemote",
+    method: "POST",
+    pathTemplate: "/v1/packages/{package_id}/git-remote",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageList",
+    method: "GET",
+    pathTemplate: "/v1/packages",
+    pathParamNames: []
+  },
+  {
+    operationId: "packagePublishExternalPush",
+    method: "POST",
+    pathTemplate: "/v1/packages/{package_id}/external-push",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageSave",
+    method: "POST",
+    pathTemplate: "/v1/packages",
+    pathParamNames: []
+  },
+  {
+    operationId: "packageSecurityAuditRecord",
+    method: "POST",
+    pathTemplate: "/v1/packages/{package_id}/security-audits",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "packageSubscriptionsList",
+    method: "GET",
+    pathTemplate: "/v1/package-subscriptions",
+    pathParamNames: []
+  },
+  {
+    operationId: "packageUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/packages/{package_id}",
+    pathParamNames: ["package_id"]
+  },
+  {
+    operationId: "repoApplyPatch",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/patch",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoCommit",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/commits",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoCreate",
+    method: "POST",
+    pathTemplate: "/v1/repos",
+    pathParamNames: []
+  },
+  {
+    operationId: "repoDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/repos/{repo_id}",
+    pathParamNames: ["repo_id"]
+  },
+  {
+    operationId: "repoDiff",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/diff",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoDiscardSession",
+    method: "DELETE",
+    pathTemplate: "/v1/repo-sessions/{session_id}",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoEditFiles",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/edits",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoGet",
+    method: "GET",
+    pathTemplate: "/v1/repos/{repo_id}",
+    pathParamNames: ["repo_id"]
+  },
+  {
+    operationId: "repoGetCheckStatus",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/checks",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoGetGitRemote",
+    method: "POST",
+    pathTemplate: "/v1/repos/git-remote",
+    pathParamNames: []
+  },
+  {
+    operationId: "repoGetGitRemoteByPath",
+    method: "POST",
+    pathTemplate: "/v1/repos/{repo_id}/git-remote",
+    pathParamNames: ["repo_id"]
+  },
+  {
+    operationId: "repoGetSession",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoList",
+    method: "GET",
+    pathTemplate: "/v1/repos",
+    pathParamNames: []
+  },
+  {
+    operationId: "repoListSessions",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions",
+    pathParamNames: []
+  },
+  {
+    operationId: "repoLog",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/log",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoOpenSession",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions",
+    pathParamNames: []
+  },
+  {
+    operationId: "repoPromoteToPackage",
+    method: "POST",
+    pathTemplate: "/v1/repos/{repo_id}/promote",
+    pathParamNames: ["repo_id"]
+  },
+  {
+    operationId: "repoPublishSession",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/publish",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoReadFile",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/file",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoRebaseSession",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/rebase",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoRestore",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/restore",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoRunChecks",
+    method: "POST",
+    pathTemplate: "/v1/repo-sessions/{session_id}/checks",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoSearch",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/search",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoShowPublishNote",
+    method: "GET",
+    pathTemplate: "/v1/repo-publish-note",
+    pathParamNames: []
+  },
+  {
+    operationId: "repoStatus",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/status",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoTree",
+    method: "GET",
+    pathTemplate: "/v1/repo-sessions/{session_id}/tree",
+    pathParamNames: ["session_id"]
+  },
+  {
+    operationId: "repoUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/repos/{repo_id}",
+    pathParamNames: ["repo_id"]
+  },
+  {
+    operationId: "runGet",
+    method: "GET",
+    pathTemplate: "/v1/runs/{run_id}",
+    pathParamNames: ["run_id"]
+  },
+  {
+    operationId: "runList",
+    method: "GET",
+    pathTemplate: "/v1/runs",
+    pathParamNames: []
+  },
+  {
+    operationId: "runSummary",
+    method: "GET",
+    pathTemplate: "/v1/runs/summary",
+    pathParamNames: []
+  },
+  {
+    operationId: "runUpdate",
+    method: "PATCH",
+    pathTemplate: "/v1/runs/{run_id}",
+    pathParamNames: ["run_id"]
+  },
+  {
+    operationId: "runUpdateBulk",
+    method: "POST",
+    pathTemplate: "/v1/runs/triage",
+    pathParamNames: []
+  },
+  {
+    operationId: "search",
+    method: "GET",
+    pathTemplate: "/v1/search",
+    pathParamNames: []
+  },
+  {
+    operationId: "searchTool",
+    method: "POST",
+    pathTemplate: "/v1/search/tool",
+    pathParamNames: []
+  },
+  {
+    operationId: "secretDelete",
+    method: "DELETE",
+    pathTemplate: "/v1/secrets/{scope}/{name}",
+    pathParamNames: ["scope", "name"]
+  },
+  {
+    operationId: "secretJwtSign",
+    method: "POST",
+    pathTemplate: "/v1/secrets/jwt",
+    pathParamNames: []
+  },
+  {
+    operationId: "secretList",
+    method: "GET",
+    pathTemplate: "/v1/secrets",
+    pathParamNames: []
+  },
+  {
+    operationId: "secretLock",
+    method: "POST",
+    pathTemplate: "/v1/secrets/lock",
+    pathParamNames: []
+  },
+  {
+    operationId: "secretProviderBind",
+    method: "PUT",
+    pathTemplate: "/v1/secret-providers/{provider}",
+    pathParamNames: ["provider"]
+  },
+  {
+    operationId: "secretProviderList",
+    method: "GET",
+    pathTemplate: "/v1/secret-providers",
+    pathParamNames: []
+  },
+  {
+    operationId: "secretProviderLock",
+    method: "POST",
+    pathTemplate: "/v1/secret-providers/{provider}/lock",
+    pathParamNames: ["provider"]
+  },
+  {
+    operationId: "secretProviderUnbind",
+    method: "DELETE",
+    pathTemplate: "/v1/secret-providers/{provider}",
+    pathParamNames: ["provider"]
+  },
+  {
+    operationId: "secretSet",
+    method: "PUT",
+    pathTemplate: "/v1/secrets/{scope}/{name}",
+    pathParamNames: ["scope", "name"]
+  },
+  {
+    operationId: "secretSetMany",
+    method: "POST",
+    pathTemplate: "/v1/secrets/batch",
+    pathParamNames: []
+  },
+  {
+    operationId: "storageExport",
+    method: "GET",
+    pathTemplate: "/v1/storage/{storage_id}/export",
+    pathParamNames: ["storage_id"]
+  },
+  {
+    operationId: "storageQuery",
+    method: "POST",
+    pathTemplate: "/v1/storage/{storage_id}/query",
+    pathParamNames: ["storage_id"]
+  },
+  {
+    operationId: "teamCreate",
+    method: "POST",
+    pathTemplate: "/v1/orgs/teams",
+    pathParamNames: []
+  },
+  {
+    operationId: "teamList",
+    method: "GET",
+    pathTemplate: "/v1/orgs/teams",
+    pathParamNames: []
+  },
+  {
+    operationId: "teamMemberAdd",
+    method: "POST",
+    pathTemplate: "/v1/orgs/teams/{team_id}/members",
+    pathParamNames: ["team_id"]
+  },
+  {
+    operationId: "teamMemberRemove",
+    method: "DELETE",
+    pathTemplate: "/v1/orgs/teams/{team_id}/members/{user_id}",
+    pathParamNames: ["team_id", "user_id"]
+  },
+  {
+    operationId: "tokenCreate",
+    method: "POST",
+    pathTemplate: "/v1/tokens",
+    pathParamNames: []
+  },
+  {
+    operationId: "tokenGet",
+    method: "GET",
+    pathTemplate: "/v1/tokens/{token_id}",
+    pathParamNames: ["token_id"]
+  },
+  {
+    operationId: "tokenGetCurrent",
+    method: "GET",
+    pathTemplate: "/v1/tokens/current",
+    pathParamNames: []
+  },
+  {
+    operationId: "tokenList",
+    method: "GET",
+    pathTemplate: "/v1/tokens",
+    pathParamNames: []
+  },
+  {
+    operationId: "tokenRevoke",
+    method: "DELETE",
+    pathTemplate: "/v1/tokens/{token_id}",
+    pathParamNames: ["token_id"]
+  },
+  {
+    operationId: "tokenRevokeCurrent",
+    method: "DELETE",
+    pathTemplate: "/v1/tokens/current",
+    pathParamNames: []
+  },
+  {
+    operationId: "tokenRotate",
+    method: "POST",
+    pathTemplate: "/v1/tokens/{token_id}/rotate",
+    pathParamNames: ["token_id"]
+  },
+  {
+    operationId: "tokenRotateCurrent",
+    method: "POST",
+    pathTemplate: "/v1/tokens/current/rotate",
+    pathParamNames: []
+  },
+  {
+    operationId: "usageByPackageGet",
+    method: "GET",
+    pathTemplate: "/v1/account/usage/by-package",
+    pathParamNames: []
+  },
+  {
+    operationId: "usageGet",
+    method: "GET",
+    pathTemplate: "/v1/account/usage",
+    pathParamNames: []
+  },
+  {
+    operationId: "usageTrendGet",
+    method: "GET",
+    pathTemplate: "/v1/account/usage/trend",
+    pathParamNames: []
+  },
+  {
+    operationId: "waitingSummary",
+    method: "GET",
+    pathTemplate: "/v1/account/waiting",
+    pathParamNames: []
+  },
+  {
+    operationId: "webhookDeliveryList",
+    method: "GET",
+    pathTemplate: "/v1/webhooks/{webhookName}/deliveries",
+    pathParamNames: ["webhookName"]
+  },
+  {
+    operationId: "webhookDisable",
+    method: "POST",
+    pathTemplate: "/v1/webhooks/{webhookName}/disable",
+    pathParamNames: ["webhookName"]
+  },
+  {
+    operationId: "webhookEnable",
+    method: "POST",
+    pathTemplate: "/v1/webhooks/{webhookName}/enable",
+    pathParamNames: ["webhookName"]
+  },
+  {
+    operationId: "webhookList",
+    method: "GET",
+    pathTemplate: "/v1/webhooks",
+    pathParamNames: []
+  },
+  {
+    operationId: "webhookUrlApply",
+    method: "POST",
+    pathTemplate: "/v1/webhooks/apply",
+    pathParamNames: []
+  },
+  {
+    operationId: "webhookUrlMint",
+    method: "POST",
+    pathTemplate: "/v1/webhooks/{webhookName}/url",
+    pathParamNames: ["webhookName"]
+  },
+  {
+    operationId: "webhookUrlRotate",
+    method: "POST",
+    pathTemplate: "/v1/webhooks/{webhookName}/url/rotate",
+    pathParamNames: ["webhookName"]
+  },
+  {
+    operationId: "workflowRunCancel",
+    method: "POST",
+    pathTemplate: "/v1/workflow-runs/{id}/cancel",
+    pathParamNames: ["id"]
+  },
+  {
+    operationId: "workflowRunList",
+    method: "GET",
+    pathTemplate: "/v1/workflow-runs",
+    pathParamNames: []
+  }
+];
+
+// src/open-api-client.ts
+var OpenApiError = class extends Error {
+  status;
+  code;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "OpenApiError";
+    this.status = options.status ?? null;
+    this.code = options.code ?? null;
+  }
+};
+var openApiDocumentPath = "openapi.json";
+var cliCredentialBootstrapRedeemOperationId = "cliCredentialBootstrapRedeem";
+var openApiRouteCache = /* @__PURE__ */ new Map();
+var openApiRouteCacheVersion = 1;
+function openApiCacheDir() {
+  return join(userCacheDir(), "openapi");
+}
+function sha256Hex(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function originPointerPath(origin) {
+  return join(openApiCacheDir(), `${sha256Hex(origin)}.etag`);
+}
+function routeMapPath(etag) {
+  return join(openApiCacheDir(), `${sha256Hex(etag)}.json`);
+}
+function isOperationRoute(value) {
+  if (!value || typeof value !== "object") return false;
+  const route = value;
+  return typeof route.operationId === "string" && typeof route.method === "string" && typeof route.pathTemplate === "string" && Array.isArray(route.pathParamNames) && route.pathParamNames.every((name) => typeof name === "string");
+}
+async function readPersistedRoutes(origin) {
+  try {
+    const etag = (await readFile(originPointerPath(origin), "utf8")).trim();
+    if (!etag) return null;
+    const raw = JSON.parse(await readFile(routeMapPath(etag), "utf8"));
+    if (!raw || typeof raw !== "object") return null;
+    const entry = raw;
+    if (entry.version !== openApiRouteCacheVersion || entry.etag !== etag)
+      return null;
+    if (!Array.isArray(entry.operations) || !entry.operations.every(isOperationRoute))
+      return null;
+    return {
+      etag,
+      operations: new Map(
+        entry.operations.map((route) => [route.operationId, route])
+      )
+    };
+  } catch {
+    return null;
+  }
+}
+async function persistRoutes(origin, previousEtag, entry) {
+  if (!entry.etag) return;
+  try {
+    await mkdir(openApiCacheDir(), { recursive: true });
+    await writeFile(
+      routeMapPath(entry.etag),
+      JSON.stringify({
+        version: openApiRouteCacheVersion,
+        etag: entry.etag,
+        operations: [...entry.operations.values()]
+      })
+    );
+    await writeFile(originPointerPath(origin), entry.etag);
+    if (previousEtag && previousEtag !== entry.etag) {
+      await rm(routeMapPath(previousEtag), { force: true });
+    }
+  } catch {
+  }
+}
+async function openApiGet(input) {
+  return openApiRequest({
+    ...input,
+    method: "GET",
+    path: input.path,
+    query: input.query
+  });
+}
+async function openApiRequest(input) {
+  const apiUrl = input.apiUrl || defaultApiUrl;
+  assertTokenSafeApiUrl(apiUrl);
+  const url = capabilityProxyUrl(apiUrl, input.path.replace(/^\//, ""));
+  if (input.org) {
+    url.searchParams.set("org", input.org);
+  }
+  if (input.query) {
+    appendQueryParams(url.searchParams, input.query);
+  }
+  const method = input.method.toUpperCase();
+  const headers = {
+    accept: "application/json",
+    authorization: `Bearer ${input.token}`,
+    "user-agent": `${cliName}/${readPackageVersion()}`
+  };
+  let body;
+  if (input.body !== void 0 && method !== "GET" && method !== "HEAD") {
+    headers["content-type"] = "application/json";
+    body = JSON.stringify(input.body);
+  }
+  const fetchFn = input.fetchFn ?? fetch;
+  let response;
+  try {
+    response = await fetchFn(url, { method, headers, body });
+  } catch (error) {
+    const reason = describeNetworkError(error);
+    throw new OpenApiError(
+      `Could not reach the Kody API at ${url.origin} (${reason}). Check --api-url / KODY_API_URL and your network.`
+    );
+  }
+  const responseBody = await readJson(response);
+  if (!response.ok) {
+    throw describeOpenApiFailure(response.status, responseBody, url);
+  }
+  return responseBody;
+}
+async function callOpenApiOperation(input) {
+  const operationId = input.operationId.trim();
+  if (!operationId) {
+    throw new OpenApiError(
+      "Provide an Open API operationId (e.g. usageGet, metaGetCurrentUser)."
+    );
+  }
+  assertApiOperationAllowed(operationId);
+  const apiUrl = input.apiUrl || defaultApiUrl;
+  const operations = input.operations ?? await loadOpenApiOperations({ apiUrl, fetchFn: input.fetchFn });
+  const route = operations.get(operationId);
+  if (!route) {
+    throw new OpenApiError(
+      `Unknown operationId "${operationId}". Operation ids are listed in ${capabilityProxyUrl(apiUrl, openApiDocumentPath).href} and match Kody capability names (plus token operations such as tokenCreate).`,
+      { status: 404, code: "not_found" }
+    );
+  }
+  const built = buildOpenApiHttpRequest({
+    route,
+    params: input.params ?? {}
+  });
+  return openApiRequest({
+    token: input.token,
+    apiUrl,
+    fetchFn: input.fetchFn,
+    ...input.org ? { org: input.org } : {},
+    method: built.method,
+    path: built.path,
+    query: built.query,
+    body: built.body
+  });
+}
+function assertApiOperationAllowed(operationId) {
+  if (operationId === cliCredentialBootstrapRedeemOperationId) {
+    throw new OpenApiError(
+      `Refusing to call ${cliCredentialBootstrapRedeemOperationId}: redeem returns a kody_at_\u2026 token that must not print to stdout. Use \`kody auth bootstrap --code <kody_bc_\u2026>\` instead (stores the token; never prints it).`,
+      { status: null, code: "refused" }
+    );
+  }
+}
+function buildOpenApiHttpRequest(input) {
+  const remaining = { ...input.params };
+  const pathParams = {};
+  for (const name of input.route.pathParamNames) {
+    if (!(name in remaining) || remaining[name] === void 0 || remaining[name] === null) {
+      throw new OpenApiError(
+        `Missing required path parameter "${name}" for ${input.route.operationId} (${input.route.pathTemplate}).`
+      );
+    }
+    pathParams[name] = String(remaining[name]);
+    delete remaining[name];
+  }
+  const path = fillPathTemplate(input.route.pathTemplate, pathParams);
+  const method = input.route.method.toUpperCase();
+  if (apiOperationUsesQueryInputs(method)) {
+    return {
+      method,
+      path,
+      ...Object.keys(remaining).length > 0 ? { query: remaining } : {}
+    };
+  }
+  return {
+    method,
+    path,
+    body: remaining
+  };
+}
+function apiOperationUsesQueryInputs(method) {
+  const upper = method.toUpperCase();
+  return upper === "GET" || upper === "DELETE";
+}
+async function loadOpenApiOperations(input) {
+  const apiUrl = input.apiUrl || defaultApiUrl;
+  assertTokenSafeApiUrl(apiUrl);
+  const cacheKey = new URL(apiUrl).origin;
+  if (!input.bustCache) {
+    const cached = openApiRouteCache.get(cacheKey);
+    if (cached) return cached.operations;
+  }
+  const persisted = input.bustCache ? null : await readPersistedRoutes(cacheKey);
+  const url = capabilityProxyUrl(apiUrl, openApiDocumentPath);
+  const fetchFn = input.fetchFn ?? fetch;
+  let response;
+  try {
+    response = await fetchFn(url, {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "user-agent": `${cliName}/${readPackageVersion()}`,
+        ...persisted?.etag ? { "if-none-match": persisted.etag } : {}
+      }
+    });
+  } catch (error) {
+    if (bakedOpenApiRoutes.length > 0) {
+      return new Map(
+        bakedOpenApiRoutes.map((route) => [route.operationId, route])
+      );
+    }
+    const reason = describeNetworkError(error);
+    throw new OpenApiError(
+      `Could not load OpenAPI from ${url.href} (${reason}). Check --api-url / KODY_API_URL and your network.`
+    );
+  }
+  if (response.status === 304 && persisted) {
+    openApiRouteCache.set(cacheKey, persisted);
+    return persisted.operations;
+  }
+  const body = await readJson(response);
+  if (!response.ok) {
+    throw new OpenApiError(
+      `Could not load OpenAPI from ${url.href} (HTTP ${response.status}).`,
+      { status: response.status }
+    );
+  }
+  const entry = {
+    etag: response.headers.get("etag"),
+    operations: indexOpenApiOperations(body)
+  };
+  openApiRouteCache.set(cacheKey, entry);
+  await persistRoutes(cacheKey, persisted?.etag ?? null, entry);
+  return entry.operations;
+}
+function indexOpenApiOperations(document) {
+  if (!isRecord(document) || !isRecord(document.paths)) {
+    throw new OpenApiError("OpenAPI document is missing a paths object.");
+  }
+  const operations = /* @__PURE__ */ new Map();
+  for (const [pathTemplate, methods] of Object.entries(document.paths)) {
+    if (!isRecord(methods)) continue;
+    for (const [method, operation] of Object.entries(methods)) {
+      if (!isRecord(operation)) continue;
+      const operationId = typeof operation.operationId === "string" ? operation.operationId : "";
+      if (!operationId) continue;
+      operations.set(operationId, {
+        operationId,
+        method: method.toUpperCase(),
+        pathTemplate,
+        pathParamNames: pathParamNamesFromTemplate(pathTemplate)
+      });
+    }
+  }
+  return operations;
+}
+function clearOpenApiRouteCache() {
+  openApiRouteCache.clear();
+}
+function pathParamNamesFromTemplate(pathTemplate) {
+  const names = [];
+  for (const match of pathTemplate.matchAll(/\{([^{}/]+)\}/g)) {
+    const name = match[1];
+    if (name) names.push(name);
+  }
+  return names;
+}
+function fillPathTemplate(pathTemplate, pathParams) {
+  return pathTemplate.replace(/\{([^{}/]+)\}/g, (_full, name) => {
+    const value = pathParams[name];
+    if (value === void 0) {
+      throw new OpenApiError(
+        `Missing path parameter "${name}" for ${pathTemplate}.`
+      );
+    }
+    return encodeURIComponent(value);
+  });
+}
+function appendQueryParams(searchParams, query) {
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null || value === "") continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (entry === void 0 || entry === null) continue;
+        searchParams.append(key, stringifyQueryValue(entry));
+      }
+      continue;
+    }
+    searchParams.set(key, stringifyQueryValue(value));
+  }
+}
+function stringifyQueryValue(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return JSON.stringify(value);
+}
+async function searchWithApiToken(input) {
+  const body = await openApiRequest({
+    token: input.token,
+    ...input.apiUrl ? { apiUrl: input.apiUrl } : {},
+    ...input.fetchFn ? { fetchFn: input.fetchFn } : {},
+    ...input.org ? { org: input.org } : {},
+    method: "POST",
+    path: "v1/search/tool",
+    body: {
+      ...input.query ? { query: input.query } : {},
+      ...input.domain ? { domain: input.domain } : {},
+      ...input.limit !== void 0 ? { limit: input.limit } : {},
+      ...input.entity ? { entity: input.entity } : {}
+    }
+  });
+  return toolResultFromHttpBody(body);
+}
+function toolResultFromHttpBody(payload) {
+  if (isRecord(payload) && Array.isArray(payload.content)) {
+    return {
+      content: payload.content,
+      structuredContent: payload.structuredContent,
+      isError: payload.isError === true
+    };
+  }
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: payload,
+    isError: false
+  };
+}
+async function whoamiWithApiToken(input) {
+  const apiUrl = input.apiUrl || defaultApiUrl;
+  const current = await openApiGet({
+    ...input,
+    apiUrl,
+    path: "v1/tokens/current"
+  });
+  let user = null;
+  try {
+    const me = await openApiGet({
+      ...input,
+      apiUrl,
+      path: "v1/me"
+    });
+    user = {
+      userId: String(me.user_id ?? ""),
+      email: String(me.email ?? ""),
+      displayName: String(me.display_name ?? "")
+    };
+  } catch (error) {
+    if (!(error instanceof OpenApiError && error.status === 403)) throw error;
+  }
+  return {
+    apiUrl,
+    token: {
+      id: String(current.id ?? ""),
+      name: typeof current.name === "string" ? current.name : null,
+      scopes: Array.isArray(current.scopes) ? current.scopes.filter(
+        (scope) => typeof scope === "string"
+      ) : [],
+      expiresAt: typeof current.expires_at === "string" ? current.expires_at : null,
+      maxExpiresAt: typeof current.max_expires_at === "string" ? current.max_expires_at : null
+    },
+    user
+  };
+}
+async function readJson(response) {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function readErrorBody(body) {
+  if (!isRecord(body) || body.error == null) return null;
+  const { error } = body;
+  if (typeof error === "string") return { code: null, message: error };
+  if (isRecord(error)) {
+    const code = typeof error.code === "string" ? error.code : null;
+    const message = typeof error.message === "string" ? error.message : code ?? JSON.stringify(error);
+    return { code, message };
+  }
+  return { code: null, message: String(error) };
+}
+function describeOpenApiFailure(status, body, url) {
+  const failure = readErrorBody(body);
+  const code = failure?.code ?? null;
+  const detail = failure?.message ? ` Server said: ${failure.message}` : "";
+  if (status === 401) {
+    return new OpenApiError(
+      `Kody rejected the API token (expired, revoked, or malformed). Mint a fresh scoped token and pass it with --token or ${apiTokenEnvVar}.${detail}`,
+      { status, code }
+    );
+  }
+  if (status === 403 && code === "insufficient_scope") {
+    return new OpenApiError(
+      `${insufficientScopeMessage({
+        ...readInsufficientScopeDetails(body),
+        currentLifetime: currentStoredTokenLifetimeAlias(url.origin)
+      })}${detail}`,
+      { status, code }
+    );
+  }
+  if (code === "feature_disabled") {
+    return new OpenApiError(`Kody returned feature_disabled.${detail}`, {
+      status,
+      code
+    });
+  }
+  return new OpenApiError(
+    failure?.message ?? `Kody API request failed with HTTP ${status} (${url.pathname}).`,
+    { status, code }
+  );
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  OpenApiError,
+  openApiDocumentPath,
+  cliCredentialBootstrapRedeemOperationId,
+  openApiGet,
+  openApiRequest,
+  callOpenApiOperation,
+  assertApiOperationAllowed,
+  buildOpenApiHttpRequest,
+  apiOperationUsesQueryInputs,
+  loadOpenApiOperations,
+  indexOpenApiOperations,
+  clearOpenApiRouteCache,
+  searchWithApiToken,
+  toolResultFromHttpBody,
+  whoamiWithApiToken
+};
+//# sourceMappingURL=chunk-W2SAFAT4.js.map