@andreprado/agentkit 0.1.0 → 0.2.0

package/src/runtime/targets/container/build.ts

@@ -1,146 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-
-import { loadAgentCapsule } from "../../config";
-import { buildSharedAgentManifest, type ManifestSchema, type SharedAgentManifest } from "../../core/manifest";
-
-export type ContainerBuildResult = {
-  target: "container";
-  root: string;
-  buildDir: string;
-  manifestPath: string;
-  serverPath: string;
-  packageJsonPath: string;
-  dockerfilePath: string;
-  migrationsDir: string;
-  warnings: string[];
-};
-
-export type ContainerManifest = Omit<SharedAgentManifest, "runtime"> & {
-  target: "container";
-  runtime: "container";
-  container: {
-    runtime: "node";
-    entrypoint: "server.ts";
-    port: 4123;
-  };
-};
-
-const CONTAINER_BUILD_DIR = ".agentkit/build/container";
-
-export async function buildContainerAgentCapsule(cwd = process.cwd()): Promise<ContainerBuildResult> {
-  const capsule = await loadAgentCapsule(cwd);
-  const databaseConfig = capsule.config.storage.database;
-  const databaseSchema = await loadApplicationSchema(
-    capsule.root,
-    databaseConfig?.driver === "turso" ? databaseConfig.schema : undefined,
-  );
-  const manifest = buildContainerManifest(buildSharedAgentManifest(capsule, { databaseSchema }));
-  const buildDir = join(capsule.root, CONTAINER_BUILD_DIR);
-  const migrationsDir = join(buildDir, "migrations");
-  const manifestPath = join(buildDir, "agent.manifest.json");
-  const serverPath = join(buildDir, "server.ts");
-  const packageJsonPath = join(buildDir, "package.json");
-  const dockerfilePath = join(buildDir, "Dockerfile");
-
-  await mkdir(migrationsDir, { recursive: true });
-  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-  await writeFile(serverPath, renderContainerServer());
-  await writeFile(packageJsonPath, renderContainerPackageJson(capsule.config.name));
-  await writeFile(dockerfilePath, renderDockerfile());
-
-  if (databaseSchema) {
-    await writeFile(join(migrationsDir, "schema.sql"), databaseSchema.source);
-  }
-
-  return {
-    target: "container",
-    root: capsule.root,
-    buildDir,
-    manifestPath,
-    serverPath,
-    packageJsonPath,
-    dockerfilePath,
-    migrationsDir,
-    warnings: [],
-  };
-}
-
-function buildContainerManifest(shared: SharedAgentManifest): ContainerManifest {
-  return {
-    ...shared,
-    target: "container",
-    runtime: "container",
-    container: {
-      runtime: "node",
-      entrypoint: "server.ts",
-      port: 4123,
-    },
-  };
-}
-
-async function loadApplicationSchema(root: string, schemaPath: string | undefined): Promise<ManifestSchema | null> {
-  if (!schemaPath) {
-    return null;
-  }
-
-  const source = await readFile(resolve(root, schemaPath), "utf8");
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(source));
-  return {
-    source,
-    sha256: Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join(""),
-  };
-}
-
-function renderContainerServer(): string {
-  return `import { startContainerRuntime } from "@andreprado/agentkit/runtime/container";
-
-await startContainerRuntime();
-`;
-}
-
-function renderContainerPackageJson(agentName: string): string {
-  return `${JSON.stringify(
-    {
-      name: `agentkit-${slugify(agentName)}-container`,
-      private: true,
-      type: "module",
-      scripts: {
-        start: "tsx server.ts",
-      },
-      dependencies: {
-        "@andreprado/agentkit": "latest",
-        "tsx": "^4.22.3",
-      },
-    },
-    null,
-    2,
-  )}\n`;
-}
-
-function renderDockerfile(): string {
-  return `FROM node:24-slim
-
-WORKDIR /app
-COPY package.json server.ts agent.manifest.json ./
-COPY migrations ./migrations
-RUN npm install --omit=dev
-
-ENV HOST=0.0.0.0
-ENV PORT=4123
-ENV AGENTKIT_CAPSULE_ROOT=/capsule
-
-EXPOSE 4123
-CMD ["npm", "start"]
-`;
-}
-
-function slugify(value: string): string {
-  const slug = value
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 48);
-
-  return slug || "agent";
-}

