@andreprado/agentkit 0.1.0-alpha.3 → 0.1.0-alpha.5

package/src/cli/deploy-chat-ui.ts

@@ -0,0 +1,385 @@
+import { readFile } from "node:fs/promises";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { join, relative, resolve } from "node:path";
+
+import { findAgentCapsuleRoot } from "../runtime/config";
+import { readLocalDeployStateIfExists } from "../runtime/core/deploy-state";
+import { AgentKitError, isAgentKitError } from "../runtime/errors";
+import { defaultDeployChatAccessTokenName, defaultDeployChatAccessTokenPath } from "./constants";
+
+export async function startDeployChatUiServer(
+  cwd: string,
+  options: { port: number; tokenFile?: string },
+): Promise<{ url: string; deployUrl: string; tokenSource: string; stop(): Promise<void> }> {
+  const root = await findAgentCapsuleRoot(cwd);
+  const state = await readLocalDeployStateIfExists(root);
+
+  if (!state?.url) {
+    throw new Error("No hosted deploy URL found. Run agentkit deploy first.");
+  }
+
+  const tokenPath = options.tokenFile
+    ? resolve(root, options.tokenFile)
+    : join(root, defaultDeployChatAccessTokenPath);
+  const hostname = "localhost";
+  const deployUrl = state.url;
+  const server = createServer(async (request, response) => {
+    try {
+      const requestUrl = new URL(request.url ?? "/", `http://${request.headers.host ?? `${hostname}:${options.port}`}`);
+
+      if (request.method === "GET" && requestUrl.pathname === "/") {
+        sendHtml(response, renderDeployChatUi({ deployUrl }));
+        return;
+      }
+
+      if (request.method === "GET" && requestUrl.pathname === "/health") {
+        sendJson(response, 200, { status: "ok", target: "deploy-chat-ui", deployUrl });
+        return;
+      }
+
+      if (request.method === "GET" && requestUrl.pathname === "/_agentkit") {
+        sendJson(response, 200, {
+          deployUrl,
+          access: "proxied",
+          tokenSource: process.env.AGENTKIT_DEPLOY_ACCESS_TOKEN ? "AGENTKIT_DEPLOY_ACCESS_TOKEN" : relativePath(root, tokenPath),
+        });
+        return;
+      }
+
+      if (request.method === "POST" && (requestUrl.pathname === "/v1/chat" || requestUrl.pathname === "/chat")) {
+        const token = await readDeployAccessTokenForUi(tokenPath);
+        const body = await readIncomingBody(request);
+        const contentTypeHeader = request.headers["content-type"];
+        const contentType = Array.isArray(contentTypeHeader)
+          ? contentTypeHeader[0] ?? "application/json"
+          : contentTypeHeader ?? "application/json";
+        const upstream = await fetch(new URL("/v1/chat", deployUrl).href, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": contentType,
+          },
+          body,
+        });
+        const text = await upstream.text();
+
+        response.writeHead(upstream.status, {
+          "content-type": upstream.headers.get("content-type") ?? "application/json",
+        });
+        response.end(text);
+        return;
+      }
+
+      sendJson(response, 404, { error: { code: "not_found", message: "Route not found." } });
+    } catch (error) {
+      sendJson(response, 500, {
+        error: {
+          code: isAgentKitError(error) ? error.code : "deploy_chat_ui_error",
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
+  await new Promise<void>((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, hostname, () => {
+      server.off("error", reject);
+      resolvePromise();
+    });
+  });
+
+  return {
+    url: `http://${hostname}:${options.port}`,
+    deployUrl,
+    tokenSource: process.env.AGENTKIT_DEPLOY_ACCESS_TOKEN ? "AGENTKIT_DEPLOY_ACCESS_TOKEN" : relativePath(root, tokenPath),
+    stop: () =>
+      new Promise<void>((resolvePromise, reject) => {
+        server.close((error) => (error ? reject(error) : resolvePromise()));
+      }),
+  };
+}
+
+export async function readDeployAccessTokenForUi(tokenPath: string): Promise<string> {
+  if (process.env.AGENTKIT_DEPLOY_ACCESS_TOKEN) {
+    return process.env.AGENTKIT_DEPLOY_ACCESS_TOKEN;
+  }
+
+  let payload: unknown;
+
+  try {
+    payload = JSON.parse(await readFile(tokenPath, "utf8"));
+  } catch {
+    throw new AgentKitError(
+      "deploy_access_token_missing",
+      `Could not read a clean deploy access token file at ${tokenPath}. Run: agentkit access token create ${defaultDeployChatAccessTokenName} --out ${defaultDeployChatAccessTokenPath}`,
+    );
+  }
+
+  const token =
+    payload && typeof payload === "object"
+      ? (payload as { access_token?: { token?: unknown }; token?: unknown; accessToken?: unknown }).access_token?.token ??
+        (payload as { token?: unknown }).token ??
+        (payload as { accessToken?: unknown }).accessToken
+      : undefined;
+
+  if (typeof token !== "string" || token.trim().length === 0) {
+    throw new AgentKitError(
+      "deploy_access_token_invalid",
+      `Deploy access token file ${tokenPath} does not contain access_token.token. Recreate it with: agentkit access token create ${defaultDeployChatAccessTokenName} --out ${defaultDeployChatAccessTokenPath}`,
+    );
+  }
+
+  return token.trim();
+}
+
+function readIncomingBody(request: IncomingMessage): Promise<string> {
+  return new Promise((resolvePromise, reject) => {
+    let body = "";
+    request.setEncoding("utf8");
+    request.on("data", (chunk) => {
+      body += chunk;
+    });
+    request.on("end", () => resolvePromise(body));
+    request.on("error", reject);
+  });
+}
+
+function sendJson(response: ServerResponse, status: number, body: unknown): void {
+  response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  response.end(JSON.stringify(body, null, 2));
+}
+
+function sendHtml(response: ServerResponse, body: string): void {
+  response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+  response.end(body);
+}
+
+function renderDeployChatUi(input: { deployUrl: string }): string {
+  const deployUrl = escapeHtml(input.deployUrl);
+
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>AgentKit Hosted Chat</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f6f7f5;
+        --panel: #ffffff;
+        --ink: #182022;
+        --muted: #667175;
+        --line: #d9ded9;
+        --accent: #176b5d;
+        --danger: #9f2d2d;
+      }
+
+      * { box-sizing: border-box; }
+
+      body {
+        margin: 0;
+        min-height: 100svh;
+        background: var(--bg);
+        color: var(--ink);
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      main {
+        min-height: 100svh;
+        display: grid;
+        grid-template-rows: auto 1fr auto;
+        background: var(--panel);
+      }
+
+      header {
+        border-bottom: 1px solid var(--line);
+        padding: 18px 22px;
+      }
+
+      h1 {
+        margin: 0 0 4px;
+        font-size: 20px;
+        line-height: 1.2;
+      }
+
+      code {
+        color: var(--muted);
+        font-size: 12px;
+        overflow-wrap: anywhere;
+      }
+
+      #messages {
+        padding: 22px;
+        overflow: auto;
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+      }
+
+      .message {
+        max-width: 780px;
+        display: grid;
+        gap: 4px;
+      }
+
+      .message.user {
+        align-self: end;
+      }
+
+      .role {
+        color: var(--muted);
+        font-size: 12px;
+        font-weight: 700;
+        text-transform: uppercase;
+      }
+
+      .bubble {
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        padding: 12px 14px;
+        white-space: pre-wrap;
+        line-height: 1.45;
+        background: #fbfbfa;
+      }
+
+      .user .bubble {
+        border-color: #b8d8ce;
+        background: #e8f5f0;
+      }
+
+      .error .bubble {
+        border-color: #e1b1b1;
+        color: var(--danger);
+        background: #fff6f6;
+      }
+
+      form {
+        border-top: 1px solid var(--line);
+        padding: 14px;
+        display: grid;
+        grid-template-columns: 1fr auto;
+        gap: 10px;
+      }
+
+      textarea {
+        min-height: 52px;
+        max-height: 180px;
+        resize: vertical;
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        padding: 12px;
+        color: var(--ink);
+        font: inherit;
+      }
+
+      button {
+        min-width: 96px;
+        border: 0;
+        border-radius: 8px;
+        padding: 0 18px;
+        color: white;
+        background: var(--accent);
+        font: inherit;
+        font-weight: 700;
+        cursor: pointer;
+      }
+
+      button:disabled {
+        cursor: wait;
+        opacity: 0.65;
+      }
+
+      @media (max-width: 640px) {
+        form {
+          grid-template-columns: 1fr;
+        }
+
+        button {
+          min-height: 44px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>AgentKit Hosted Chat</h1>
+        <code>${deployUrl}</code>
+      </header>
+      <section id="messages" aria-live="polite"></section>
+      <form id="form">
+        <textarea id="message" name="message" placeholder="Type a message" required autofocus></textarea>
+        <button id="send" type="submit">Send</button>
+      </form>
+    </main>
+    <script>
+      const form = document.querySelector("#form");
+      const textarea = document.querySelector("#message");
+      const send = document.querySelector("#send");
+      const messages = document.querySelector("#messages");
+      let conversationId = null;
+
+      function addMessage(role, content, className = "") {
+        const wrapper = document.createElement("article");
+        wrapper.className = ["message", role, className].filter(Boolean).join(" ");
+        const label = document.createElement("div");
+        label.className = "role";
+        label.textContent = role;
+        const bubble = document.createElement("div");
+        bubble.className = "bubble";
+        bubble.textContent = content;
+        wrapper.append(label, bubble);
+        messages.append(wrapper);
+        messages.scrollTop = messages.scrollHeight;
+      }
+
+      form.addEventListener("submit", async (event) => {
+        event.preventDefault();
+        const message = textarea.value.trim();
+        if (!message) return;
+
+        addMessage("user", message);
+        textarea.value = "";
+        send.disabled = true;
+
+        try {
+          const response = await fetch("/v1/chat", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ message, conversationId }),
+          });
+          const payload = await response.json();
+
+          if (!response.ok) {
+            throw new Error(payload.error?.message || "Request failed");
+          }
+
+          conversationId = payload.conversationId || conversationId;
+          addMessage("assistant", payload.message?.content || "");
+        } catch (error) {
+          addMessage("error", error instanceof Error ? error.message : String(error), "error");
+        } finally {
+          send.disabled = false;
+          textarea.focus();
+        }
+      });
+    </script>
+  </body>
+</html>`;
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function relativePath(root: string, path: string): string {
+  const output = relative(root, path);
+  return output.startsWith("..") ? path : output || ".";
+}

package/src/cli/deploy-readiness.ts

@@ -0,0 +1,329 @@
+import { findAgentCapsuleRoot, loadAgentCapsule } from "../runtime/config";
+import { readLocalDeployStateIfExists } from "../runtime/core/deploy-state";
+import { loadDeployReadinessContext, stableCloudProjectId, type DeployReadinessContext } from "../runtime/deploy-readiness";
+import { loadCapsuleEnv } from "../runtime/env";
+import { isAgentKitError } from "../runtime/errors";
+import {
+  cloudApiRequest,
+  formatCloudAuthSource,
+  readCloudAuth,
+  type CloudCapabilitiesResponse,
+  type CloudLimitsResponse,
+  type CloudMeResponse,
+  type CloudSecretsResponse,
+} from "./cloud-client";
+
+type DeployReadinessStatus = "pass" | "fail" | "warn" | "info";
+
+type DeployReadinessCheck = {
+  status: DeployReadinessStatus;
+  title: string;
+  message: string;
+  action?: string;
+};
+
+type DeployReadinessReport = {
+  ok: boolean;
+  apiUrl: string;
+  context: DeployReadinessContext;
+  checks: DeployReadinessCheck[];
+};
+
+export async function checkDeployReadiness(options: {
+  apiUrl: string;
+  requireLogin: boolean;
+}): Promise<DeployReadinessReport> {
+  const context = await loadDeployReadinessContext(process.cwd(), process.env);
+  const auth = await readCloudAuth();
+  const checks: DeployReadinessCheck[] = [];
+  let cloudAuthUsable = false;
+
+  if (context.runtime !== "edge") {
+    checks.push({
+      status: "fail",
+      title: "Target runtime",
+      message: 'Cloudflare deploy requires runtime: "edge" in agentkit.config.ts.',
+      action: "set runtime: \"edge\" before deploying to AgentKit Cloud",
+    });
+  } else {
+    checks.push({
+      status: "pass",
+      title: "Target runtime",
+      message: "Capsule is configured for edge deploy.",
+    });
+  }
+
+  if (!auth?.token) {
+    checks.push({
+      status: options.requireLogin ? "fail" : "warn",
+      title: "Login",
+      message: options.requireLogin
+        ? "No AgentKit Cloud token was found for hosted production deploy."
+        : "No AgentKit Cloud token was found; deploy will request anonymous mode.",
+      action: "agentkit login --token <token>",
+    });
+  } else {
+    try {
+      const me = (await cloudApiRequest(options.apiUrl, "/v1/me", { method: "GET" })) as CloudMeResponse;
+      const email = me.account?.email;
+      checks.push({
+        status: "pass",
+        title: "Login",
+        message: email ? `Authenticated as ${email}.` : "AgentKit Cloud token is accepted.",
+      });
+      cloudAuthUsable = true;
+    } catch (error) {
+      checks.push({
+        status: "fail",
+        title: "Login",
+        message: `AgentKit Cloud rejected the token from ${formatCloudAuthSource(auth)}. ${formatReadinessError(error)}`,
+        action: "agentkit login --token <token>",
+      });
+    }
+  }
+
+  if (cloudAuthUsable) {
+    try {
+      const payload = (await cloudApiRequest(options.apiUrl, "/v1/me/capabilities", {
+        method: "GET",
+      })) as CloudCapabilitiesResponse;
+      const capabilities = payload.capabilities ?? [];
+      const hasCloudflareAlpha = capabilities.some(
+        (capability) => capability.name === "cloudflare_deploy_alpha" && capability.status === "active",
+      );
+
+      checks.push({
+        status: hasCloudflareAlpha ? "pass" : "fail",
+        title: "Deploy entitlement",
+        message: hasCloudflareAlpha
+          ? "cloudflare_deploy_alpha is active."
+          : "This account is missing the cloudflare_deploy_alpha entitlement.",
+        ...(hasCloudflareAlpha ? {} : { action: "log in with an invited AgentKit Cloud alpha token" }),
+      });
+    } catch (error) {
+      checks.push({
+        status: "fail",
+        title: "Deploy entitlement",
+        message: `Could not verify AgentKit Cloud capabilities. ${formatReadinessError(error)}`,
+      });
+    }
+
+    try {
+      const payload = (await cloudApiRequest(options.apiUrl, "/v1/me/limits", {
+        method: "GET",
+      })) as CloudLimitsResponse;
+      const account = payload.online_agents?.account;
+      const global = payload.online_agents?.global;
+      const accountLimit = normalizeOptionalNumber(account?.limit);
+      const accountUsed = normalizeOptionalNumber(account?.used);
+      const globalLimit = normalizeOptionalNumber(global?.limit);
+      const globalUsed = normalizeOptionalNumber(global?.used);
+
+      if (accountLimit !== undefined && accountUsed !== undefined && accountUsed >= accountLimit) {
+        checks.push({
+          status: "fail",
+          title: "Online agent capacity",
+          message: `This account is already using ${accountUsed}/${accountLimit} online AgentKit deploys.`,
+          action: "agentkit deploy pause",
+        });
+      } else if (globalLimit !== undefined && globalUsed !== undefined && globalUsed >= globalLimit) {
+        checks.push({
+          status: "fail",
+          title: "Online agent capacity",
+          message: `AgentKit Cloud is already using ${globalUsed}/${globalLimit} global online deploy slots.`,
+          action: "agentkit deploy status",
+        });
+      } else if (accountLimit !== undefined && accountUsed !== undefined) {
+        checks.push({
+          status: "pass",
+          title: "Online agent capacity",
+          message: `Account has capacity: ${accountUsed}/${accountLimit} online deploys are in use.`,
+        });
+      } else if (globalLimit !== undefined && globalUsed !== undefined) {
+        checks.push({
+          status: "pass",
+          title: "Online agent capacity",
+          message: `Global capacity is available: ${globalUsed}/${globalLimit} online deploys are in use.`,
+        });
+      } else {
+        checks.push({
+          status: "info",
+          title: "Online agent capacity",
+          message: "No online deploy limit is configured for this account.",
+        });
+      }
+    } catch (error) {
+      checks.push({
+        status: "warn",
+        title: "Online agent capacity",
+        message: `Could not verify online deploy capacity. ${formatReadinessError(error)}`,
+      });
+    }
+  }
+
+  if (context.agentKitManagedSecrets.length > 0) {
+    checks.push({
+      status: "info",
+      title: "AgentKit-managed secrets",
+      message: `${context.agentKitManagedSecrets.join(", ")} ${
+        context.agentKitManagedSecrets.length === 1 ? "is" : "are"
+      } provisioned by AgentKit Cloud during deploy.`,
+    });
+  }
+
+  if (context.accessMode === "private") {
+    checks.push({
+      status: "info",
+      title: "Private access",
+      message: "AGENTKIT_PRIVATE_TOKEN is required at runtime; AgentKit Cloud generates it and saves it in .agentkit/deploy.json.",
+    });
+  }
+
+  if (context.userManagedSecrets.length === 0) {
+    checks.push({
+      status: "pass",
+      title: "Hosted secrets",
+      message: "No user-managed hosted secrets are required by this capsule.",
+    });
+  } else if (!cloudAuthUsable) {
+    checks.push({
+      status: options.requireLogin ? "fail" : "warn",
+      title: "Hosted secrets",
+      message: `Could not check hosted secrets without a valid AgentKit Cloud login. Required: ${context.userManagedSecrets.join(", ")}.`,
+      action: "agentkit secret list",
+    });
+  } else {
+    try {
+      const payload = (await cloudApiRequest(
+        options.apiUrl,
+        `/v1/projects/${encodeURIComponent(context.projectId)}/secrets`,
+        { method: "GET" },
+      )) as CloudSecretsResponse;
+      const hostedSecretNames = new Set((payload.secrets ?? []).map((secret) => secret.name).filter(isString));
+      const missing = context.userManagedSecrets.filter((name) => !hostedSecretNames.has(name));
+
+      if (missing.length === 0) {
+        checks.push({
+          status: "pass",
+          title: "Hosted secrets",
+          message: "All user-managed hosted secrets are set.",
+        });
+      } else {
+        for (const secret of missing) {
+          const localSource = context.localSecrets[secret];
+          checks.push({
+            status: "fail",
+            title: `Hosted secret ${secret}`,
+            message: localSource
+              ? `${secret} is present locally but has not been set in AgentKit Cloud.`
+              : `${secret} is required but missing from AgentKit Cloud.`,
+            action: secretSetCommand(secret, localSource),
+          });
+        }
+      }
+    } catch (error) {
+      checks.push({
+        status: "fail",
+        title: "Hosted secrets",
+        message: `Could not list hosted secrets for project ${context.projectId}. ${formatReadinessError(error)}`,
+        action: "agentkit secret list",
+      });
+    }
+  }
+
+  return {
+    ok: checks.every((check) => check.status !== "fail"),
+    apiUrl: options.apiUrl,
+    context,
+    checks,
+  };
+}
+
+export function printDeployReadinessReport(report: DeployReadinessReport): void {
+  console.log("AgentKit deploy readiness");
+  console.log(`Project: ${report.context.projectName}`);
+  console.log(`Project ID: ${report.context.projectId}`);
+  console.log(`Target: ${report.context.target}`);
+  console.log(`API: ${report.apiUrl}`);
+  console.log("");
+
+  for (const check of report.checks) {
+    console.log(`[${check.status}] ${check.title}: ${check.message}`);
+
+    if (check.action) {
+      console.log(`  Run: ${check.action}`);
+    }
+  }
+}
+
+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, {});
+  let synced = 0;
+  let skipped = 0;
+
+  for (const secret of context.userManagedSecrets) {
+    const value = localEnv[secret];
+
+    if (value === undefined) {
+      skipped += 1;
+      console.log(`${secret}\tskipped_missing_local`);
+      continue;
+    }
+
+    await cloudApiRequest(options.apiUrl, `/v1/projects/${encodeURIComponent(options.projectId)}/secrets/${encodeURIComponent(secret)}`, {
+      method: "PUT",
+      body: JSON.stringify({ value }),
+    });
+    synced += 1;
+    console.log(`${secret}\tsynced`);
+  }
+
+  if (context.userManagedSecrets.length === 0) {
+    console.log("No user-managed hosted secrets are declared by this capsule.");
+    return;
+  }
+
+  console.log("");
+  console.log(`${synced} synced, ${skipped} skipped`);
+}
+
+export function formatReadinessError(error: unknown): string {
+  if (isAgentKitError(error)) {
+    return `${error.code}: ${error.message}`;
+  }
+
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function resolveProjectIdForSecretCommand(cwd: string): Promise<string> {
+  const state = await readLocalDeployStateIfExists(cwd);
+
+  if (state?.project_id) {
+    return state.project_id;
+  }
+
+  const root = await findAgentCapsuleRoot(cwd);
+  const capsule = await loadAgentCapsule(root);
+  return stableCloudProjectId(capsule.config.name);
+}
+
+function secretSetCommand(secret: string, source: DeployReadinessContext["localSecrets"][string] | undefined): string {
+  if (source?.dotenv) {
+    return `agentkit secret set ${secret} --from-local-env`;
+  }
+
+  if (source?.environment) {
+    return `agentkit secret set ${secret} --from-env`;
+  }
+
+  return `agentkit secret set ${secret} --stdin`;
+}
+
+function normalizeOptionalNumber(value: number | null | undefined): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function isString(value: unknown): value is string {
+  return typeof value === "string";
+}