@build0.ai/agent-core 0.1.0

package/README.md

@@ -0,0 +1,146 @@
+# @build0.ai/agent-core
+
+Core framework for Build0 autonomous coding agents. This package provides the workflow orchestration engine, plugin system, and utilities needed to build autonomous agents.
+
+## Installation
+
+```bash
+npm install @build0.ai/agent-core
+# or
+pnpm add @build0.ai/agent-core
+```
+
+## Quick Start
+
+```typescript
+import { Runner, credentialManager } from "@build0.ai/agent-core";
+import { myPlugin } from "./plugins/my-plugin.js";
+
+async function main() {
+  // Fetch credentials from remote API
+  const credentials = await credentialManager.fetchCredentials();
+
+  // Create runner and register plugins
+  const runner = new Runner();
+  await runner.registerPlugin(myPlugin, {
+    API_KEY: credentials.MY_API_KEY!,
+  });
+
+  // Run workflow
+  await runner.runWorkflow("./workflow.json");
+}
+
+main();
+```
+
+## Features
+
+- **Declarative Workflows**: Define agent behavior in JSON
+- **Type-Safe Plugin System**: Build plugins with compile-time validation
+- **MCP Tools Integration**: Tools are exposed via Model Context Protocol
+- **Claude Agent SDK**: Leverages Claude for intelligent coding tasks
+- **Credential Management**: Secure remote credential fetching and decryption
+- **Structured Logging**: JSON-formatted logs for easy parsing
+
+## Workflow Format
+
+```json
+{
+  "steps": [
+    {
+      "id": "step_1",
+      "type": "tool",
+      "tool": "my_tool",
+      "args": {
+        "param": "value"
+      }
+    },
+    {
+      "id": "step_2",
+      "type": "ai_agent",
+      "args": {
+        "prompt": "Analyze the output: {{ step_1.output }}",
+        "working_dir": "./workspace"
+      }
+    }
+  ]
+}
+```
+
+## Creating Plugins
+
+```typescript
+import { McpPlugin, BasePluginConfig, ToolDefinition } from "@build0.ai/agent-core";
+import { z } from "zod";
+
+interface MyPluginConfig extends BasePluginConfig {
+  API_KEY: string;
+}
+
+export const myPlugin: McpPlugin<MyPluginConfig> = {
+  name: "my_plugin",
+  config: {} as MyPluginConfig,
+
+  async init(config: MyPluginConfig): Promise<void> {
+    if (!config.API_KEY) {
+      throw new Error("API_KEY is required");
+    }
+    this.config = config;
+  },
+
+  registerTools(): ToolDefinition[] {
+    return [
+      {
+        name: "my_tool",
+        description: "Does something useful",
+        zodSchema: z.object({
+          param: z.string().describe("A parameter"),
+        }),
+      },
+    ];
+  },
+
+  async handleToolCall(name, args) {
+    if (name === "my_tool") {
+      // Implementation
+      return {
+        content: [{ type: "text", text: "Result" }],
+      };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  },
+};
+```
+
+## Environment Variables
+
+The framework uses these environment variables:
+
+- `BUILD0_AGENT_CREDENTIALS_URL` - Remote credentials API endpoint
+- `BUILD0_AGENT_AUTH_TOKEN` - Authentication token for credentials API
+- `BUILD0_AGENT_ENCRYPTION_KEY` - AES-256 key for credential decryption (hex)
+- `BUILD0_TRIGGER_PAYLOAD` - JSON payload from external triggers (auto-injected as `{{ input }}`)
+- `ANTHROPIC_API_KEY` - API key for Claude (required by Claude Agent SDK)
+
+## Exports
+
+### Classes
+- `Runner` - Main workflow orchestration engine
+
+### Singletons
+- `logger` - Structured JSON logger
+- `credentialManager` - Credential fetching service
+
+### Types
+- `McpPlugin<TConfig>` - Plugin interface
+- `BasePluginConfig` - Base plugin configuration
+- `ToolDefinition` - Tool metadata with Zod schema
+- `Workflow` - Workflow definition
+- `WorkflowStep` - Single workflow step
+- `Credential` - Credential structure
+- `AgentResult` - AI agent execution result
+- Various log message types
+
+## License
+
+MIT

package/dist/core/log-types.d.ts