package/src/runtime/targets/container/server.ts

@@ -1,33 +0,0 @@
-import { resolve } from "node:path";
-
-import { startAgentDevServer, type AgentDevServer } from "../../dev-server";
-
-export type ContainerRuntimeOptions = {
-  capsuleRoot?: string;
-  hostname?: string;
-  port?: number;
-};
-
-export async function startContainerRuntime(options: ContainerRuntimeOptions = {}): Promise<AgentDevServer> {
-  const capsuleRoot = resolve(options.capsuleRoot ?? process.env.AGENTKIT_CAPSULE_ROOT ?? process.cwd());
-  const hostname = options.hostname ?? process.env.HOST ?? "0.0.0.0";
-  const port = options.port ?? parsePort(process.env.PORT) ?? 4123;
-  return startAgentDevServer(capsuleRoot, { hostname, port, access: "enforce" });
-}
-
-function parsePort(value: string | undefined): number | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  const port = Number(value);
-  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : undefined;
-}
-
-if (import.meta.main) {
-  const runtime = await startContainerRuntime();
-
-  console.log("AgentKit container runtime running");
-  console.log(`API:     http://${runtime.hostname}:${runtime.port}`);
-  console.log(`Inspect: http://${runtime.hostname}:${runtime.port}/_agentkit`);
-}

package/src/runtime/targets/vps/deploy.ts

