@andreprado/agentkit 0.1.0-alpha.9 → 0.1.1

package/src/cli/deploy-readiness.ts

@@ -1,15 +1,17 @@
 import { findAgentCapsuleRoot, loadAgentCapsule } from "../runtime/config";
-import { readLocalDeployStateIfExists } from "../runtime/core/deploy-state";
-import { loadDeployReadinessContext, stableCloudProjectId, type DeployReadinessContext } from "../runtime/deploy-readiness";
+import { loadDeployReadinessContext, type DeployReadinessContext } from "../runtime/deploy-readiness";
 import { loadCapsuleEnv } from "../runtime/env";
 import { isAgentKitError } from "../runtime/errors";
+import { MANAGED_COMPOSIO_API_KEY_SECRET, MANAGED_COMPOSIO_ENTITLEMENT } from "../runtime/integrations/composio";
 import {
   cloudApiRequest,
   formatCloudAuthSource,
-  readCloudAuth,
+  readCloudAuthForApiUrl,
   type CloudCapabilitiesResponse,
   type CloudLimitsResponse,
+  type CloudManagedComposioResponse,
   type CloudMeResponse,
+  type CloudProjectResolveResponse,
   type CloudSecretsResponse,
 } from "./cloud-client";
 
@@ -27,6 +29,16 @@ type DeployReadinessReport = {
   apiUrl: string;
   context: DeployReadinessContext;
   checks: DeployReadinessCheck[];
+  cloudAuth: {
+    source?: string;
+    accountEmail?: string;
+  };
+  onlineCapacity: {
+    accountUsed?: number;
+    accountLimit?: number;
+    globalUsed?: number;
+    globalLimit?: number;
+  };
 };
 
 export async function checkDeployReadiness(options: {
@@ -34,9 +46,15 @@ export async function checkDeployReadiness(options: {
   requireLogin: boolean;
 }): Promise<DeployReadinessReport> {
   const context = await loadDeployReadinessContext(process.cwd(), process.env);
-  const auth = await readCloudAuth();
+  const auth = options.requireLogin ? await readCloudAuthForApiUrl(options.apiUrl) : null;
   const checks: DeployReadinessCheck[] = [];
   let cloudAuthUsable = false;
+  const cloudAuth: DeployReadinessReport["cloudAuth"] = {};
+  const onlineCapacity: DeployReadinessReport["onlineCapacity"] = {};
+
+  if (auth?.token) {
+    cloudAuth.source = formatCloudAuthSource(auth);
+  }
 
   if (context.runtime !== "edge") {
     checks.push({
@@ -53,6 +71,22 @@ export async function checkDeployReadiness(options: {
     });
   }
 
+  const nodeMajor = majorNodeVersion(process.versions.node);
+  if (nodeMajor !== null && nodeMajor < 24) {
+    checks.push({
+      status: "warn",
+      title: "Node version",
+      message: `@andreprado/agentkit requires Node >=24; current Node is ${process.versions.node}.`,
+      action: "use Node 24+ before running direct node imports or production container commands",
+    });
+  } else {
+    checks.push({
+      status: "pass",
+      title: "Node version",
+      message: `Node ${process.versions.node} satisfies @andreprado/agentkit engines.node >=24.`,
+    });
+  }
+
   if (!auth?.token) {
     checks.push({
       status: options.requireLogin ? "fail" : "warn",
@@ -66,6 +100,9 @@ export async function checkDeployReadiness(options: {
     try {
       const me = (await cloudApiRequest(options.apiUrl, "/v1/me", { method: "GET" })) as CloudMeResponse;
       const email = me.account?.email;
+      if (email) {
+        cloudAuth.accountEmail = email;
+      }
       checks.push({
         status: "pass",
         title: "Login",
@@ -82,6 +119,19 @@ export async function checkDeployReadiness(options: {
     }
   }
 
+  if (cloudAuthUsable) {
+    try {
+      context.projectId = await resolveCloudProjectId(options.apiUrl, context.projectName);
+    } catch (error) {
+      checks.push({
+        status: "fail",
+        title: "Project identity",
+        message: `Could not resolve the account-scoped AgentKit Cloud project. ${formatReadinessError(error)}`,
+      });
+      cloudAuthUsable = false;
+    }
+  }
+
   if (cloudAuthUsable) {
     try {
       const payload = (await cloudApiRequest(options.apiUrl, "/v1/me/capabilities", {
@@ -91,6 +141,9 @@ export async function checkDeployReadiness(options: {
       const hasCloudflareAlpha = capabilities.some(
         (capability) => capability.name === "cloudflare_deploy_alpha" && capability.status === "active",
       );
+      const hasManagedComposio = capabilities.some(
+        (capability) => capability.name === MANAGED_COMPOSIO_ENTITLEMENT && capability.status === "active",
+      );
 
       checks.push({
         status: hasCloudflareAlpha ? "pass" : "fail",
@@ -100,6 +153,17 @@ export async function checkDeployReadiness(options: {
           : "This account is missing the cloudflare_deploy_alpha entitlement.",
         ...(hasCloudflareAlpha ? {} : { action: "log in with an invited AgentKit Cloud alpha token" }),
       });
+
+      if (context.integrations.managedComposio.enabled) {
+        checks.push({
+          status: hasManagedComposio ? "pass" : "fail",
+          title: "Managed Composio entitlement",
+          message: hasManagedComposio
+            ? `${MANAGED_COMPOSIO_ENTITLEMENT} is active.`
+            : `This capsule uses AgentKit-managed Composio, but this account is missing ${MANAGED_COMPOSIO_ENTITLEMENT}.`,
+          ...(hasManagedComposio ? {} : { action: "upgrade the AgentKit Cloud account or ask an operator to grant managed_composio" }),
+        });
+      }
     } catch (error) {
       checks.push({
         status: "fail",
@@ -119,6 +183,22 @@ export async function checkDeployReadiness(options: {
       const globalLimit = normalizeOptionalNumber(global?.limit);
       const globalUsed = normalizeOptionalNumber(global?.used);
 
+      if (accountLimit !== undefined) {
+        onlineCapacity.accountLimit = accountLimit;
+      }
+
+      if (accountUsed !== undefined) {
+        onlineCapacity.accountUsed = accountUsed;
+      }
+
+      if (globalLimit !== undefined) {
+        onlineCapacity.globalLimit = globalLimit;
+      }
+
+      if (globalUsed !== undefined) {
+        onlineCapacity.globalUsed = globalUsed;
+      }
+
       if (accountLimit !== undefined && accountUsed !== undefined && accountUsed >= accountLimit) {
         checks.push({
           status: "fail",
@@ -159,6 +239,61 @@ export async function checkDeployReadiness(options: {
         message: `Could not verify online deploy capacity. ${formatReadinessError(error)}`,
       });
     }
+
+    if (context.integrations.managedComposio.enabled) {
+      try {
+        const payload = (await cloudApiRequest(
+          options.apiUrl,
+          `/v1/me/managed-composio?toolkits=${encodeURIComponent(context.integrations.managedComposio.toolkits.join(","))}`,
+          {
+            method: "GET",
+          },
+        )) as CloudManagedComposioResponse;
+        const managed = payload.managed_composio;
+        const missingToolkits = (managed?.toolkits ?? []).filter((toolkit) => toolkit.auth_config !== "set");
+
+        if (managed?.api_key !== "set") {
+          checks.push({
+            status: "fail",
+            title: "Managed Composio API key",
+            message: `AgentKit Cloud is missing AGENTKIT_SECRET_${MANAGED_COMPOSIO_API_KEY_SECRET}.`,
+            action: "ask the AgentKit Cloud operator to configure managed Composio",
+          });
+        } else {
+          checks.push({
+            status: "pass",
+            title: "Managed Composio API key",
+            message: "AgentKit Cloud has the managed COMPOSIO_API_KEY.",
+          });
+        }
+
+        if (missingToolkits.length > 0) {
+          checks.push({
+            status: "fail",
+            title: "Managed Composio auth configs",
+            message: `Missing ${missingToolkits
+              .map((toolkit) => `${toolkit.auth_config_env ?? "auth config"} for ${toolkit.toolkit ?? "unknown"}`)
+              .join(", ")}.`,
+            action: "ask the AgentKit Cloud operator to configure the Composio auth config registry or fallback env",
+          });
+        } else {
+          const toolkitSources = (managed?.toolkits ?? []).map((toolkit) =>
+            `${toolkit.toolkit ?? "unknown"}${toolkit.auth_config_source ? ` via ${toolkit.auth_config_source}` : ""}`,
+          );
+          checks.push({
+            status: "pass",
+            title: "Managed Composio auth configs",
+            message: `Auth configs are available for ${toolkitSources.join(", ")}.`,
+          });
+        }
+      } catch (error) {
+        checks.push({
+          status: "warn",
+          title: "Managed Composio auth configs",
+          message: `Could not verify managed Composio auth configs. ${formatReadinessError(error)}`,
+        });
+      }
+    }
   }
 
   if (context.agentKitManagedSecrets.length > 0) {
@@ -171,6 +306,25 @@ export async function checkDeployReadiness(options: {
     });
   }
 
+  if (context.integrations.managedComposio.enabled) {
+    if (!options.requireLogin) {
+      checks.push({
+        status: "fail",
+        title: "Managed Composio access",
+        message: "AgentKit-managed Composio is paid hosted infrastructure and cannot be used by anonymous deploys.",
+        action: "run agentkit deploy without --anonymous after logging in with a paid AgentKit Cloud account",
+      });
+    } else {
+      checks.push({
+        status: "info",
+        title: "Managed Composio",
+        message: `Configured for ${context.integrations.managedComposio.toolkits.join(", ")} with ${
+          context.integrations.managedComposio.toolCount
+        } allowed action${context.integrations.managedComposio.toolCount === 1 ? "" : "s"}. AgentKit Cloud injects COMPOSIO_API_KEY.`,
+      });
+    }
+  }
+
   if (context.accessMode === "private") {
     checks.push({
       status: "info",
@@ -255,6 +409,8 @@ export async function checkDeployReadiness(options: {
     apiUrl: options.apiUrl,
     context,
     checks,
+    cloudAuth,
+    onlineCapacity,
   };
 }
 
@@ -264,6 +420,19 @@ export function printDeployReadinessReport(report: DeployReadinessReport): void
   console.log(`Project ID: ${report.context.projectId}`);
   console.log(`Target: ${report.context.target}`);
   console.log(`API: ${report.apiUrl}`);
+  const authSummary = formatDeployCloudAuthSummary(report);
+
+  if (authSummary) {
+    console.log(`Account: ${authSummary.account}`);
+    console.log(`Auth source: ${authSummary.source}`);
+  }
+
+  const capacitySummary = formatDeployOnlineCapacity(report, "current");
+
+  if (capacitySummary) {
+    console.log(`Capacity: ${capacitySummary}`);
+  }
+
   console.log("");
 
   for (const check of report.checks) {
@@ -275,6 +444,36 @@ export function printDeployReadinessReport(report: DeployReadinessReport): void
   }
 }
 
+export function formatDeployCloudAuthSummary(
+  report: DeployReadinessReport,
+): { account: string; source: string } | null {
+  if (!report.cloudAuth.accountEmail || !report.cloudAuth.source) {
+    return null;
+  }
+
+  return {
+    account: report.cloudAuth.accountEmail,
+    source: report.cloudAuth.source,
+  };
+}
+
+export function formatDeployOnlineCapacity(
+  report: DeployReadinessReport,
+  timing: "current" | "before deploy",
+): string | null {
+  const suffix = timing === "before deploy" ? " before deploy" : "";
+
+  if (report.onlineCapacity.accountUsed !== undefined && report.onlineCapacity.accountLimit !== undefined) {
+    return `${report.onlineCapacity.accountUsed}/${report.onlineCapacity.accountLimit} account online deploy slots in use${suffix}`;
+  }
+
+  if (report.onlineCapacity.globalUsed !== undefined && report.onlineCapacity.globalLimit !== undefined) {
+    return `${report.onlineCapacity.globalUsed}/${report.onlineCapacity.globalLimit} global online deploy slots in use${suffix}`;
+  }
+
+  return null;
+}
+
 export async function syncHostedSecretsFromLocal(options: { apiUrl: string; projectId: string }): Promise<void> {
   const context = await loadDeployReadinessContext(process.cwd(), process.env);
   const localEnv = await loadCapsuleEnv(context.root, {});
@@ -315,34 +514,48 @@ export function formatReadinessError(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-export async function resolveProjectIdForSecretCommand(cwd: string): Promise<string> {
-  const state = await readLocalDeployStateIfExists(cwd);
+export async function resolveProjectIdForSecretCommand(cwd: string, apiUrl: string): Promise<string> {
+  const root = await findAgentCapsuleRoot(cwd);
+  const capsule = await loadAgentCapsule(root);
+  return resolveCloudProjectId(apiUrl, capsule.config.name);
+}
 
-  if (state?.project_id) {
-    return state.project_id;
+async function resolveCloudProjectId(apiUrl: string, projectName: string): Promise<string> {
+  const payload = (await cloudApiRequest(apiUrl, "/v1/projects/resolve", {
+    method: "POST",
+    body: JSON.stringify({ project_name: projectName }),
+  })) as CloudProjectResolveResponse;
+  const projectId = payload.project?.id;
+
+  if (!projectId) {
+    throw new Error("AgentKit Cloud did not return a project id.");
   }
 
-  const root = await findAgentCapsuleRoot(cwd);
-  const capsule = await loadAgentCapsule(root);
-  return stableCloudProjectId(capsule.config.name);
+  return projectId;
 }
 
 function secretSetCommand(secret: string, source: DeployReadinessContext["localSecrets"][string] | undefined): string {
   if (source?.dotenv) {
-    return `agentkit secret set ${secret} --from-local-env`;
+    return `npm run agentkit -- secret set ${secret} --from-local-env`;
   }
 
   if (source?.environment) {
-    return `agentkit secret set ${secret} --from-env`;
+    return `npm run agentkit -- secret set ${secret} --from-env`;
   }
 
-  return `agentkit secret set ${secret} --stdin`;
+  return `npm run agentkit -- secret set ${secret} --stdin`;
 }
 
 function normalizeOptionalNumber(value: number | null | undefined): number | undefined {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
+function majorNodeVersion(version: string): number | null {
+  const [major] = version.split(".");
+  const parsed = Number(major);
+  return Number.isInteger(parsed) ? parsed : null;
+}
+
 function isString(value: unknown): value is string {
   return typeof value === "string";
 }

package/src/cli/help.ts

@@ -13,7 +13,7 @@ Usage:
   agentkit <command> [options]
 
 Start:
-  agentkit new <name> [--template blank|support|dentista] [--no-install]
+  agentkit new [name] [--template blank|support|dentista] [--no-install]
   agentkit dev
   agentkit open
   agentkit chat-ui --deploy
@@ -29,6 +29,9 @@ Build:
   agentkit db migrate
   agentkit eval run
   agentkit eval from-conversation <id>
+  agentkit improve collect --deploy --since 24h
+  agentkit feedback create --about last-run --kind bug --summary <text>
+  agentkit replay <bundle-dir> --against local
   agentkit conversations list
 
 Deploy:
@@ -41,8 +44,13 @@ Deploy:
 
 More:
   agentkit channels ...
+  agentkit integrations status
+  agentkit billing checkout --slots <count>
+  agentkit account token ...
   agentkit access token ...
+  agentkit provider login openai-codex
   agentkit env ...
+  agentkit feedback create --summary <text>
   agentkit docs full
   agentkit help commands
 `;
@@ -52,7 +60,7 @@ export function renderCommandReference(): string {
   return `AgentKit Command Reference
 
 Usage:
-  agentkit new <name> [--template blank|support|dentista] [--no-install]
+  agentkit new [name] [--template blank|support|dentista] [--no-install]
   agentkit dev [--port <number>]
   agentkit open
   agentkit chat-ui --deploy [--port <number>] [--token-file <path>]
@@ -72,28 +80,53 @@ Usage:
   agentkit db seed [--file <path>]
   agentkit eval run
   agentkit eval from-conversation <conversation-id> [--out <path>] [--force]
-  agentkit conversations list
-  agentkit conversations show <conversation-id>
-  agentkit conversations trace <conversation-id>
+  agentkit improve collect [--deploy] [--since <duration|iso>] [--conversation-id <id>] [--out <directory>]
+  agentkit improve evals <bundle-dir-or-json> [--force]
+  agentkit feedback create [--about last-run|deploy|manual] [--kind bug|confusion|missing_docs|feature_request|deploy_issue|runtime_issue|other] --summary <text> [--message <text>] [--out <path>]
+  agentkit feedback preview [draft.json]
+  agentkit feedback send [draft.json] [--about last-run|deploy|manual] [--kind <kind>] --summary <text> [--message <text>] [--api <url>] [--save]
+  agentkit replay <bundle-dir-or-json> --against local
+  agentkit conversations list [--deploy]
+  agentkit conversations show <conversation-id> [--deploy]
+  agentkit conversations trace <conversation-id> [--deploy]
   agentkit channels list
-  agentkit channels add <website|telegram|whatsapp> <name> [--provider zapster|meta] [--api <url>]
-  agentkit channels connect <website|telegram|whatsapp> <name> [--provider zapster|meta] [--api <url>]
+  agentkit channels add <website|telegram|whatsapp|discord|slack|webhook> <name> [--provider zapster|meta|uazapi|evolution] [--mode interactions|bot] [--api <url>]
+  agentkit channels connect <website|telegram|whatsapp|discord|slack|webhook> <name> [--provider zapster|meta|uazapi|evolution] [--mode interactions|bot] [--api <url>]
   agentkit channels setup <name> [--apply] [--api <url>]
   agentkit channels status <name> [--api <url>]
   agentkit channels doctor <name> [--api <url>]
   agentkit channels test <name> [--message <text>] [--fixture <path>] [--api <url>]
+  agentkit channels test-audio <name> [--fixture voice-note|audio-file|<path>] [--api <url>]
   agentkit channels deliveries list <name> [--api <url>]
   agentkit channels deliveries show <delivery-id> [--api <url>]
+  agentkit channels buffers list <name> [--api <url>]
+  agentkit channels buffers show [<name>] <conversation-id> [--api <url>]
+  agentkit channels buffers flush [<name>] <conversation-id> [--api <url>]
+  agentkit channels buffers clear [<name>] <conversation-id> [--api <url>]
+  agentkit channels buffers retry [<name>] <conversation-id> [--api <url>]
+  agentkit integrations status [--toolkit <slug>] [--api <url>]
+  agentkit integrations connect composio [--toolkit <slug>] [--callback-url <url>] [--api <url>]
+  agentkit skills status
+  agentkit skills sync
   agentkit inspect
   agentkit build [--target cloudflare|container]
+  agentkit provider login|status|logout openai-codex
   agentkit login --token <token> [--api <url>]
   agentkit logout
+  agentkit billing checkout --slots <count> [--email <email>] [--api <url>]
+  agentkit billing status <billing-intent-id> --secret <secret> [--api <url>]
+  agentkit billing claim <billing-intent-id> --secret <secret> [--token-name <name>] [--api <url>]
+  agentkit billing portal [--api <url>]
+  agentkit account token create <name> [--api <url>] [--use] [--out <path>]
+  agentkit account token list [--api <url>]
+  agentkit account token revoke <token-id> [--api <url>]
   agentkit deploy [--target cloudflare|vps] [--host <host>] [--api <url>] [--dry-run] [--anonymous] [--local-wrangler] [--smoke <message>]
   agentkit deploy doctor [--api <url>] [--anonymous]
   agentkit deploy smoke [--message <text>] [--api <url>]
   agentkit deploy status [--api <url>]
   agentkit deploy pause [--api <url>]
   agentkit deploy resume [--api <url>]
+  agentkit transcribe smoke [--provider test|openai|groq] [--model <model>] [--fixture <audio-file>]
   agentkit secret set <NAME> <VALUE> [--api <url>]
   agentkit secret set <NAME> --stdin [--api <url>]
   agentkit secret set <NAME> --from-env [ENV_NAME] [--api <url>]
@@ -128,12 +161,21 @@ Commands:
   sync            Run or scaffold catalog/data synchronization
   db              Manage the local SQLite database
   eval            Run local eval files or create one from a conversation
+  improve         Collect production or local traces and generate regression evals
+  feedback        Create local redacted feedback drafts and send them to AgentKit Cloud
+  replay          Replay an improve bundle against the local Agent Capsule
   conversations   List, inspect, and trace stored local conversations
   channels        Manage hosted channel resources
+  integrations    Manage hosted AgentKit-managed integrations
+  skills          Check or refresh local AgentKit skill files
+  transcribe      Smoke-test audio transcription providers
   inspect         Print machine-readable Agent Capsule state
   build           Build a hosted deploy artifact
+  provider        Manage local model-provider login
   login           Store an AgentKit Cloud alpha token outside the capsule
   logout          Remove the stored AgentKit Cloud alpha token
+  billing         Buy deploy slots, claim checkout tokens, and open the billing portal
+  account         Manage AgentKit Cloud account tokens
   deploy          Build and send a hosted artifact to AgentKit Cloud
   secret          Manage hosted AgentKit Cloud secrets without readback
   access          Manage hosted deploy access tokens
@@ -150,13 +192,15 @@ Examples:
   agentkit tool lookup_order --input '{"orderId":"A100"}'
   agentkit eval run
 
+  agentkit new
+  agentkit new .
   agentkit new clara-dentista --template dentista
 `;
 }
 
 export function renderCommandHelp(command: string): string {
   const usage: Record<string, string> = {
-    new: "agentkit new <name> [--template blank|support|dentista] [--no-install]",
+    new: "agentkit new [name] [--template blank|support|dentista] [--no-install]",
     dev: "agentkit dev [--port <number>]",
     open: "agentkit open",
     "chat-ui": "agentkit chat-ui --deploy [--port <number>] [--token-file <path>]",
@@ -166,13 +210,27 @@ export function renderCommandHelp(command: string): string {
     spec: 'agentkit spec init --brief "owner request" | agentkit spec check',
     sync: "agentkit sync init [--force] | agentkit sync run [--file <path>]",
     eval: "agentkit eval run | agentkit eval from-conversation <conversation-id> [--out <path>] [--force]",
+    improve:
+      "agentkit improve collect [--deploy] [--since <duration|iso>] [--conversation-id <id>] [--out <directory>] | agentkit improve evals <bundle-dir-or-json> [--force]",
+    feedback:
+      "agentkit feedback create|preview|send [draft.json] [--about last-run|deploy|manual] [--kind <kind>] [--summary <text>] [--message <text>]",
+    replay: "agentkit replay <bundle-dir-or-json> --against local",
     conversations:
-      "agentkit conversations list | agentkit conversations show <conversation-id> | agentkit conversations trace <conversation-id>",
+      "agentkit conversations list [--deploy] | agentkit conversations show <conversation-id> [--deploy] | agentkit conversations trace <conversation-id> [--deploy]",
+    channels:
+      "agentkit channels list | add | connect | setup | status | doctor | test | test-audio | deliveries | buffers",
+    skills: "agentkit skills status | agentkit skills sync",
+    transcribe: "agentkit transcribe smoke [--provider test|openai|groq] [--model <model>] [--fixture <audio-file>]",
     deploy:
       'agentkit deploy [--smoke "hello"] | agentkit deploy smoke [--message "hello"] | agentkit deploy doctor | status | pause | resume',
     secret:
       "agentkit secret set <NAME> --stdin | --from-env [ENV_NAME] | --from-local-env | agentkit secret sync --from-local | list | unset <NAME>",
     access: "agentkit access token create <name> [--out <path>] | list | revoke <token-id>",
+    account: "agentkit account token create <name> [--use] [--out <path>] | list | revoke <token-id>",
+    billing:
+      "agentkit billing checkout --slots <count> [--email <email>] | status <intent-id> --secret <secret> | claim <intent-id> --secret <secret> | portal",
+    integrations: "agentkit integrations status [--toolkit <slug>] | agentkit integrations connect composio [--toolkit <slug>]",
+    provider: "agentkit provider login|status|logout openai-codex",
     env: "agentkit env set <NAME> --stdin | --from-env [ENV_NAME] | list | unset <NAME>",
     docs: "agentkit docs path | llms | full",
     handoff: "agentkit handoff codex [goal] | agentkit handoff claude [goal]",