@@ -0,0 +1,73 @@
+import { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+export type LogLevel = "info" | "warn" | "error" | "debug";
+export interface BaseLogMessage {
+    timestamp: string;
+    level: LogLevel;
+    type: string;
+    stepId?: string;
+    message?: string;
+}
+export interface StepStartMessage extends BaseLogMessage {
+    type: "step_start";
+    stepId: string;
+    stepType: "ai_agent" | "tool";
+    toolName?: string;
+}
+export interface StepCompleteMessage extends BaseLogMessage {
+    type: "step_complete";
+    stepId: string;
+    duration?: number;
+    outputPreview?: string;
+}
+export interface StepErrorMessage extends BaseLogMessage {
+    type: "step_error";
+    stepId: string;
+    error: string;
+}
+export interface StepSkipMessage extends BaseLogMessage {
+    type: "step_skip";
+    stepId: string;
+    reason: string;
+}
+export interface AiAgentPromptMessage extends BaseLogMessage {
+    type: "ai_agent_prompt";
+    stepId: string;
+    promptLength: number;
+    truncated: boolean;
+    fullPromptPath?: string;
+}
+export interface AiAgentResponseMessage extends BaseLogMessage {
+    type: "ai_agent_response";
+    stepId: string;
+    responseLength: number;
+    responsePreview: string;
+}
+export interface ToolCallMessage extends BaseLogMessage {
+    type: "tool_call";
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, any>;
+}
+export interface ToolResultMessage extends BaseLogMessage {
+    type: "tool_result";
+    toolName: string;
+    toolCallId: string;
+    resultLength: number;
+    resultPreview: string;
+    hasJsonResult?: boolean;
+}
+export interface ClaudeCodeSdkMessage extends BaseLogMessage {
+    type: "claude_code_sdk";
+    sdkMessage: SDKMessage;
+}
+export interface ClaudeCodeStderrMessage extends BaseLogMessage {
+    type: "claude_code_stderr";
+    stderr: string;
+}
+export interface GenericLogMessage extends BaseLogMessage {
+    type: "log";
+}
+export type LogMessage = StepStartMessage | StepCompleteMessage | StepErrorMessage | StepSkipMessage | AiAgentPromptMessage | AiAgentResponseMessage | ToolCallMessage | ToolResultMessage | ClaudeCodeSdkMessage | ClaudeCodeStderrMessage | GenericLogMessage;
+export type LogMessageType = LogMessage["type"];
+export declare function createLogMessage<T extends LogMessage>(message: Omit<T, "timestamp">): T;
+//# sourceMappingURL=log-types.d.ts.map

package/dist/core/log-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-types.d.ts","sourceRoot":"","sources":["../../src/core/log-types.ts"],"names":[],"mappings":"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"}

package/dist/core/log-types.js

@@ -0,0 +1,8 @@
+// Log message types for structured agent progress tracking
+// Helper function to create typed log messages
+export function createLogMessage(message) {
+    return {
+        ...message,
+        timestamp: new Date().toISOString(),
+    };
+}

package/dist/core/runner.d.ts

@@ -0,0 +1,26 @@
+import { McpPlugin } from "./types.js";
+/**
+ * Framework runner for autonomous agents.
+ * Handles workflow execution and plugin management.
+ */
+export declare class Runner {
+    private plugins;
+    private pluginRegistry;
+    /**
+     * Register a plugin with its configuration.
+     * TypeScript will enforce the config type matches the plugin's requirements.
+     */
+    registerPlugin<TConfig extends Record<string, any>>(plugin: McpPlugin<TConfig>, config: TConfig): Promise<void>;
+    /**
+     * Validate that all required tools are available and there are no conflicts.
+     */
+    private validateTools;
+    private createMcpServer;
+    /**
+     * Run a workflow from a file.
+     * @param workflowPath - Path to the workflow JSON file
+     * @param initialContext - Optional additional context to merge
+     */
+    runWorkflow(workflowPath: string, initialContext?: Record<string, any>): Promise<void>;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/core/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAoBvC;;;GAGG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,cAAc,CAAqC;IAE3D;;;OAGG;IACG,cAAc,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtD,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,EAC1B,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IAchB;;OAEG;IACH,OAAO,CAAC,aAAa;IA8CrB,OAAO,CAAC,eAAe;IA8BvB;;;;OAIG;IACG,WAAW,CACf,YAAY,EAAE,MAAM,EACpB,cAAc,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACvC,OAAO,CAAC,IAAI,CAAC;CAwJjB"}

package/dist/core/runner.js

@@ -0,0 +1,214 @@
+import path from "path";
+import fs from "fs/promises";
+import os from "os";
+import { loadWorkflow } from "../utils/workflow.js";
+import { runAgent } from "../utils/agent.js";
+import { logger } from "../utils/logger.js";
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+function interpolate(text, context) {
+    if (typeof text !== "string")
+        return text;
+    return text.replace(/\{\{\s*([\w\.]+)\s*\}\}/g, (_, path) => {
+        const keys = path.split(".");
+        let value = context;
+        for (const key of keys) {
+            value = value?.[key];
+        }
+        // If value is an object, stringify it. If string, return as is.
+        return value !== undefined
+            ? typeof value === "object"
+                ? JSON.stringify(value, null, 2)
+                : String(value)
+            : "";
+    });
+}
+/**
+ * Framework runner for autonomous agents.
+ * Handles workflow execution and plugin management.
+ */
+export class Runner {
+    plugins = [];
+    pluginRegistry = new Map();
+    /**
+     * Register a plugin with its configuration.
+     * TypeScript will enforce the config type matches the plugin's requirements.
+     */
+    async registerPlugin(plugin, config) {
+        await plugin.init(config);
+        this.plugins.push(plugin);
+        this.pluginRegistry.set(plugin.name, plugin);
+        logger.info(`Plugin ${plugin.name} registered with ${plugin.registerTools().length} tools: ${plugin
+            .registerTools()
+            .map((t) => t.name)
+            .join(", ")}`);
+    }
+    /**
+     * Validate that all required tools are available and there are no conflicts.
+     */
+    validateTools(workflow) {
+        // Build a map of all available tools from registered plugins
+        const availableTools = new Map(); // toolName -> pluginName
+        for (const plugin of this.plugins) {
+            const tools = plugin.registerTools();
+            for (const tool of tools) {
+                if (availableTools.has(tool.name)) {
+                    const existingPlugin = availableTools.get(tool.name);
+                    throw new Error(`Duplicate tool name detected: "${tool.name}" is provided by both "${existingPlugin}" and "${plugin.name}" plugins`);
+                }
+                availableTools.set(tool.name, plugin.name);
+            }
+        }
+        // Check that all tools referenced in workflow steps are available
+        const missingTools = [];
+        for (const step of workflow.steps) {
+            if (step.type === "tool" && step.tool) {
+                if (!availableTools.has(step.tool)) {
+                    missingTools.push(step.tool);
+                }
+            }
+        }
+        if (missingTools.length > 0) {
+            throw new Error(`Workflow references tools that are not available: ${missingTools.join(", ")}\n` +
+                `Available tools: ${Array.from(availableTools.keys()).join(", ")}\n` +
+                `Make sure the required plugins are registered in index.ts`);
+        }
+        logger.info(`✅ All required workflow tools are available:\n${Array.from(availableTools.keys())
+            .map((t) => `- ${t}`)
+            .join("\n")}`);
+    }
+    createMcpServer() {
+        const tools = [];
+        for (const plugin of this.plugins) {
+            const pluginTools = plugin.registerTools();
+            for (const pluginTool of pluginTools) {
+                tools.push(tool(pluginTool.name, pluginTool.description, pluginTool.zodSchema.shape, async (args) => {
+                    return await plugin.handleToolCall(pluginTool.name, args);
+                }));
+            }
+        }
+        const server = createSdkMcpServer({
+            name: "agent-tools",
+            version: "1.0.0",
+            tools,
+        });
+        logger.info(`✅ MCP server created with ${tools.length} tools:\n${tools
+            .map((t) => `- ${t.name}`)
+            .join("\n")}`);
+        return server;
+    }
+    /**
+     * Run a workflow from a file.
+     * @param workflowPath - Path to the workflow JSON file
+     * @param initialContext - Optional additional context to merge
+     */
+    async runWorkflow(workflowPath, initialContext = {}) {
+        const workflow = await loadWorkflow(workflowPath);
+        logger.info(`Workflow loaded (${workflow.steps.length} steps)`);
+        // Validate tools before running
+        this.validateTools(workflow);
+        const mcpServer = this.createMcpServer();
+        // Build initial context with trigger payload from environment
+        const context = { ...initialContext };
+        // Automatically inject BUILD0_TRIGGER_PAYLOAD as 'input' if present
+        if (process.env.BUILD0_TRIGGER_PAYLOAD) {
+            try {
+                const triggerPayload = JSON.parse(process.env.BUILD0_TRIGGER_PAYLOAD);
+                context.input = triggerPayload;
+                logger.info(`Trigger payload loaded from BUILD0_TRIGGER_PAYLOAD`);
+            }
+            catch (e) {
+                logger.error(`Failed to parse BUILD0_TRIGGER_PAYLOAD: ${e}`);
+            }
+        }
+        let isFirstAiAgentStep = true;
+        for (const step of workflow.steps) {
+            logger.stepStart(step.id, step.type, step.tool);
+            // Check 'if' condition
+            if (step.if) {
+                const condition = interpolate(step.if, context);
+                if (!condition || condition === "false") {
+                    logger.stepSkip(step.id, "condition false");
+                    continue;
+                }
+            }
+            try {
+                switch (step.type) {
+                    case "ai_agent":
+                        // Extract and interpolate args for ai_agent
+                        const agentArgs = {};
+                        if (step.args) {
+                            for (const [k, v] of Object.entries(step.args)) {
+                                agentArgs[k] =
+                                    typeof v === "string" ? interpolate(v, context) : v;
+                            }
+                        }
+                        const fullPrompt = agentArgs.prompt || "";
+                        const workingDir = path.resolve(process.cwd(), agentArgs.working_dir || ".");
+                        // Write full prompt to a temp file OUTSIDE the working directory
+                        // to avoid Claude Code scanning it automatically
+                        const tempPromptFile = path.join(os.tmpdir(), `prompt_${step.id}_${Date.now()}.txt`);
+                        // Truncate prompt to ~2000 tokens (1 token ≈ 4 chars -> 8000 chars)
+                        const MAX_CHARS = 2000 * 4;
+                        await fs.writeFile(tempPromptFile, fullPrompt, "utf-8");
+                        logger.aiAgentPrompt(step.id, fullPrompt.length, fullPrompt.length > MAX_CHARS, tempPromptFile);
+                        let truncatedPrompt = fullPrompt.substring(0, MAX_CHARS);
+                        if (fullPrompt.length > MAX_CHARS) {
+                            truncatedPrompt += `\n\n[Note: The full prompt was truncated. I have saved the complete details to the file '${tempPromptFile}' (outside the workspace). You can read it if needed, but it is large.]`;
+                        }
+                        const result = await runAgent({
+                            prompt: truncatedPrompt,
+                            workingDirectory: workingDir,
+                            mcpServers: {
+                                "agent-tools": mcpServer,
+                            },
+                            shouldContinuePreviousSession: !isFirstAiAgentStep,
+                        });
+                        isFirstAiAgentStep = false;
+                        logger.aiAgentResponse(step.id, result.output.length, result.output.substring(0, 100));
+                        context[step.id] = { output: result.output };
+                        break;
+                    case "tool":
+                        const toolName = step.tool;
+                        if (!toolName)
+                            throw new Error("Tool name missing");
+                        // Find plugin that provides this tool
+                        const plugin = this.plugins.find((p) => p.registerTools().some((t) => t.name === toolName));
+                        if (!plugin)
+                            throw new Error(`Plugin for tool ${toolName} not found`);
+                        // Interpolate args
+                        const args = {};
+                        if (step.args) {
+                            for (const [k, v] of Object.entries(step.args)) {
+                                args[k] =
+                                    typeof v === "string" ? interpolate(v, context) : v;
+                            }
+                        }
+                        const toolCallId = `${step.id}_${toolName}_${Date.now()}`;
+                        logger.toolCall(toolName, toolCallId, args);
+                        const toolResult = await plugin.handleToolCall(toolName, args);
+                        // Extract text content
+                        const outputText = toolResult.content
+                            .map((c) => c.text)
+                            .join("\n");
+                        logger.toolResult(toolName, toolCallId, outputText.length, outputText.substring(0, 100), true);
+                        // Try to parse JSON if possible for easier access
+                        let outputData = outputText;
+                        try {
+                            outputData = JSON.parse(outputText);
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                        context[step.id] = { output: outputData };
+                        // Tool result already logged above
+                        break;
+                }
+                logger.stepComplete(step.id);
+            }
+            catch (error) {
+                logger.stepError(step.id, error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        }
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,29 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z, ZodRawShape } from "zod";
+/**
+ * Base configuration provided to all plugins.
+ * Contains credentials fetched from remote API.
+ */
+export interface BasePluginConfig {
+    [key: string]: string | undefined;
+}
+/**
+ * Tool definition with Zod schema for MCP SDK compatibility
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    zodSchema: z.ZodObject<ZodRawShape>;
+}
+/**
+ * Generic plugin interface.
+ * Each plugin should define its own TConfig interface with required keys.
+ */
+export interface McpPlugin<TConfig extends BasePluginConfig = BasePluginConfig> {
+    name: string;
+    config?: TConfig;
+    init(config: TConfig): Promise<void>;
+    registerTools(): ToolDefinition[];
+    handleToolCall(name: string, args: Record<string, unknown>): Promise<CallToolResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,KAAK,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS,CACxB,OAAO,SAAS,gBAAgB,GAAG,gBAAgB;IAEnD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,aAAa,IAAI,cAAc,EAAE,CAAC;IAClC,cAAc,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,cAAc,CAAC,CAAC;CAC5B"}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Runner } from "./core/runner.js";
+export type { McpPlugin, BasePluginConfig, ToolDefinition, } from "./core/types.js";
+export type { Workflow, WorkflowStep } from "./utils/workflow.js";
+export { logger } from "./utils/logger.js";
+export type { LogMessage, LogLevel, LogMessageType, BaseLogMessage, StepStartMessage, StepCompleteMessage, StepErrorMessage, StepSkipMessage, AiAgentPromptMessage, AiAgentResponseMessage, ToolCallMessage, ToolResultMessage, ClaudeCodeSdkMessage, ClaudeCodeStderrMessage, GenericLogMessage, } from "./core/log-types.js";
+export { credentialManager } from "./services/credential-manager.js";
+export type { Credential } from "./services/credential-manager.js";
+export type { AgentResult } from "./utils/agent.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,cAAc,GACf,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGlE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,YAAY,EACV,UAAU,EACV,QAAQ,EACR,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,YAAY,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAGnE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+// Core
+export { Runner } from "./core/runner.js";
+// Logger
+export { logger } from "./utils/logger.js";
+// Credentials
+export { credentialManager } from "./services/credential-manager.js";

package/dist/services/credential-manager.d.ts

@@ -0,0 +1,30 @@
+export interface Credential {
+    type: string;
+    provider: string;
+    apiKey?: string;
+    access_token?: string;
+    raw?: any;
+}
+/**
+ * Centralized credential management service.
+ * Fetches, decrypts, and caches credentials from remote API.
+ * Provides a singleton instance that all parts of the framework can use.
+ */
+declare class CredentialManager {
+    private credentials;
+    private fetchPromise;
+    /**
+     * Fetch credentials from remote API and cache them.
+     * Ensures credentials are only fetched once even if called multiple times.
+     * Returns raw credentials - transformation to env vars happens in index.ts
+     */
+    fetchCredentials(): Promise<Record<string, Credential>>;
+    private _performFetch;
+    /**
+     * Get cached raw credentials. Returns empty object if not yet fetched.
+     */
+    getCredentials(): Record<string, Credential>;
+}
+export declare const credentialManager: CredentialManager;
+export {};
+//# sourceMappingURL=credential-manager.d.ts.map

package/dist/services/credential-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-manager.d.ts","sourceRoot":"","sources":["../../src/services/credential-manager.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,GAAG,CAAC;CACX;AAyBD;;;;GAIG;AACH,cAAM,iBAAiB;IACrB,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,YAAY,CAAoD;IAExE;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;YAsB/C,aAAa;IA8C3B;;OAEG;IACH,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;CAG7C;AAGD,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/dist/services/credential-manager.js

@@ -0,0 +1,94 @@
+import crypto from "crypto";
+import { logger } from "../utils/logger.js";
+const ALGORITHM = "aes-256-gcm";
+const CREDENTIALS_AUTH_KEY = "agent-credentials";
+function decryptCredentials(encryptedData) {
+    const encryptionKey = process.env.BUILD0_AGENT_ENCRYPTION_KEY;
+    if (!encryptionKey) {
+        throw new Error("BUILD0_ENCRYPTION_KEY environment variable is not set. Cannot decrypt credentials.");
+    }
+    const parts = encryptedData.split(":");
+    if (parts.length !== 3) {
+        throw new Error("Invalid encrypted data format");
+    }
+    const [ivHex, authTagHex, encrypted] = parts;
+    const key = Buffer.from(encryptionKey, "hex");
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    decipher.setAAD(Buffer.from(CREDENTIALS_AUTH_KEY));
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return JSON.parse(decrypted);
+}
+/**
+ * Centralized credential management service.
+ * Fetches, decrypts, and caches credentials from remote API.
+ * Provides a singleton instance that all parts of the framework can use.
+ */
+class CredentialManager {
+    credentials = null;
+    fetchPromise = null;
+    /**
+     * Fetch credentials from remote API and cache them.
+     * Ensures credentials are only fetched once even if called multiple times.
+     * Returns raw credentials - transformation to env vars happens in index.ts
+     */
+    async fetchCredentials() {
+        // If already fetched, return cached credentials
+        if (this.credentials !== null) {
+            return this.credentials;
+        }
+        // If fetch is in progress, wait for it
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        // Start new fetch
+        this.fetchPromise = this._performFetch();
+        this.credentials = await this.fetchPromise;
+        logger.info(`✅ Credentials fetched successfully:\n${Object.keys(this.credentials)
+            .map((key) => `- ${key}`)
+            .join("\n")}`);
+        return this.credentials;
+    }
+    async _performFetch() {
+        const credentialsUrl = process.env.BUILD0_AGENT_CREDENTIALS_URL;
+        const authToken = process.env.BUILD0_AGENT_AUTH_TOKEN;
+        if (!credentialsUrl) {
+            throw new Error("BUILD0_AGENT_CREDENTIALS_URL environment variable is not set.");
+        }
+        if (!authToken) {
+            throw new Error("BUILD0_AGENT_AUTH_TOKEN environment variable is not set.");
+        }
+        console.log(`[Credentials] Fetching remote credentials from ${credentialsUrl}...`);
+        try {
+            const response = await fetch(credentialsUrl, {
+                headers: { "x-agent-auth-token": authToken },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch credentials: ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (!data.encrypted) {
+                throw new Error("Invalid response format: missing 'encrypted' field");
+            }
+            const rawCredentials = decryptCredentials(data.encrypted);
+            console.log("[Credentials] Successfully decrypted credentials");
+            // Return raw credentials - transformation happens in index.ts
+            return rawCredentials;
+        }
+        catch (error) {
+            console.error("[Credentials] Error fetching/decrypting credentials:", error instanceof Error ? error.message : JSON.stringify(error));
+            throw error;
+        }
+    }
+    /**
+     * Get cached raw credentials. Returns empty object if not yet fetched.
+     */
+    getCredentials() {
+        return this.credentials || {};
+    }
+}
+// Singleton instance
+export const credentialManager = new CredentialManager();

package/dist/utils/agent.d.ts

@@ -0,0 +1,11 @@
+import { McpSdkServerConfigWithInstance } from "@anthropic-ai/claude-agent-sdk";
+export interface AgentResult {
+    output: string;
+}
+export declare function runAgent(params: {
+    prompt: string;
+    workingDirectory: string;
+    mcpServers: Record<string, McpSdkServerConfigWithInstance>;
+    shouldContinuePreviousSession?: boolean;
+}): Promise<AgentResult>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/utils/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/utils/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAG/B,MAAM,gCAAgC,CAAC;AAGxC,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,QAAQ,CAAC,MAAM,EAAE;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC;IAC3D,6BAA6B,CAAC,EAAE,OAAO,CAAC;CACzC,GAAG,OAAO,CAAC,WAAW,CAAC,CAsDvB"}

package/dist/utils/agent.js

@@ -0,0 +1,46 @@
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "./logger.js";
+export async function runAgent(params) {
+    // Capture stderr to see actual errors from Claude Code process
+    const stderrMessages = [];
+    const stderrCallback = (message) => {
+        stderrMessages.push(message);
+        logger.claudeCodeStderr(message);
+    };
+    const stream = query({
+        prompt: params.prompt,
+        options: {
+            continue: params.shouldContinuePreviousSession ?? false,
+            cwd: params.workingDirectory,
+            // We can use the default executable (node)
+            mcpServers: params.mcpServers,
+            // Enable all tools by default
+            permissionMode: "bypassPermissions",
+            stderr: stderrCallback,
+        },
+    });
+    let finalResult = null;
+    try {
+        for await (const message of stream) {
+            logger.claudeCodeSdkMessage(message);
+            if (message.type === "result") {
+                finalResult = message;
+            }
+        }
+    }
+    catch (error) {
+        logger.claudeCodeStderr(error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+    if (finalResult) {
+        if (finalResult.subtype === "success") {
+            return {
+                output: finalResult.result,
+            };
+        }
+        else {
+            throw new Error(`Error: ${finalResult.subtype}. Message: ${JSON.stringify(finalResult.errors, null, 2)}`);
+        }
+    }
+    throw new Error("No final result received");
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,29 @@
+import { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+declare class Logger {
+    private currentStepId?;
+    private originalConsoleLog;
+    private originalConsoleWarn;
+    private originalConsoleError;
+    private originalConsoleDebug;
+    constructor();
+    private overrideConsole;
+    private log;
+    private createMessage;
+    stepStart(stepId: string, stepType: "ai_agent" | "tool", toolName?: string): void;
+    stepComplete(stepId: string, duration?: number, outputPreview?: string): void;
+    stepError(stepId: string, error: string): void;
+    stepSkip(stepId: string, reason: string): void;
+    aiAgentPrompt(stepId: string, promptLength: number, truncated: boolean, fullPromptPath?: string): void;
+    aiAgentResponse(stepId: string, responseLength: number, responsePreview: string): void;
+    toolCall(toolName: string, toolCallId: string, args: Record<string, any>): void;
+    toolResult(toolName: string, toolCallId: string, resultLength: number, resultPreview: string, hasJsonResult?: boolean): void;
+    claudeCodeSdkMessage(message: SDKMessage): void;
+    claudeCodeStderr(stderr: string): void;
+    info(message: string, data?: Record<string, any>): void;
+    warn(message: string, data?: Record<string, any>): void;
+    error(message: string, data?: Record<string, any>): void;
+    debug(message: string, data?: Record<string, any>): void;
+}
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAiB5D,cAAM,MAAM;IACV,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,oBAAoB,CAAuB;;IAanD,OAAO,CAAC,eAAe;IAgCvB,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,aAAa;IAcrB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAW1E,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM;IAWtE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAUvC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAUvC,aAAa,CACX,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,OAAO,EAClB,cAAc,CAAC,EAAE,MAAM;IAYzB,eAAe,CACb,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM;IAWzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAUxE,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,OAAO;IAazB,oBAAoB,CAAC,OAAO,EAAE,UAAU;IAQxC,gBAAgB,CAAC,MAAM,EAAE,MAAM;IAW/B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAWhD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAWhD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAWjD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAUlD;AAED,eAAO,MAAM,MAAM,QAAe,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,168 @@
+// Logger utility for structured JSON logging
+class Logger {
+    currentStepId;
+    originalConsoleLog;
+    originalConsoleWarn;
+    originalConsoleError;
+    originalConsoleDebug;
+    constructor() {
+        // Store original console methods
+        this.originalConsoleLog = console.log.bind(console);
+        this.originalConsoleWarn = console.warn.bind(console);
+        this.originalConsoleError = console.error.bind(console);
+        this.originalConsoleDebug = console.debug.bind(console);
+        // Override console methods to automatically include step ID
+        this.overrideConsole();
+    }
+    overrideConsole() {
+        const self = this;
+        console.log = (...args) => {
+            const message = args
+                .map((arg) => (typeof arg === "string" ? arg : JSON.stringify(arg)))
+                .join(" ");
+            self.info(message);
+        };
+        console.warn = (...args) => {
+            const message = args
+                .map((arg) => (typeof arg === "string" ? arg : JSON.stringify(arg)))
+                .join(" ");
+            self.warn(message);
+        };
+        console.error = (...args) => {
+            const message = args
+                .map((arg) => (typeof arg === "string" ? arg : JSON.stringify(arg)))
+                .join(" ");
+            self.error(message);
+        };
+        console.debug = (...args) => {
+            const message = args
+                .map((arg) => (typeof arg === "string" ? arg : JSON.stringify(arg)))
+                .join(" ");
+            self.debug(message);
+        };
+    }
+    log(message) {
+        // Use original console.log to avoid recursion
+        this.originalConsoleLog(JSON.stringify(message));
+    }
+    createMessage(type, level, data) {
+        return {
+            timestamp: new Date().toISOString(),
+            level,
+            type,
+            stepId: this.currentStepId,
+            ...data,
+        };
+    }
+    stepStart(stepId, stepType, toolName) {
+        this.currentStepId = stepId;
+        this.log(this.createMessage("step_start", "info", {
+            stepId,
+            stepType,
+            toolName,
+        }));
+    }
+    stepComplete(stepId, duration, outputPreview) {
+        this.log(this.createMessage("step_complete", "info", {
+            stepId,
+            duration,
+            outputPreview,
+        }));
+        this.currentStepId = undefined;
+    }
+    stepError(stepId, error) {
+        this.log(this.createMessage("step_error", "error", {
+            stepId,
+            error,
+        }));
+        this.currentStepId = undefined;
+    }
+    stepSkip(stepId, reason) {
+        this.log(this.createMessage("step_skip", "warn", {
+            stepId,
+            reason,
+        }));
+        this.currentStepId = undefined;
+    }
+    aiAgentPrompt(stepId, promptLength, truncated, fullPromptPath) {
+        this.log(this.createMessage("ai_agent_prompt", "info", {
+            stepId,
+            promptLength,
+            truncated,
+            fullPromptPath,
+        }));
+    }
+    aiAgentResponse(stepId, responseLength, responsePreview) {
+        this.log(this.createMessage("ai_agent_response", "info", {
+            stepId,
+            responseLength,
+            responsePreview,
+        }));
+    }
+    toolCall(toolName, toolCallId, args) {
+        this.log(this.createMessage("tool_call", "info", {
+            toolName,
+            toolCallId,
+            args,
+        }));
+    }
+    toolResult(toolName, toolCallId, resultLength, resultPreview, hasJsonResult) {
+        this.log(this.createMessage("tool_result", "info", {
+            toolName,
+            toolCallId,
+            resultLength,
+            resultPreview,
+            hasJsonResult,
+        }));
+    }
+    claudeCodeSdkMessage(message) {
+        this.log(this.createMessage("claude_code_sdk", "info", {
+            sdkMessage: message,
+        }));
+    }
+    claudeCodeStderr(stderr) {
+        this.log(this.createMessage("claude_code_stderr", "error", { stderr }));
+    }
+    // Generic log methods that automatically include current step ID
+    info(message, data) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            level: "info",
+            type: "log",
+            message,
+            stepId: this.currentStepId ?? undefined,
+            ...data,
+        });
+    }
+    warn(message, data) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            level: "warn",
+            type: "log",
+            message,
+            stepId: this.currentStepId ?? undefined,
+            ...data,
+        });
+    }
+    error(message, data) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            level: "error",
+            type: "log",
+            message,
+            stepId: this.currentStepId ?? undefined,
+            ...data,
+        });
+    }
+    debug(message, data) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            level: "debug",
+            type: "log",
+            message,
+            stepId: this.currentStepId ?? undefined,
+            ...data,
+        });
+    }
+}
+export const logger = new Logger();

package/dist/utils/workflow.d.ts

@@ -0,0 +1,12 @@
+export interface WorkflowStep {
+    id: string;
+    type: "ai_agent" | "tool";
+    tool?: string;
+    args?: Record<string, any>;
+    if?: string;
+}
+export interface Workflow {
+    steps: WorkflowStep[];
+}
+export declare function loadWorkflow(filePath: string): Promise<Workflow>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/utils/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/utils/workflow.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAGtE"}

package/dist/utils/workflow.js

@@ -0,0 +1,5 @@
+import fs from "fs/promises";
+export async function loadWorkflow(filePath) {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@build0.ai/agent-core",
+  "version": "0.1.0",
+  "description": "Core framework for Build0 autonomous coding agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.54",
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "zod": "^3.22.4"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": "^0.71.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "claude",
+    "anthropic",
+    "autonomous",
+    "mcp"
+  ],
+  "license": "MIT"
+}