@andreprado/agentkit 0.1.0-alpha.10

package/src/runtime/db-commands.ts

@@ -0,0 +1,167 @@
+import { access, readFile, rm } from "node:fs/promises";
+import { constants } from "node:fs";
+import { delimiter, join, relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+
+import { loadAgentCapsule } from "./config";
+import { openPreparedCapsuleStore } from "./database";
+import { AgentKitError } from "./errors";
+
+export type DbMigrateResult = {
+  root: string;
+  databasePath: string;
+  migrationsPath: string | null;
+  migrationsApplied: string[];
+  migrationsSkipped: string[];
+  schemaPath: string | null;
+  schemaApplied: boolean;
+};
+
+export type DbResetResult = DbMigrateResult & {
+  resetPath: string;
+};
+
+export type DbSeedResult = DbMigrateResult & {
+  seedPath: string;
+};
+
+export type DbShellResult =
+  | {
+      opened: true;
+      databasePath: string;
+      exitCode: number;
+    }
+  | {
+      opened: false;
+      databasePath: string;
+      command: string;
+      message: string;
+    };
+
+export async function migrateLocalDatabase(cwd = process.cwd()): Promise<DbMigrateResult> {
+  const capsule = await loadAgentCapsule(cwd);
+  const prepared = await openPreparedCapsuleStore(capsule);
+
+  try {
+    return {
+      root: capsule.root,
+      databasePath: prepared.databasePath,
+      migrationsPath: prepared.migrations.path,
+      migrationsApplied: prepared.migrations.applied,
+      migrationsSkipped: prepared.migrations.skipped,
+      schemaPath: prepared.schema.path,
+      schemaApplied: prepared.schema.applied,
+    };
+  } finally {
+    prepared.store.close();
+  }
+}
+
+export async function resetLocalDatabase(cwd = process.cwd()): Promise<DbResetResult> {
+  const capsule = await loadAgentCapsule(cwd);
+  const databasePath = requireLocalDatabasePath(capsule.storagePath);
+
+  await rm(databasePath, { force: true });
+  const migrated = await migrateLocalDatabase(capsule.root);
+
+  return {
+    ...migrated,
+    resetPath: databasePath,
+  };
+}
+
+export async function seedLocalDatabase(cwd = process.cwd(), seedFile = "seed.sql"): Promise<DbSeedResult> {
+  const capsule = await loadAgentCapsule(cwd);
+  const seedPath = resolve(capsule.root, seedFile);
+
+  let seedSql: string;
+
+  try {
+    seedSql = await readFile(seedPath, "utf8");
+  } catch (error) {
+    throw new AgentKitError(
+      "database_schema_error",
+      `Could not read seed SQL file at ${relative(capsule.root, seedPath)}. Use agentkit db seed --file <path>.`,
+      { cause: error },
+    );
+  }
+
+  const prepared = await openPreparedCapsuleStore(capsule);
+
+  try {
+    prepared.store.applyApplicationSchema(seedSql);
+    return {
+      root: capsule.root,
+      databasePath: prepared.databasePath,
+      migrationsPath: prepared.migrations.path,
+      migrationsApplied: prepared.migrations.applied,
+      migrationsSkipped: prepared.migrations.skipped,
+      schemaPath: prepared.schema.path,
+      schemaApplied: prepared.schema.applied,
+      seedPath,
+    };
+  } finally {
+    prepared.store.close();
+  }
+}
+
+export async function openLocalDatabaseShell(cwd = process.cwd()): Promise<DbShellResult> {
+  const migrated = await migrateLocalDatabase(cwd);
+  const sqlite3 = await findExecutable("sqlite3");
+  const command = `sqlite3 ${JSON.stringify(migrated.databasePath)}`;
+
+  if (!sqlite3) {
+    return {
+      opened: false,
+      databasePath: migrated.databasePath,
+      command,
+      message: "sqlite3 was not found on PATH. Install sqlite3, then run the command below.",
+    };
+  }
+
+  const exitCode = await runInteractiveCommand(sqlite3, [migrated.databasePath]);
+
+  return {
+    opened: true,
+    databasePath: migrated.databasePath,
+    exitCode,
+  };
+}
+
+function runInteractiveCommand(command: string, args: string[]): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+    });
+
+    child.once("error", reject);
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+}
+
+function requireLocalDatabasePath(storagePath: string | undefined): string {
+  if (!storagePath) {
+    throw new AgentKitError("invalid_config", "Local database commands require storage.path or storage.driver: agentkit.");
+  }
+
+  return storagePath;
+}
+
+async function findExecutable(name: string): Promise<string | null> {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory) {
+      continue;
+    }
+
+    const candidate = join(directory, name);
+
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      // Keep looking.
+    }
+  }
+
+  return null;
+}