@@ -1,223 +0,0 @@
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import type { LocalDeployState } from "../../core/deploy-state";
-import type { ContainerBuildResult } from "../container/build";
-
-export type VpsDeployOptions = {
-  host: string;
-  dryRun?: boolean;
-};
-
-export type VpsDeployPlan = {
-  target: "vps";
-  runtime: "container";
-  host: string;
-  buildDir: string;
-  composePath: string;
-  envExamplePath: string;
-  secretsPath: string;
-  handoffPath: string;
-  statePath: string;
-  commands: string[];
-};
-
-const VPS_BUILD_DIR = ".agentkit/build/vps";
-
-export async function prepareVpsDeploy(
-  container: ContainerBuildResult,
-  options: VpsDeployOptions,
-): Promise<VpsDeployPlan> {
-  const buildDir = join(container.root, VPS_BUILD_DIR);
-  const composePath = join(buildDir, "compose.yaml");
-  const envExamplePath = join(buildDir, ".env.production.example");
-  const envPath = join(buildDir, ".env.production");
-  const secretsPath = join(buildDir, "SECRETS.md");
-  const handoffPath = join(buildDir, "PRODUCTION_HANDOFF.md");
-  const statePath = join(container.root, ".agentkit/deploy.json");
-  const manifest = JSON.parse(await readFile(container.manifestPath, "utf8")) as {
-    name: string;
-    secrets: string[];
-    access: {
-      mode: "private" | "token" | "public";
-    };
-  };
-
-  await mkdir(buildDir, { recursive: true });
-  const envExample = renderEnvExample(manifest.secrets);
-  await writeFile(composePath, renderCompose(manifest.name));
-  await writeFile(envExamplePath, envExample);
-  await writeFile(envPath, envExample, { mode: 0o600 });
-  await chmod(envPath, 0o600);
-  await writeFile(secretsPath, renderSecretsChecklist(manifest.secrets));
-  await writeFile(handoffPath, renderProductionHandoff(options.host, manifest.name, manifest.access.mode));
-
-  const state: LocalDeployState = {
-    deploy_id: `vps_${slugify(manifest.name)}`,
-    project_id: `local_${slugify(manifest.name)}`,
-    url: `https://${options.host}`,
-    target: "vps",
-    runtime: "container",
-    resources: {
-      vps: {
-        host: options.host,
-        compose: composePath,
-        env_example: envExamplePath,
-        sqlite_path: "/data/agentkit.db",
-        files_path: "/capsule/.agentkit/files",
-      },
-      container: {
-        build_dir: container.buildDir,
-      },
-    },
-    access: {
-      mode: "operator-managed",
-    },
-    created_at: new Date().toISOString(),
-  };
-  await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
-  await chmod(statePath, 0o600);
-
-  return {
-    target: "vps",
-    runtime: "container",
-    host: options.host,
-    buildDir,
-    composePath,
-    envExamplePath,
-    secretsPath,
-    handoffPath,
-    statePath,
-    commands: [
-      `cp ${envExamplePath} ${envPath}`,
-      `docker compose -f ${composePath} --env-file ${envPath} config`,
-      `docker compose -f ${composePath} --env-file ${envPath} up -d --build`,
-      `curl -fsS https://${options.host}/health`,
-      `curl -fsS -H "Authorization: Bearer $AGENTKIT_PRIVATE_TOKEN" https://${options.host}/_agentkit`,
-    ],
-  };
-}
-
-function renderCompose(agentName: string): string {
-  return `services:
-  agent:
-    build:
-      context: ../container
-    image: agentkit-${slugify(agentName)}:latest
-    restart: unless-stopped
-    env_file:
-      - .env.production
-    environment:
-      HOST: 0.0.0.0
-      PORT: 4123
-      AGENTKIT_SQLITE_PATH: /data/agentkit.db
-    ports:
-      - "\${AGENTKIT_PORT:-4123}:4123"
-    volumes:
-      - ../../..:/capsule
-      - agentkit_data:/data
-      - agentkit_files:/capsule/.agentkit/files
-    healthcheck:
-      test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:4123/health').then((r)=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-      start_period: 10s
-
-volumes:
-  agentkit_data:
-  agentkit_files:
-`;
-}
-
-function renderEnvExample(secrets: string[]): string {
-  const secretLines = secrets.map((name) => `${name}=`).join("\n");
-  return `# Copy to .env.production on the VPS and fill values there.
-AGENTKIT_PORT=4123
-AGENTKIT_CAPSULE_ROOT=/capsule
-AGENTKIT_SQLITE_PATH=/data/agentkit.db
-${secretLines ? `\n${secretLines}\n` : ""}
-`;
-}
-
-function renderSecretsChecklist(secrets: string[]): string {
-  const lines = secrets.length > 0 ? secrets.map((name) => `- [ ] ${name}`).join("\n") : "- No production secrets required for the current manifest.";
-  return `# VPS Secret Checklist
-
-Fill these names in .env.production on the host. Do not commit secret values.
-
-${lines}
-`;
-}
-
-function renderProductionHandoff(host: string, agentName: string, accessMode: "private" | "token" | "public"): string {
-  return `# VPS Production Handoff
-
-## Deploy
-
-1. Copy .agentkit/build/vps to the VPS or run these commands from the capsule root on the VPS.
-2. Copy .agentkit/build/vps/.env.production.example to .agentkit/build/vps/.env.production and fill secret values on the host.
-3. Run:
-
-\`\`\`sh
-docker compose -f .agentkit/build/vps/compose.yaml --env-file .agentkit/build/vps/.env.production config
-docker compose -f .agentkit/build/vps/compose.yaml --env-file .agentkit/build/vps/.env.production up -d --build
-\`\`\`
-
-## Ports And Reverse Proxy
-
-- Container port: 4123.
-- Host port: AGENTKIT_PORT, default 4123.
-- Put nginx, Caddy, Traefik, or your VPS proxy in front of http://127.0.0.1:4123 for https://${host}.
-
-## Smoke
-
-\`\`\`sh
-curl -fsS https://${host}/health
-curl -fsS -H "Authorization: Bearer $AGENTKIT_PRIVATE_TOKEN" https://${host}/_agentkit
-curl -fsS -X POST https://${host}/chat \\
-  -H 'content-type: application/json'${renderChatAuthHeader(accessMode)} \\
-  -d '{"message":{"role":"user","content":"hello"}}'
-\`\`\`
-
-Set AGENTKIT_PRIVATE_TOKEN for privileged AgentKit endpoints. Chat access follows access.mode: ${accessMode}.
-
-## Database
-
-- Default database: SQLite at /data/agentkit.db in the agentkit_data volume.
-- Backup: snapshot the agentkit_data Docker volume or copy /data/agentkit.db after stopping the container.
-- Postgres upgrade path: set a managed DATABASE_URL in .env.production after the container runtime grows the Postgres store.
-
-## Files
-
-- Local files persist in the agentkit_files volume mounted at /capsule/.agentkit/files.
-
-## Rollback
-
-\`\`\`sh
-docker compose -f .agentkit/build/vps/compose.yaml --env-file .agentkit/build/vps/.env.production down
-docker image ls 'agentkit-${slugify(agentName)}'
-docker compose -f .agentkit/build/vps/compose.yaml --env-file .agentkit/build/vps/.env.production up -d --no-build
-\`\`\`
-`;
-}
-
-function renderChatAuthHeader(accessMode: "private" | "token" | "public"): string {
-  if (accessMode === "public") {
-    return "";
-  }
-
-  const secretName = accessMode === "private" ? "AGENTKIT_PRIVATE_TOKEN" : "AGENTKIT_ACCESS_TOKEN";
-  return ` \\
-  -H "Authorization: Bearer $${secretName}"`;
-}
-
-function slugify(value: string): string {
-  const slug = value
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 48);
-
-  return slug || "agent";
-}

