@andreprado/agentkit 0.1.0-alpha.10

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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,33 @@
+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 });
+}
+
+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

@@ -0,0 +1,206 @@
+import { 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[];
+  };
+
+  await mkdir(buildDir, { recursive: true });
+  const envExample = renderEnvExample(manifest.secrets);
+  await writeFile(composePath, renderCompose(manifest.name));
+  await writeFile(envExamplePath, envExample);
+  await writeFile(envPath, envExample);
+  await writeFile(secretsPath, renderSecretsChecklist(manifest.secrets));
+  await writeFile(handoffPath, renderProductionHandoff(options.host, manifest.name));
+
+  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`);
+
+  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 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", "bun", "-e", "const r=await fetch('http://127.0.0.1:4123/health'); process.exit(r.ok?0: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): 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 https://${host}/_agentkit
+curl -fsS -X POST https://${host}/chat \\
+  -H 'content-type: application/json' \\
+  -d '{"message":{"role":"user","content":"hello"}}'
+\`\`\`
+
+## 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 slugify(value: string): string {
+  const slug = value
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+
+  return slug || "agent";
+}

package/src/runtime/tool-runner.ts

@@ -0,0 +1,65 @@
+import { loadAgentCapsule } from "./config";
+import { openPreparedCapsuleStore } from "./database";
+import { loadCapsuleEnv } from "./env";
+import { isAgentKitError } from "./errors";
+import { createToolRuntime, type ToolCallResult } from "./tools";
+
+export type RunToolOptions = {
+  name: string;
+  input?: unknown;
+  signal?: AbortSignal;
+};
+
+export async function runToolFromCwd(cwd: string, options: RunToolOptions): Promise<ToolCallResult> {
+  const capsule = await loadAgentCapsule(cwd);
+  const env = await loadCapsuleEnv(capsule.root);
+  const { store } = await openPreparedCapsuleStore(capsule);
+  const conversation = store.createConversation({
+    agentName: capsule.config.name,
+    title: `tool ${options.name}`,
+  });
+  const run = store.createRun({
+    conversationId: conversation.id,
+    provider: capsule.config.provider.name,
+    model: capsule.config.provider.model,
+  });
+  const toolRuntime = createToolRuntime({
+    tools: capsule.config.tools ?? [],
+    store,
+    runId: run.id,
+    conversationId: conversation.id,
+    env,
+    signal: options.signal,
+    runtime: {
+      environment: "local",
+      invocation: "tool",
+      target: "bun",
+      database: "sqlite",
+    },
+  });
+
+  try {
+    const result = await toolRuntime.execute({
+      name: options.name,
+      input: options.input ?? {},
+    });
+
+    store.completeRun({
+      runId: run.id,
+      status: "completed",
+    });
+
+    return result;
+  } catch (error) {
+    store.completeRun({
+      runId: run.id,
+      status: "failed",
+      errorCode: isAgentKitError(error) ? error.code : "runtime_error",
+      errorMessage: error instanceof Error ? error.message : String(error),
+    });
+
+    throw error;
+  } finally {
+    store.close();
+  }
+}