@auxx/sdk 0.0.12 → 0.0.13

package/lib/api/api.js

@@ -123,7 +123,7 @@ class ApiImpl {
         }
         return complete(result.value);
     }
-    async createDeployment({ appId, clientBundleSha, serverBundleSha, deploymentType, settingsSchema, targetOrganizationId, environmentVariables, version, metadata, }) {
+    async createDeployment({ appId, clientBundleSha, serverBundleSha, deploymentType, settingsSchema, catalog, targetOrganizationId, environmentVariables, version, metadata, }) {
         const result = await this.fetcher.post({
             path: `/api/v1/apps/${appId}/deployments`,
             body: {
@@ -131,6 +131,7 @@ class ApiImpl {
                 serverBundleSha,
                 deploymentType,
                 settingsSchema,
+                catalog,
                 targetOrganizationId,
                 environmentVariables,
                 version,

package/lib/api/schemas.js

@@ -38,6 +38,7 @@ const appDataSchema = z.object({
     avatarId: z.string().nullable().optional(),
     avatarUrl: z.string().nullable().optional(),
     category: z.string().nullable().optional(),
+    verified: z.boolean().optional(),
     createdAt: z.string().or(z.date()),
     updatedAt: z.string().or(z.date()),
 });

package/lib/build/server/find-tool-server-modules.js

@@ -0,0 +1,279 @@
+import fs from 'node:fs';
+import { parse } from '@typescript-eslint/parser';
+import { analyze } from '@typescript-eslint/scope-manager';
+import { walk } from 'zimmerframe';
+import { complete, errored } from '../../errors.js';
+import { getAppEntryPoint } from '../../util/get-app-entry-point.js';
+function checkPath(path, doesModuleExist) {
+    return doesModuleExist(path) ? path : null;
+}
+function resolvePathWithExtension(path, doesModuleExist) {
+    return (checkPath(path + '.ts', doesModuleExist) ||
+        checkPath(path + '.tsx', doesModuleExist) ||
+        checkPath(path + '.js', doesModuleExist));
+}
+function resolveAbsolutePath(sourcePath, currPath) {
+    if (sourcePath.startsWith('.')) {
+        const currDir = currPath.split('/').slice(0, -1).join('/');
+        const combinedPath = currDir + '/' + sourcePath;
+        const parts = combinedPath.split('/');
+        const resolvedParts = [];
+        for (const part of parts) {
+            if (part === '..') {
+                resolvedParts.pop();
+            }
+            else if (part !== '.') {
+                resolvedParts.push(part);
+            }
+        }
+        return resolvedParts.join('/');
+    }
+    return sourcePath;
+}
+function unwrapTypeAnnotations(node) {
+    while (node) {
+        if (node.type === 'TSSatisfiesExpression' || node.type === 'TSAsExpression') {
+            node = node.expression;
+        }
+        else if (node.type === 'TSTypeAssertion') {
+            node = node.expression;
+        }
+        else {
+            break;
+        }
+    }
+    return node;
+}
+function resolveIdentifierToValue(node, scope) {
+    const variable = scope.set.get(node.name);
+    if (!variable) {
+        throw new Error(`Unable to find variable ${node.name} in scope`);
+    }
+    if (variable.defs.length !== 1) {
+        throw new Error(`Expected exactly one definition for variable ${node.name}, found ${variable.defs.length}`);
+    }
+    const def = variable.defs[0];
+    if (!def)
+        return null;
+    if (def.node.type === 'VariableDeclarator')
+        return def.node.init;
+    if (def.type === 'ImportBinding')
+        return def;
+    return null;
+}
+function loadModule(sourcePath, currPath, helpers) {
+    const absolutePath = resolveAbsolutePath(sourcePath, currPath);
+    const fullPath = resolvePathWithExtension(absolutePath, helpers.doesModuleExist);
+    if (!fullPath) {
+        throw new Error(`Unable to resolve path for module ${sourcePath} from ${currPath}`);
+    }
+    if (helpers.modules.has(fullPath)) {
+        return helpers.modules.get(fullPath);
+    }
+    const content = helpers.getModuleSource(fullPath);
+    const ast = parse(content, { range: true, jsx: true });
+    const scopeManager = analyze(ast, { sourceType: 'module' });
+    const moduleScope = scopeManager.acquire(ast, true);
+    const namedExports = new Map();
+    const module = { content, ast, scope: moduleScope, namedExports, path: fullPath };
+    helpers.modules.set(fullPath, module);
+    walk(ast, null, {
+        ExportNamedDeclaration(node) {
+            if (node.declaration?.type === 'VariableDeclaration' &&
+                node.declaration.declarations.length === 1 &&
+                node.declaration.declarations[0].type === 'VariableDeclarator' &&
+                node.declaration.declarations[0].id.type === 'Identifier') {
+                const declaration = node.declaration.declarations[0];
+                namedExports.set(declaration.id.name, declaration.init);
+            }
+            if (node?.specifiers && moduleScope) {
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === 'ExportSpecifier' &&
+                        specifier.exported.type === 'Identifier' &&
+                        specifier.local.type === 'Identifier') {
+                        if (node.source !== null) {
+                            namedExports.set(specifier.exported.name, node);
+                        }
+                        else {
+                            const resolved = resolveIdentifierToValue(specifier.local, moduleScope);
+                            if (resolved)
+                                namedExports.set(specifier.exported.name, resolved);
+                        }
+                    }
+                }
+            }
+        },
+        ExportDefaultDeclaration(node) {
+            if (node.declaration) {
+                if (node.declaration.type === 'FunctionDeclaration' ||
+                    node.declaration.type === 'ArrowFunctionExpression' ||
+                    node.declaration.type === 'FunctionExpression') {
+                    namedExports.set('default', node.declaration);
+                }
+                else if (node.declaration.type === 'Identifier' && moduleScope) {
+                    const resolved = resolveIdentifierToValue(node.declaration, moduleScope);
+                    if (resolved)
+                        namedExports.set('default', resolved);
+                }
+            }
+        },
+    });
+    return module;
+}
+function captureExecuteRef(toolId, node, scope, currPath, helpers) {
+    let importValue = node.type === 'Identifier' ? resolveIdentifierToValue(node, scope) : node;
+    if (!importValue) {
+        throw new Error(`Tool '${toolId}': unable to resolve 'execute'`);
+    }
+    importValue = unwrapTypeAnnotations(importValue);
+    const isInlineFunction = importValue.type === 'ArrowFunctionExpression' ||
+        importValue.type === 'FunctionExpression' ||
+        importValue.type === 'FunctionDeclaration';
+    if (isInlineFunction) {
+        throw new Error(`Tool '${toolId}': 'execute' must be imported from a separate .server.ts file. ` +
+            `Inline server functions are not allowed.`);
+    }
+    if (importValue.type !== 'ImportBinding' && importValue.type !== 'ExportNamedDeclaration') {
+        throw new Error(`Tool '${toolId}': 'execute' must be imported from another file. Found ${importValue.type}.`);
+    }
+    const importDeclaration = importValue.type === 'ExportNamedDeclaration' ? importValue : importValue.parent;
+    const sourcePath = importDeclaration.source.value;
+    const isServerFile = sourcePath.endsWith('.server') ||
+        sourcePath.endsWith('.server.ts') ||
+        sourcePath.endsWith('.server.tsx') ||
+        sourcePath.endsWith('.server.js');
+    if (!isServerFile) {
+        throw new Error(`Tool '${toolId}': 'execute' must be imported from a .server.ts file (got '${sourcePath}').`);
+    }
+    if (importValue.type === 'ImportBinding') {
+        const specifier = importDeclaration.specifiers.find((s) => s.local && s.local.name === importValue.name.name);
+        if (specifier && specifier.type !== 'ImportDefaultSpecifier') {
+            throw new Error(`Tool '${toolId}': 'execute' must be imported as a default export from '${sourcePath}'.`);
+        }
+    }
+    let absolutePath = resolveAbsolutePath(sourcePath, currPath);
+    absolutePath = resolvePathWithExtension(absolutePath, helpers.doesModuleExist) || absolutePath;
+    return { path: absolutePath, export: 'default' };
+}
+function visitTool(node, scope, result, currPath, helpers) {
+    if (node.type === 'Identifier') {
+        let targetScope = scope;
+        let value = resolveIdentifierToValue(node, scope);
+        let targetPath = currPath;
+        if (value?.type === 'ImportBinding') {
+            const importDeclaration = value.parent;
+            const module = loadModule(importDeclaration.source.value, currPath, helpers);
+            const local = value.name.name;
+            const specifier = importDeclaration.specifiers.find((s) => s.local && s.local.name === local);
+            const name = specifier?.imported?.name ?? 'default';
+            if (!module.namedExports.has(name)) {
+                throw new Error(`Unable to find named export ${name} in module ${importDeclaration.source.value}`);
+            }
+            value = module.namedExports.get(name) ?? null;
+            if (module.scope)
+                targetScope = module.scope;
+            targetPath = module.path;
+        }
+        value = value ? unwrapTypeAnnotations(value) : null;
+        if (!value) {
+            throw new Error(`Tool ${node.name}: expected initializer`);
+        }
+        if (value.type === 'CallExpression') {
+            visitTool(value.arguments[0], targetScope, result, targetPath, helpers);
+            return;
+        }
+        if (value.type !== 'ObjectExpression') {
+            throw new Error(`Tool ${node.name}: expected ObjectExpression, got ${value.type}`);
+        }
+        visitTool(value, targetScope, result, targetPath, helpers);
+        return;
+    }
+    if (node.type === 'CallExpression') {
+        visitTool(node.arguments[0], scope, result, currPath, helpers);
+        return;
+    }
+    if (node.type === 'ObjectExpression') {
+        let id;
+        let execute = null;
+        for (const property of node.properties) {
+            if (property.type !== 'Property' || property.key.type !== 'Identifier')
+                continue;
+            const name = property.key.name;
+            if (name === 'id') {
+                if (property.value.type !== 'Literal' || typeof property.value.value !== 'string') {
+                    throw new Error(`Tool: 'id' must be a string literal`);
+                }
+                id = property.value.value;
+            }
+            else if (name === 'execute') {
+                execute = captureExecuteRef(id ?? '<unknown>', property.value, scope, currPath, helpers);
+            }
+        }
+        if (!id)
+            throw new Error(`Tool: missing 'id'`);
+        if (!execute)
+            throw new Error(`Tool '${id}': missing 'execute'`);
+        result.set(id, { execute });
+    }
+}
+function findProperty(obj, name, scope) {
+    const property = obj.properties.find((p) => p.type === 'Property' && p.key.type === 'Identifier' && p.key.name === name);
+    if (!property)
+        return null;
+    let value = property.value;
+    if (value.type === 'Identifier') {
+        const resolvedValue = resolveIdentifierToValue(value, scope);
+        if (resolvedValue && resolvedValue.type !== 'ImportBinding')
+            value = resolvedValue;
+    }
+    return value;
+}
+export function findToolModulesFromSource(source, currPath, helpers) {
+    const result = new Map();
+    try {
+        const ast = parse(source, { range: true, jsx: true });
+        const scopeManager = analyze(ast, { sourceType: 'module' });
+        const moduleScope = scopeManager.acquire(ast, true);
+        if (moduleScope === null) {
+            throw new Error('Expected to be able to acquire module scope');
+        }
+        ;
+        walk(ast, null, {
+            ExportNamedDeclaration(node) {
+                if (!node.declaration || node.declaration.type !== 'VariableDeclaration')
+                    return;
+                if (node.declaration.declarations.length !== 1)
+                    return;
+                const declaration = node.declaration.declarations[0];
+                if (declaration.id.type !== 'Identifier' || declaration.id.name !== 'app')
+                    return;
+                const appValue = declaration.init;
+                if (!appValue || appValue.type !== 'ObjectExpression')
+                    return;
+                const tools = findProperty(appValue, 'tools', moduleScope);
+                if (tools?.type !== 'ArrayExpression')
+                    return;
+                for (const element of tools.elements) {
+                    if (element)
+                        visitTool(element, moduleScope, result, currPath, helpers);
+                }
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errored({ code: 'TOOL_RESOLUTION_FAILED', message });
+    }
+    return complete(result);
+}
+export async function findToolModules(srcDirAbsolute) {
+    const appEntryPoint = await getAppEntryPoint(srcDirAbsolute);
+    if (!appEntryPoint) {
+        return complete(new Map());
+    }
+    return findToolModulesFromSource(appEntryPoint.content, appEntryPoint.path, {
+        getModuleSource: (p) => fs.readFileSync(p, 'utf-8'),
+        doesModuleExist: (p) => fs.existsSync(p),
+        modules: new Map(),
+    });
+}

package/lib/build/server/find-workflow-block-server-modules.js

@@ -240,12 +240,20 @@ function visitBlock(node, scope, result, currPath, helpers) {
             targetPath = module.path;
         }
         value = unwrapTypeAnnotations(value);
+        if (value?.type === 'CallExpression') {
+            visitBlock(value.arguments[0], targetScope, result, targetPath, helpers);
+            return;
+        }
         if (!value || value.type !== 'ObjectExpression') {
             throw new Error(`Expected variable ${node.name} to have an initializer`);
         }
         visitBlock(value, targetScope, result, targetPath, helpers);
         return;
     }
+    if (node.type === 'CallExpression') {
+        visitBlock(node.arguments[0], scope, result, currPath, helpers);
+        return;
+    }
     if (node.type === 'ObjectExpression') {
         let id;
         let execute;
@@ -381,12 +389,12 @@ export function findWorkflowBlockModulesFromSource(source, currPath, helpers) {
         const message = error instanceof Error ? error.message : String(error);
         return errored({ code: 'WORKFLOW_BLOCK_RESOLUTION_FAILED', message });
     }
-    return complete(result);
+    return complete({ blocks: result });
 }
 export async function findWorkflowBlockModules(srcDirAbsolute) {
     const appEntryPoint = await getAppEntryPoint(srcDirAbsolute);
     if (!appEntryPoint) {
-        return complete(new Map());
+        return complete({ blocks: new Map() });
     }
     const getModuleSource = (path) => {
         return fs.readFileSync(path, 'utf-8');

package/lib/build/server/generate-server-entry.js

@@ -16,7 +16,7 @@ async function findServerFunctionModules(cwd, pattern) {
         });
     }
 }
-export async function generateServerEntry({ appDirAbsolute, srcDirAbsolute, webhooksDirAbsolute, eventDirAbsolute, workflowBlockModules, log, }) {
+export async function generateServerEntry({ appDirAbsolute, srcDirAbsolute, webhooksDirAbsolute, eventDirAbsolute, workflowBlockModules, toolModules = new Map(), log, }) {
     const pathsResult = await combineAsync({
         serverFunctionConcretePaths: findServerFunctionModules(srcDirAbsolute, 'server'),
         webhookConcretePaths: findServerFunctionModules(webhooksDirAbsolute, 'webhook'),
@@ -105,6 +105,51 @@ export async function generateServerEntry({ appDirAbsolute, srcDirAbsolute, webh
             };
         }
 
+        // Tool module registry
+        const toolModulesMap = new Map()
+
+        ${[...toolModules.entries()]
+        .map(([toolId, handlers]) => `toolModulesMap.set(
+                        ${JSON.stringify(toolId)},
+                        {
+                        ${[...Object.entries(handlers)]
+        .map(([handler, data]) => data
+        ? `${JSON.stringify(handler)}: {
+                                        module: () => import(${JSON.stringify(path.join(appDirAbsolute, data.path))}),
+                                        export: ${JSON.stringify(data.export)}
+                                    },`
+        : '')
+        .join('\n')}
+                        }
+                    )`)
+        .join('\n')}
+
+        // Build __AUXX_TOOLS__ — the single tool registry read by the unified
+        // lambda tool-executor for both agent-surfaced and action-surfaced
+        // invocations. Mirrors __AUXX_WORKFLOW_BLOCKS__: the executor reads
+        // execute(input, ctx) off this global. See plans/kopilot/agents/triggers/app-surface-implementation-plan.md §5.2.
+        const __AUXX_TOOLS__ = {};
+
+        for (const [toolId, handlers] of toolModulesMap.entries()) {
+            __AUXX_TOOLS__[toolId] = {
+                execute: async (...args) => {
+                    const executeHandler = handlers.execute;
+                    if (!executeHandler) {
+                        throw new Error(\`No execute handler for tool \${toolId}\`);
+                    }
+                    const module = await executeHandler.module();
+                    const func = module[executeHandler.export];
+                    if (!func) {
+                        throw new Error(\`Execute export not found in tool \${toolId}\`);
+                    }
+                    if (typeof func !== "function") {
+                        throw new Error(\`Execute export in tool \${toolId} is not a function\`);
+                    }
+                    return await func(...args);
+                }
+            };
+        }
+
         var stdin_default;
         var stdin_webhooks_default;
         var stdin_events_default;

package/lib/build/server/zod-to-provider-tool-schema.js

@@ -0,0 +1,42 @@
+import { z } from 'zod/v4';
+export function zodToProviderToolSchema(schema, _provider = 'anthropic') {
+    const raw = z.toJSONSchema(schema, { unrepresentable: 'any' });
+    delete raw.$schema;
+    delete raw.id;
+    const refs = [];
+    const cleaned = stripAuxxRefAndMineRefs(raw, [], refs);
+    return { jsonSchema: cleaned, refs };
+}
+function stripAuxxRefAndMineRefs(node, path, out) {
+    if (!node || typeof node !== 'object')
+        return node;
+    if (Array.isArray(node)) {
+        return node.map((entry, i) => stripAuxxRefAndMineRefs(entry, [...path, String(i)], out));
+    }
+    const obj = { ...node };
+    if (obj.auxxRef && typeof obj.auxxRef === 'object') {
+        const kind = obj.auxxRef.kind;
+        if (typeof kind === 'string') {
+            out.push({ path: [...path], kind });
+        }
+        delete obj.auxxRef;
+    }
+    if (obj.properties && typeof obj.properties === 'object') {
+        const props = obj.properties;
+        const cleanedProps = {};
+        for (const key of Object.keys(props)) {
+            cleanedProps[key] = stripAuxxRefAndMineRefs(props[key], [...path, key], out);
+        }
+        obj.properties = cleanedProps;
+    }
+    if (obj.items) {
+        obj.items = stripAuxxRefAndMineRefs(obj.items, [...path, '[]'], out);
+    }
+    if (obj.anyOf) {
+        obj.anyOf = obj.anyOf.map((entry) => stripAuxxRefAndMineRefs(entry, path, out));
+    }
+    if (obj.oneOf) {
+        obj.oneOf = obj.oneOf.map((entry) => stripAuxxRefAndMineRefs(entry, path, out));
+    }
+    return obj;
+}

package/lib/client/workflow/index.d.ts

@@ -1,4 +1,4 @@
-export type { BaseType, Connection, InferWorkflowInput, InferWorkflowOutput, WorkflowBlock, WorkflowCategory, WorkflowExecutionContext, WorkflowOrganization, WorkflowSchema, WorkflowSDK, WorkflowTrigger, WorkflowUser, } from '../../root/workflow/types.js';
+export type { BaseType, Connection, InferWorkflowInput, InferWorkflowOutput, Trigger, WorkflowBlock, WorkflowCategory, WorkflowExecutionContext, WorkflowOrganization, WorkflowSchema, WorkflowSDK, WorkflowUser, } from '../../root/workflow/types.js';
 export * from './components/index.js';
 export * from './hooks/index.js';
 export type { PathTo, PathToField, ValueAtPath } from './types/index.js';

package/lib/client/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/workflow/index.ts"],"names":[],"mappings":"AASA,YAAY,EACV,QAAQ,EACR,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB,EACpB,cAAc,EACd,WAAW,EACX,eAAe,EACf,YAAY,GACb,MAAM,8BAA8B,CAAA;AAGrC,cAAc,uBAAuB,CAAA;AAErC,cAAc,kBAAkB,CAAA;AAEhC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/workflow/index.ts"],"names":[],"mappings":"AASA,YAAY,EACV,QAAQ,EACR,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,OAAO,EACP,aAAa,EACb,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB,EACpB,cAAc,EACd,WAAW,EACX,YAAY,GACb,MAAM,8BAA8B,CAAA;AAGrC,cAAc,uBAAuB,CAAA;AAErC,cAAc,kBAAkB,CAAA;AAEhC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}

package/lib/commands/dev/bundle-javascript.js

@@ -1,5 +1,7 @@
+import chalk from 'chalk';
 import chokidar from 'chokidar';
 import { complete, isComplete, isErrored } from '../../errors.js';
+import { compileAndExtractCatalog, } from '../../util/compile-and-extract-catalog.js';
 import { compileAndExtractSettingsSchema } from '../../util/compile-and-extract-settings.js';
 import { prepareBuildContext } from './prepare-build-context.js';
 export function bundleJavaScript(onSuccess, onError) {
@@ -39,7 +41,21 @@ export function bundleJavaScript(onSuccess, onError) {
             }
             const results = bundleResults.value;
             const settingsSchema = await compileAndExtractSettingsSchema();
-            await onSuccess?.([results.client.outputFiles[0].text, results.server.outputFiles[0].text], settingsSchema);
+            const catalogResult = await compileAndExtractCatalog();
+            let catalog;
+            if (isErrored(catalogResult)) {
+                const err = catalogResult.error;
+                const detail = 'error' in err && err.error instanceof Error
+                    ? `\n    ${err.error.message}`
+                    : 'message' in err
+                        ? `\n    ${err.message}`
+                        : '';
+                process.stderr.write(chalk.yellow(`⚠ Catalog extraction failed (${err.code}) — deployment will ship with no catalog${detail}\n`));
+            }
+            else {
+                catalog = catalogResult.value;
+            }
+            await onSuccess?.([results.client.outputFiles[0].text, results.server.outputFiles[0].text], settingsSchema, catalog);
             isBuilding = false;
             if (buildQueued && !isDisposing) {
                 buildQueued = false;

package/lib/commands/dev/prepare-build-context.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import path from 'path';
+import { findToolModules } from '../../build/server/find-tool-server-modules.js';
 import { findWorkflowBlockModules } from '../../build/server/find-workflow-block-server-modules.js';
 import { combine, combineAsync, complete, isComplete, isErrored, map, } from '../../errors.js';
 import { ClientBuilder } from './client-builder.js';
@@ -41,10 +42,15 @@ export async function prepareBuildContext(mode) {
             if (isErrored(workflowBlockModulesResult)) {
                 return workflowBlockModulesResult;
             }
-            const workflowBlockModules = workflowBlockModulesResult.value;
+            const toolModulesResult = await findToolModules(srcDir);
+            if (isErrored(toolModulesResult)) {
+                return toolModulesResult;
+            }
+            const { blocks: workflowBlockModules } = workflowBlockModulesResult.value;
+            const toolModules = toolModulesResult.value;
             return combineAsync({
                 client: client.rebuild({ workflowBlockModules }),
-                server: server.rebuild({ workflowBlockModules }),
+                server: server.rebuild({ workflowBlockModules, toolModules }),
             });
         },
         dispose: async (timeoutMs) => {
@@ -86,5 +92,8 @@ export function printBuildContextError(error) {
         case 'WORKFLOW_BLOCK_RESOLUTION_FAILED':
             process.stderr.write(`${chalk.red('✖ ')}Failed to build workflow block(s): ${error.message}\n`);
             break;
+        case 'TOOL_RESOLUTION_FAILED':
+            process.stderr.write(`${chalk.red('✖ ')}Failed to resolve tool(s): ${error.message}\n`);
+            break;
     }
 }

package/lib/commands/dev/server-builder.js

@@ -42,13 +42,14 @@ export class ServerBuilder {
             });
         }
     }
-    async rebuild({ workflowBlockModules, }) {
+    async rebuild({ workflowBlockModules, toolModules, }) {
         const jsResult = await generateServerEntry({
             appDirAbsolute: path.resolve(this._directories.app),
             srcDirAbsolute: path.resolve(this._directories.src),
             webhooksDirAbsolute: path.resolve(this._directories.webhooks),
             eventDirAbsolute: path.resolve(this._directories.events),
             workflowBlockModules,
+            toolModules: toolModules ?? new Map(),
             log: console.log,
         });
         if (isErrored(jsResult)) {

package/lib/commands/dev/upload.js

@@ -5,7 +5,7 @@ import { combineAsync, complete, isErrored } from '../../errors.js';
 import { calculateBundleSha } from '../../util/calculate-bundle-sha.js';
 import { spinnerify } from '../../util/spinner.js';
 import { uploadBundle } from '../../util/upload-bundle.js';
-export async function upload({ contents, appId, targetOrganizationId, environmentVariables, cliVersion, settingsSchema, }) {
+export async function upload({ contents, appId, targetOrganizationId, environmentVariables, cliVersion, settingsSchema, catalog, }) {
     return await spinnerify('Uploading...', () => `Upload complete at ${new Date().toLocaleTimeString()}`, async () => {
         const [clientBundle, serverBundle] = contents;
         const clientSha = calculateBundleSha(clientBundle);
@@ -34,6 +34,9 @@ export async function upload({ contents, appId, targetOrganizationId, environmen
         if (settingsSchema) {
             process.stdout.write(`${chalk.green('✓ ')}Settings schema included\n`);
         }
+        if (catalog && (catalog.tools.length || catalog.toolsets.length)) {
+            process.stdout.write(`${chalk.green('✓ ')}Catalog extracted (${catalog.tools.length} tools, ${catalog.toolsets.length} toolsets, ${catalog.workflow.blocks.length} blocks, ${catalog.triggers.length} triggers, ${catalog.actions.length} actions)\n`);
+        }
         const deployResult = await api.createDeployment({
             appId,
             clientBundleSha: clientSha,
@@ -42,6 +45,7 @@ export async function upload({ contents, appId, targetOrganizationId, environmen
             targetOrganizationId,
             environmentVariables,
             settingsSchema,
+            catalog,
             metadata: { cliVersion },
         });
         if (isErrored(deployResult)) {

package/lib/commands/dev.js

@@ -129,7 +129,7 @@ export const dev = new Command('dev')
         });
         cleanupFunctions.push(cleanupTs);
         let haveBundlingErrors = false;
-        const cleanupJs = bundleJavaScript(async (contents, settingsSchema) => {
+        const cleanupJs = bundleJavaScript(async (contents, settingsSchema, catalog) => {
             if (haveBundlingErrors) {
                 process.stdout.write(`${chalk.green('✓')} Bundling errors fixed\n`);
                 haveBundlingErrors = false;
@@ -141,6 +141,7 @@ export const dev = new Command('dev')
                 environmentVariables,
                 cliVersion,
                 settingsSchema,
+                catalog,
             });
             if (isErrored(uploadResult)) {
                 printUploadError(uploadResult);

package/lib/commands/version/create/bundle-javascript.js

@@ -1,4 +1,5 @@
 import { complete, errored, isErrored } from '../../../errors.js';
+import { compileAndExtractCatalog, } from '../../../util/compile-and-extract-catalog.js';
 import { compileAndExtractSettingsSchema } from '../../../util/compile-and-extract-settings.js';
 import { prepareBuildContext } from '../../dev/prepare-build-context.js';
 export async function bundleJavaScript() {
@@ -26,8 +27,11 @@ export async function bundleJavaScript() {
         });
     }
     const settingsSchema = await compileAndExtractSettingsSchema();
+    const catalogResult = await compileAndExtractCatalog();
+    const catalog = isErrored(catalogResult) ? undefined : catalogResult.value;
     return complete({
         bundles: [builds.client.outputFiles[0].text, builds.server.outputFiles[0].text],
         settingsSchema,
+        catalog,
     });
 }

package/lib/commands/version/create.js

@@ -64,11 +64,14 @@ export const versionCreate = new Command('create')
         }
         process.exit(1);
     }
-    const { bundles, settingsSchema } = bundleResult.value;
+    const { bundles, settingsSchema, catalog } = bundleResult.value;
     const [clientBundle, serverBundle] = bundles;
     if (settingsSchema) {
         process.stdout.write(`${chalk.green('✓ ')}Settings schema extracted\n`);
     }
+    if (catalog && (catalog.tools.length || catalog.toolsets.length)) {
+        process.stdout.write(`${chalk.green('✓ ')}Catalog extracted (${catalog.tools.length} tools, ${catalog.toolsets.length} toolsets, ${catalog.workflow.blocks.length} blocks, ${catalog.triggers.length} triggers, ${catalog.actions.length} actions)\n`);
+    }
     const deployResult = await spinnerify('Uploading...', 'Upload complete', async () => {
         const cliVersionResult = loadAuxxCliVersion();
         if (isErrored(cliVersionResult)) {
@@ -112,6 +115,7 @@ export const versionCreate = new Command('create')
             serverBundleSha: serverSha,
             deploymentType: 'production',
             settingsSchema,
+            catalog,
             metadata: { cliVersion },
         });
         if (isErrored(result)) {

package/lib/env-loader.js

@@ -1,2 +1,18 @@
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import dotenv from 'dotenv';
-dotenv.config();
+function findEnvFile() {
+    let dir = resolve(process.cwd());
+    const root = dirname(dir) === dir ? dir : '/';
+    while (true) {
+        const candidate = join(dir, '.env');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir || dir === root)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+dotenv.config({ path: findEnvFile() });