package/src/templates/skills/agentkit-deploy/SKILL.md

@@ -1,52 +0,0 @@
----
-name: agentkit-deploy
-description: Use when preparing or running AgentKit hosted deploys, deploy readiness checks, managed secrets, deploy smoke tests, hosted chat UI checks, access tokens, or production handoff.
----
-
-# AgentKit Deploy
-
-Use this when the owner asks to prepare, test, or run hosted deploy.
-
-## Rules
-
-- The user should not choose hosting infrastructure. AgentKit owns target routing.
-- Keep production secret values out of the capsule.
-- Use hosted managed secrets, not committed `.env`.
-- Run readiness checks before saying deploy-ready.
-
-## Local Readiness
-
-```sh
-npm run typecheck
-npm run agentkit -- skills status
-npm run agentkit -- inspect
-npm run agentkit -- db migrate
-npm run chat -- --message "hello"
-npm run agentkit -- deploy --dry-run
-npm run agentkit -- deploy doctor
-```
-
-If this deploy fixes production behavior, replay the collected evidence first:
-
-```sh
-npm run agentkit -- replay .agentkit/improve/<run> --against local
-```
-
-## Hosted Flow
-
-```sh
-npm run agentkit -- login --token agk_user_...
-npm run agentkit -- secret sync --from-local
-npm run agentkit -- secret list
-npm run agentkit -- deploy --smoke "hello"
-npm run agentkit -- deploy status
-npm run agentkit -- chat-ui --deploy
-```
-
-Open the printed `Chat:` URL and report it to the owner.
-
-## Production Handoff
-
-`npm run agentkit -- deploy` prints a production handoff after a successful deploy. Use it as the source of truth for the deploy URL, UI command, secret status, database/schema artifact, integration connect commands, smoke status, and next recommended command.
-
-Report changed files, required env/secret names, database schema changes, deploy order, smoke checks, rollback concerns, and whether the provider was still `test/fake`.

package/src/templates/skills/agentkit-integrations/SKILL.md