package/src/runtime/deploy-readiness.ts

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+
+import { loadAgentCapsule } from "./config";
+import { buildSharedAgentManifest } from "./core/manifest";
+import { listCapsuleEnv } from "./env";
+
+export type DeployReadinessSecretSource = {
+  dotenv: boolean;
+  environment: boolean;
+};
+
+export type DeployReadinessContext = {
+  root: string;
+  projectName: string;
+  projectId: string;
+  target: "cloudflare";
+  runtime: "edge" | "local";
+  provider: {
+    name: string;
+    model: string;
+  };
+  accessMode: "private" | "token" | "public";
+  requiredSecrets: string[];
+  userManagedSecrets: string[];
+  agentKitManagedSecrets: string[];
+  localSecrets: Record<string, DeployReadinessSecretSource>;
+  knowledge: {
+    enabled: boolean;
+    sourceCount: number;
+    embeddingProvider: string;
+    databaseDriver: "none" | "turso";
+  };
+};
+
+export async function loadDeployReadinessContext(
+  cwd = process.cwd(),
+  env: Record<string, string | undefined> = process.env,
+): Promise<DeployReadinessContext> {
+  const capsule = await loadAgentCapsule(cwd);
+  const manifest = buildSharedAgentManifest(capsule);
+  const dotenvNames = new Set(await listCapsuleEnv(capsule.root));
+  const requiredSecrets = manifest.secrets;
+  const localSecrets: Record<string, DeployReadinessSecretSource> = {};
+
+  for (const name of requiredSecrets) {
+    const source = {
+      dotenv: dotenvNames.has(name),
+      environment: Boolean(env[name]),
+    };
+
+    if (source.dotenv || source.environment) {
+      localSecrets[name] = source;
+    }
+  }
+
+  const agentKitManagedSecrets = requiredSecrets.filter((name) =>
+    isAgentKitManagedDeploySecret(name, {
+      accessMode: capsule.config.access.mode,
+      databaseDriver: manifest.storage.database.driver,
+    }),
+  );
+  const managed = new Set(agentKitManagedSecrets);
+
+  return {
+    root: capsule.root,
+    projectName: capsule.config.name,
+    projectId: stableCloudProjectId(capsule.config.name),
+    target: "cloudflare",
+    runtime: capsule.config.runtime,
+    provider: {
+      name: capsule.config.provider.name,
+      model: capsule.config.provider.model,
+    },
+    accessMode: capsule.config.access.mode,
+    requiredSecrets,
+    userManagedSecrets: requiredSecrets.filter((name) => !managed.has(name)),
+    agentKitManagedSecrets,
+    localSecrets,
+    knowledge: {
+      enabled: manifest.knowledge.enabled,
+      sourceCount: manifest.knowledge.sources.length,
+      embeddingProvider: manifest.knowledge.embedding.provider,
+      databaseDriver: manifest.storage.database.driver,
+    },
+  };
+}
+
+export function stableCloudProjectId(name: string): string {
+  return `proj_${createHash("sha256").update(name).digest("hex").slice(0, 16)}`;
+}
+
+function isAgentKitManagedDeploySecret(
+  name: string,
+  context: { accessMode: DeployReadinessContext["accessMode"]; databaseDriver: "none" | "turso" },
+): boolean {
+  if (context.databaseDriver === "turso" && (name === "TURSO_DATABASE_URL" || name === "TURSO_AUTH_TOKEN")) {
+    return true;
+  }
+
+  if (context.accessMode === "private" && name === "AGENTKIT_PRIVATE_TOKEN") {
+    return true;
+  }
+
+  return false;
+}

package/src/runtime/deploy.ts

@@ -0,0 +1 @@
+export * from "../cloud";