@auxx/sdk 0.0.12 → 0.0.14

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, publish, }) {
         const result = await this.fetcher.post({
             path: `/api/v1/apps/${appId}/deployments`,
             body: {
@@ -131,10 +131,12 @@ class ApiImpl {
                 serverBundleSha,
                 deploymentType,
                 settingsSchema,
+                catalog,
                 targetOrganizationId,
                 environmentVariables,
                 version,
                 metadata,
+                publish,
             },
             schema: createDeploymentResponseSchema,
         });

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()),
 });
@@ -68,6 +69,9 @@ export const confirmBundlesResponseSchema = z.object({
 export const createDeploymentResponseSchema = z.object({
     deploymentId: z.string(),
     version: z.string().nullable(),
+    status: z.string().optional(),
+    publishError: z.string().optional(),
+    unchanged: z.boolean().optional(),
 });
 export const deploymentSchema = z.object({
     id: z.string(),

package/lib/auth/auth.js

@@ -14,6 +14,9 @@ class Authenticator {
     isRefreshingToken = false;
     refreshTimeout = null;
     async ensureAuthed() {
+        if (process.env.AUXX_API_KEY) {
+            return { success: true, value: process.env.AUXX_API_KEY };
+        }
         const existingTokenResult = await getKeychain().load();
         if (isError(existingTokenResult)) {
             return this.promptToAuthenticate();

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/build/validate-typescript.js

@@ -1,6 +1,11 @@
+import chalk from 'chalk';
 import path from 'path';
-import { complete, errored } from '../../errors.js';
-import { getDiagnostics, readConfig, typeScriptErrorSchema } from '../../util/typescript.js';
+import { complete, errored, isErrored } from '../../errors.js';
+import { ensureAppFieldsTypes } from '../../util/ensure-app-fields-types.js';
+import { generateAppEnvTypes } from '../../util/generate-app-env-types.js';
+import { hardExit } from '../../util/hard-exit.js';
+import { spinnerify } from '../../util/spinner.js';
+import { getDiagnostics, printTsError, readConfig, typeScriptErrorSchema, } from '../../util/typescript.js';
 export async function validateTypeScript() {
     try {
         const program = await readConfig(path.resolve('tsconfig.json'));
@@ -22,3 +27,29 @@ export async function validateTypeScript() {
         return errored({ code: 'FILE_SYSTEM_ERROR', error });
     }
 }
+export async function validateTypeScriptOrExit() {
+    const appEnvTypesResult = await generateAppEnvTypes();
+    if (isErrored(appEnvTypesResult)) {
+        process.stderr.write(chalk.yellow(`⚠ Could not generate src/auxx-env.d.ts at ${appEnvTypesResult.error.path}. TypeScript image imports may show warnings.\n`));
+    }
+    else if (appEnvTypesResult.value === 'skipped_unmanaged') {
+        process.stderr.write(chalk.yellow('⚠ Skipping src/auxx-env.d.ts generation because the existing file is unmanaged.\n'));
+    }
+    await ensureAppFieldsTypes();
+    const tsResult = await spinnerify('Validating TypeScript...', 'TypeScript validation passed', validateTypeScript);
+    if (isErrored(tsResult)) {
+        if (tsResult.error.code === 'VALIDATE_TYPE_SCRIPT_ERROR') {
+            process.stdout.write('\n');
+            process.stderr.write(chalk.red(`✖ Found ${tsResult.error.errors.length} TypeScript error(s):\n`));
+            const errorsToShow = tsResult.error.errors.slice(0, 10);
+            for (const error of errorsToShow) {
+                printTsError(error);
+            }
+            if (tsResult.error.errors.length > 10) {
+                process.stderr.write(chalk.yellow(`\n  ... and ${tsResult.error.errors.length - 10} more error(s)\n`));
+            }
+            process.exit(1);
+        }
+        hardExit(`TypeScript validation failed: ${tsResult.error.error}`);
+    }
+}

package/lib/commands/build.js

@@ -2,12 +2,11 @@ import chalk from 'chalk';
 import { Command } from 'commander';
 import { isErrored } from '../errors.js';
 import { ensureAppEntryPoint } from '../util/ensure-app-entry-point.js';
-import { printJsError, printTsError } from '../util/error-reporting.js';
-import { generateAppEnvTypes } from '../util/generate-app-env-types.js';
+import { printJsError } from '../util/error-reporting.js';
 import { hardExit } from '../util/hard-exit.js';
 import { spinnerify } from '../util/spinner.js';
 import { buildJavaScript } from './build/build-javascript.js';
-import { validateTypeScript } from './build/validate-typescript.js';
+import { validateTypeScriptOrExit } from './build/validate-typescript.js';
 export const build = new Command('build')
     .description('Build your Auxx app for production')
     .action(async () => {
@@ -17,29 +16,7 @@ export const build = new Command('build')
             hardExit(`Could not find app entry point at ${entryPointResult.error}\n` +
                 `  Make sure you have a src/index.ts file in your project.`);
         }
-        const appEnvTypesResult = await generateAppEnvTypes();
-        if (isErrored(appEnvTypesResult)) {
-            process.stderr.write(chalk.yellow(`⚠ Could not generate src/auxx-env.d.ts at ${appEnvTypesResult.error.path}. TypeScript image imports may show warnings.\n`));
-        }
-        else if (appEnvTypesResult.value === 'skipped_unmanaged') {
-            process.stderr.write(chalk.yellow('⚠ Skipping src/auxx-env.d.ts generation because the existing file is unmanaged.\n'));
-        }
-        const tsResult = await spinnerify('Validating TypeScript...', 'TypeScript validation passed', validateTypeScript);
-        if (isErrored(tsResult)) {
-            if (tsResult.error.code === 'VALIDATE_TYPESCRIPT_ERROR') {
-                process.stdout.write('\n');
-                process.stderr.write(chalk.red(`✖ Found ${tsResult.error.errors.length} TypeScript error(s):\n`));
-                const errorsToShow = tsResult.error.errors.slice(0, 10);
-                for (const error of errorsToShow) {
-                    await printTsError(error);
-                }
-                if (tsResult.error.errors.length > 10) {
-                    process.stderr.write(chalk.yellow(`\n  ... and ${tsResult.error.errors.length - 10} more error(s)\n`));
-                }
-                process.exit(1);
-            }
-            hardExit('TypeScript validation failed: ' + tsResult.error.error.message);
-        }
+        await validateTypeScriptOrExit();
         const buildResult = await spinnerify('Building JavaScript...', 'JavaScript build completed', buildJavaScript);
         if (isErrored(buildResult)) {
             if (buildResult.error.code === 'BUILD_JAVASCRIPT_ERROR') {

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)) {