@andreprado/agentkit 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/cli/deploy-readiness.ts

@@ -2,12 +2,14 @@ import { findAgentCapsuleRoot, loadAgentCapsule } from "../runtime/config";
 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,
   readCloudAuthForApiUrl,
   type CloudCapabilitiesResponse,
   type CloudLimitsResponse,
+  type CloudManagedComposioResponse,
   type CloudMeResponse,
   type CloudProjectResolveResponse,
   type CloudSecretsResponse,
@@ -53,6 +55,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",
@@ -104,6 +122,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",
@@ -113,6 +134,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",
@@ -172,6 +204,58 @@ 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 missing toolkit auth config",
+          });
+        } else {
+          checks.push({
+            status: "pass",
+            title: "Managed Composio auth configs",
+            message: `Auth configs are available for ${context.integrations.managedComposio.toolkits.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) {
@@ -184,6 +268,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",
@@ -350,20 +453,26 @@ async function resolveCloudProjectId(apiUrl: string, projectName: string): Promi
 
 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

@@ -41,6 +41,7 @@ Deploy:
 
 More:
   agentkit channels ...
+  agentkit integrations status
   agentkit access token ...
   agentkit env ...
   agentkit docs full
@@ -72,9 +73,9 @@ 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 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>]
@@ -82,6 +83,7 @@ Usage:
   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>]
@@ -89,6 +91,10 @@ Usage:
   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 login --token <token> [--api <url>]
@@ -99,6 +105,7 @@ Usage:
   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>]
@@ -135,6 +142,9 @@ Commands:
   eval            Run local eval files or create one from a conversation
   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
   login           Store an AgentKit Cloud alpha token outside the capsule
@@ -172,12 +182,17 @@ export function renderCommandHelp(command: string): string {
     sync: "agentkit sync init [--force] | agentkit sync run [--file <path>]",
     eval: "agentkit eval run | agentkit eval from-conversation <conversation-id> [--out <path>] [--force]",
     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>",
+    integrations: "agentkit integrations status [--toolkit <slug>] | agentkit integrations connect composio [--toolkit <slug>]",
     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]",

package/src/cli/index.ts

@@ -22,6 +22,7 @@ import { runEvalsFromCwd, writeEvalFromConversation } from "../runtime/evals";
 import { findAgentKitDocs } from "../runtime/docs";
 import { listCapsuleEnv, setCapsuleEnv, unsetCapsuleEnv } from "../runtime/env";
 import { checkAgentSpec, initializeAgentSpec } from "../runtime/spec";
+import { checkDefaultSkillStatus, syncDefaultSkillFiles } from "../runtime/skills";
 import { initializeSyncScaffold, runCapsuleSync } from "../runtime/sync";
 import { runToolFromCwd } from "../runtime/tool-runner";
 import { startAgentDevServer } from "../runtime/dev-server";
@@ -67,6 +68,7 @@ import { renderCommandHelp, renderCommandReference, renderHelp } from "./help";
 import { runInheritedCommand, waitForShutdown } from "./process";
 import { handleChannelsCommand } from "./commands/channels";
 import { handleKnowledgeCommand } from "./commands/knowledge";
+import { handleTranscribeCommand } from "./commands/transcribe";
 
 async function main() {
   const args = parseArgs(process.argv.slice(2));
@@ -336,8 +338,15 @@ async function main() {
 
   if (args.command === "conversations") {
     const [subcommand, conversationId] = args.positional;
+    const fromDeploy = args.flags.deploy === true;
 
     if (subcommand === "list") {
+      if (fromDeploy) {
+        const payload = await fetchDeployConversationJson(process.cwd(), "/v1/conversations");
+        printJson(payload);
+        return;
+      }
+
       const conversations = await listConversationsFromCwd(process.cwd());
 
       if (conversations.length === 0) {
@@ -363,7 +372,16 @@ async function main() {
 
     if (subcommand === "show") {
       if (!conversationId) {
-        throw new Error("Missing conversation id. Usage: agentkit conversations show <conversation-id>");
+        throw new Error("Missing conversation id. Usage: agentkit conversations show <conversation-id> [--deploy]");
+      }
+
+      if (fromDeploy) {
+        const payload = await fetchDeployConversationJson(
+          process.cwd(),
+          `/v1/conversations/${encodeURIComponent(conversationId)}`,
+        );
+        printJson(payload);
+        return;
       }
 
       const conversation = await getConversationFromCwd(process.cwd(), conversationId);
@@ -382,7 +400,16 @@ async function main() {
 
     if (subcommand === "trace") {
       if (!conversationId) {
-        throw new Error("Missing conversation id. Usage: agentkit conversations trace <conversation-id>");
+        throw new Error("Missing conversation id. Usage: agentkit conversations trace <conversation-id> [--deploy]");
+      }
+
+      if (fromDeploy) {
+        const trace = await fetchDeployConversationJson(
+          process.cwd(),
+          `/v1/conversations/${encodeURIComponent(conversationId)}/trace`,
+        );
+        printJson(trace);
+        return;
       }
 
       const trace = await getConversationTraceFromCwd(process.cwd(), conversationId);
@@ -390,7 +417,7 @@ async function main() {
       return;
     }
 
-    throw new Error("Usage: agentkit conversations list | agentkit conversations show <conversation-id> | agentkit conversations trace <conversation-id>");
+    throw new Error("Usage: agentkit conversations list [--deploy] | agentkit conversations show <conversation-id> [--deploy] | agentkit conversations trace <conversation-id> [--deploy]");
   }
 
   if (args.command === "knowledge") {
@@ -764,6 +791,117 @@ async function main() {
     return;
   }
 
+  if (args.command === "transcribe") {
+    await handleTranscribeCommand(args);
+    return;
+  }
+
+  if (args.command === "skills") {
+    const [subcommand] = args.positional;
+    const root = await findAgentCapsuleRoot(process.cwd());
+
+    if (subcommand === "status") {
+      const status = await checkDefaultSkillStatus(root);
+      printSkillStatus(status);
+      if (status.status !== "current") {
+        process.exitCode = 1;
+      }
+      return;
+    }
+
+    if (subcommand === "sync") {
+      const result = await syncDefaultSkillFiles(root);
+      console.log(`Synced ${result.files.length} AgentKit skill files.`);
+      console.log("Status: current");
+      return;
+    }
+
+    throw new Error("Usage: agentkit skills status | agentkit skills sync");
+  }
+
+  if (args.command === "integrations") {
+    const [subcommand, provider] = args.positional;
+
+    if (provider !== undefined && provider !== "composio") {
+      throw new Error("Usage: agentkit integrations status | connect composio [--toolkit <slug>] [--callback-url <url>] [--api <url>]");
+    }
+
+    const state = await requireLocalDeployState();
+    const apiUrl = await resolveCloudApiUrl(args.flags.api);
+
+    if (subcommand === "status") {
+      const toolkit = parseOptionalStringFlag(
+        args.flags.toolkit,
+        "toolkit",
+        "agentkit integrations status --toolkit <slug>",
+      );
+      const payload = await cloudApiRequest(
+        apiUrl,
+        `/v1/deploys/${encodeURIComponent(state.deploy_id)}/integrations/composio/status${
+          toolkit ? `?toolkit=${encodeURIComponent(toolkit)}` : ""
+        }`,
+        { method: "GET" },
+      );
+      printJson(payload);
+      return;
+    }
+
+    if (subcommand === "connect" && provider === "composio") {
+      const toolkit = parseOptionalStringFlag(
+        args.flags.toolkit,
+        "toolkit",
+        "agentkit integrations connect composio --toolkit <slug>",
+      );
+      const callbackUrl = parseOptionalStringFlag(
+        args.flags["callback-url"],
+        "callback-url",
+        "agentkit integrations connect composio --callback-url <url>",
+      );
+      const payload = (await cloudApiRequest(
+        apiUrl,
+        `/v1/deploys/${encodeURIComponent(state.deploy_id)}/integrations/composio/connect-link`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            ...(toolkit ? { toolkit } : {}),
+            ...(callbackUrl ? { callback_url: callbackUrl } : {}),
+          }),
+        },
+      )) as {
+        connect_link?: {
+          toolkit?: string;
+          user_id?: string;
+          redirect_url?: string;
+          expires_at?: string;
+          connected_account_id?: string;
+        };
+      };
+
+      const link = payload.connect_link;
+
+      if (!link?.redirect_url) {
+        throw new AgentKitError("integration_response_invalid", "AgentKit Cloud returned an invalid Composio connect-link payload.");
+      }
+
+      console.log("Composio connect link");
+      console.log(`Toolkit: ${link.toolkit ?? toolkit ?? "unknown"}`);
+      console.log(`User:    ${link.user_id ?? "unknown"}`);
+      console.log(`URL:     ${link.redirect_url}`);
+
+      if (link.expires_at) {
+        console.log(`Expires: ${link.expires_at}`);
+      }
+
+      if (link.connected_account_id) {
+        console.log(`Account: ${link.connected_account_id}`);
+      }
+
+      return;
+    }
+
+    throw new Error("Usage: agentkit integrations status | connect composio [--toolkit <slug>] [--callback-url <url>] [--api <url>]");
+  }
+
   if (args.command === "env") {
     const [subcommand, name, ...valueParts] = args.positional;
     const root = await findAgentCapsuleRoot(process.cwd());
@@ -1074,10 +1212,67 @@ async function runDeploySmoke(input: { deployUrl: string; message: string; token
   }
 }
 
+async function fetchDeployConversationJson(cwd: string, path: string): Promise<unknown> {
+  const state = await requireLocalDeployState();
+  const deployUrl = requireDeployUrl(state);
+  const token = await readDeployAccessTokenForSmoke(cwd, state);
+  const headers = new Headers();
+
+  if (token) {
+    headers.set("Authorization", `Bearer ${token}`);
+  }
+
+  let response: Response;
+
+  try {
+    response = await fetch(new URL(path, deployUrl).href, {
+      method: "GET",
+      headers,
+    });
+  } catch (error) {
+    throw new AgentKitError(
+      "deploy_conversation_request_failed",
+      `Could not read hosted conversation data: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  const payload = await response.json().catch(() => null);
+
+  if (!response.ok) {
+    throw new AgentKitError("deploy_conversation_request_failed", readCloudError(payload, response.status));
+  }
+
+  return payload;
+}
+
 function printJson(value: unknown): void {
   console.log(JSON.stringify(value, null, 2));
 }
 
+function printSkillStatus(status: Awaited<ReturnType<typeof checkDefaultSkillStatus>>): void {
+  console.log("AgentKit skills");
+  console.log(`Status: ${status.status}`);
+  console.log(`Checked: ${status.checked}`);
+
+  if (status.missing.length > 0) {
+    console.log(`Missing: ${status.missing.length}`);
+    for (const file of status.missing.slice(0, 10)) {
+      console.log(`  ${file}`);
+    }
+  }
+
+  if (status.outdated.length > 0) {
+    console.log(`Outdated: ${status.outdated.length}`);
+    for (const file of status.outdated.slice(0, 10)) {
+      console.log(`  ${file}`);
+    }
+  }
+
+  if (status.status !== "current") {
+    console.log("Run: npm run agentkit -- skills sync");
+  }
+}
+
 async function printJsonOrWrite(value: unknown, outFlag: string | boolean | undefined, usage: string): Promise<void> {
   const outPath = parseOptionalStringFlag(outFlag, "out", usage);
 

package/src/create-project.ts

@@ -1,10 +1,11 @@
 import { execFile } from "node:child_process";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
 
-import { getTemplate, type TemplateFile } from "./templates";
+import { loadDefaultSkillFiles } from "./runtime/skills";
+import { getTemplate } from "./templates";
 
 const execFileAsync = promisify(execFile);
 const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -129,35 +130,6 @@ async function resolveAgentKitDependency(): Promise<string> {
   return packageJson.version;
 }
 
-async function loadDefaultSkillFiles(): Promise<TemplateFile[]> {
-  const sourceRoot = join(moduleDir, "templates", "skills");
-  const sourceFiles = await listFiles(sourceRoot);
-
-  return Promise.all(
-    sourceFiles.map(async (sourcePath) => ({
-      path: join("skills", relative(sourceRoot, sourcePath)).replaceAll("\\", "/"),
-      contents: await readFile(sourcePath, "utf8"),
-    })),
-  );
-}
-
-async function listFiles(directory: string): Promise<string[]> {
-  const entries = await readdir(directory, { withFileTypes: true });
-  const files = await Promise.all(
-    entries.map(async (entry) => {
-      const path = join(directory, entry.name);
-
-      if (entry.isDirectory()) {
-        return listFiles(path);
-      }
-
-      return entry.isFile() ? [path] : [];
-    }),
-  );
-
-  return files.flat().sort();
-}
-
 async function directoryExists(path: string): Promise<boolean> {
   try {
     const result = await stat(path);