@@ -1,98 +0,0 @@
----
-name: agentkit-integrations
-description: Use when adding, inspecting, connecting, or troubleshooting AgentKit-managed integrations such as managed Composio in an Agent Capsule.
----
-
-# AgentKit Integrations
-
-Use this when the owner asks for managed connected apps, Gmail/Calendar/Slack/Linear through AgentKit, or paid AgentKit-managed Composio.
-
-## Managed Composio
-
-Managed Composio is a paid hosted AgentKit feature. Use it when the owner wants AgentKit to manage OAuth/connect links, per-agent connected app state, deploy readiness, and hosted Composio credentials.
-
-Use BYO `defineTool` instead when the owner wants to bring their own Composio account/API key.
-
-## Config
-
-Edit `agentkit.config.ts`:
-
-```ts
-import { composioManaged, defineAgent } from "@andreprado/agentkit";
-
-export default defineAgent({
-  integrations: [
-    composioManaged({
-      toolkits: ["gmail", "googlecalendar"],
-      tools: {
-        gmail: ["GMAIL_FETCH_EMAILS", "GMAIL_SEND_EMAIL"],
-        googlecalendar: [
-          "GOOGLECALENDAR_EVENTS_LIST",
-          "GOOGLECALENDAR_CREATE_EVENT",
-          "GOOGLECALENDAR_UPDATE_EVENT",
-        ],
-      },
-      confirmExternalWrites: true,
-    }),
-  ],
-});
-```
-
-Keep the action list explicit. Do not expose the whole Composio catalog by default.
-
-For Google Calendar, do not configure create-only access. Include `GOOGLECALENDAR_EVENTS_LIST` so the agent can inspect availability before writing. For `GOOGLECALENDAR_CREATE_EVENT`, pass UTC `start_datetime` and explicit `event_duration_minutes` or `event_duration_hour`; AgentKit blocks Composio's implicit 30-minute duration default.
-
-An integration that allows managed Composio write actions is operator-only. AgentKit blocks its generated tool during model-driven chat, channel, and eval runs. Review the exact action, invoke it directly with `agentkit tool`, and pass `confirmed: true` for writes. `confirmExternalWrites: false` disables only that secondary input check, not the operator-only permission boundary.
-
-## Testability
-
-Do not rely on the real connected app for ordinary evals. When adding an integration, also add deterministic coverage for:
-
-- the safe path, such as free/busy before calendar create;
-- missing confirmation before an external write;
-- provider errors such as 429, timeout, missing auth, empty result, or unavailable slot;
-- privacy rules, such as not showing a full calendar or raw provider payload to the client;
-- payload invariants, such as timezone conversion, duration, recipients, or record ids.
-
-Use eval-safe branches inside capsule tools, local fixtures, or `test/fake` behavior when the hosted integration cannot run locally without touching the real provider.
-
-## Commands
-
-```sh
-npm run agentkit -- inspect
-npm run agentkit -- deploy doctor
-npm run agentkit -- deploy
-npm run agentkit -- integrations status --toolkit googlecalendar
-npm run agentkit -- integrations connect composio --toolkit gmail
-```
-
-`integrations connect composio` requires a hosted deploy because the connect link is deploy-scoped. After declaring `composioManaged(...)`, tell the owner the sequence is:
-
-```sh
-npm run agentkit -- deploy doctor
-npm run agentkit -- deploy
-npm run agentkit -- integrations connect composio --toolkit googlecalendar
-```
-
-The deploy handoff prints the connect command for each configured toolkit.
-
-## Rules
-
-- Do not add `COMPOSIO_API_KEY` to `.env.schema` for managed Composio.
-- Do not ask the owner for a Composio key when using managed Composio.
-- Do not ask the owner for Composio auth config ids; AgentKit Cloud resolves toolkit auth configs.
-- Managed Composio requires a non-anonymous hosted deploy and `managed_composio` entitlement.
-- The generated tool is `agentkit_composio_execute`.
-- Use one Composio settings profile per agent.
-
-## Verification
-
-Expected `inspect` output includes:
-
-```txt
-integrations[0].provider = composio
-tools includes agentkit_composio_execute
-managedSecrets includes COMPOSIO_API_KEY
-```
-
-If `deploy doctor` reports `managed_composio_entitlement_required`, the owner must log in with a paid AgentKit Cloud account or ask an operator to grant it.