@auxx/sdk 0.0.12 → 0.0.13

package/lib/util/compile-and-extract-catalog.js

@@ -0,0 +1,279 @@
+import * as esbuild from 'esbuild';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { HIDDEN_AUXX_DIRECTORY } from '../constants/hidden-auxx-directory.js';
+import { complete, errored } from '../errors.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SDK_ROOT = path.resolve(__dirname, '..', '..');
+export async function compileAndExtractCatalog() {
+    const srcDirAbsolute = path.resolve('src');
+    const candidates = ['app.ts', 'app.tsx'];
+    let appEntry;
+    for (const c of candidates) {
+        const p = path.join(srcDirAbsolute, c);
+        try {
+            await fs.access(p);
+            appEntry = p;
+            break;
+        }
+        catch {
+        }
+    }
+    if (!appEntry) {
+        return complete(undefined);
+    }
+    const auxxDir = path.resolve(HIDDEN_AUXX_DIRECTORY);
+    await fs.mkdir(auxxDir, { recursive: true });
+    const outputPath = path.join(auxxDir, 'app.catalog.mjs');
+    const stubServerImports = {
+        name: 'auxx-stub-server-imports',
+        setup(build) {
+            build.onResolve({ filter: /\.server(\.tsx?)?$/ }, (args) => ({
+                path: args.path,
+                namespace: 'auxx-server-stub',
+            }));
+            build.onLoad({ filter: /.*/, namespace: 'auxx-server-stub' }, () => ({
+                contents: 'export default async () => { throw new Error("stubbed at catalog extraction") }',
+                loader: 'js',
+            }));
+        },
+    };
+    const SDK_REAL_BARE = path.join(SDK_ROOT, 'lib', 'root', 'index.js');
+    const SDK_REAL_TOOLS = path.join(SDK_ROOT, 'lib', 'root', 'tools', 'index.js');
+    const SDK_REAL_WORKFLOW = path.join(SDK_ROOT, 'lib', 'root', 'workflow', 'index.js');
+    const stubSdkSubpaths = {
+        name: 'auxx-stub-sdk-subpaths',
+        setup(build) {
+            build.onResolve({ filter: /^@auxx\/sdk(\/.*)?$/ }, (args) => {
+                if (args.path === '@auxx/sdk')
+                    return { path: SDK_REAL_BARE };
+                if (args.path === '@auxx/sdk/tools')
+                    return { path: SDK_REAL_TOOLS };
+                if (args.path === '@auxx/sdk/workflow')
+                    return { path: SDK_REAL_WORKFLOW };
+                return { path: args.path, namespace: 'auxx-sdk-stub' };
+            });
+            build.onLoad({ filter: /.*/, namespace: 'auxx-sdk-stub' }, () => ({
+                contents: `
+          const noop = () => null;
+          const handler = { get: (target, prop) => {
+            if (prop in target) return target[prop];
+            if (prop === '__esModule') return true;
+            if (typeof prop === 'symbol') return undefined;
+            return noop;
+          }};
+          module.exports = new Proxy({}, handler);
+        `,
+                loader: 'js',
+            }));
+        },
+    };
+    try {
+        await esbuild.build({
+            entryPoints: [appEntry],
+            bundle: true,
+            outfile: outputPath,
+            format: 'esm',
+            platform: 'node',
+            target: ['node18'],
+            logLevel: 'silent',
+            write: true,
+            loader: {
+                '.png': 'empty',
+                '.jpg': 'empty',
+                '.jpeg': 'empty',
+                '.gif': 'empty',
+                '.webp': 'empty',
+                '.svg': 'empty',
+            },
+            plugins: [stubServerImports, stubSdkSubpaths],
+        });
+    }
+    catch (error) {
+        return errored({
+            code: 'CATALOG_COMPILE_FAILED',
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+    }
+    let appModule;
+    try {
+        const fileUrl = pathToFileURL(outputPath).href;
+        appModule = await import(`${fileUrl}?t=${Date.now()}`);
+    }
+    catch (error) {
+        return errored({
+            code: 'CATALOG_LOAD_FAILED',
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+    }
+    const app = appModule.app;
+    if (!app) {
+        return complete(undefined);
+    }
+    const toolsArr = (app.tools ?? []);
+    const toolsetsArr = (app.toolsets ?? []);
+    const workflowBlocksArr = (app.workflow?.blocks ?? []);
+    const workflowTriggersArr = (app.workflow?.triggers ?? []);
+    if (!toolsArr.length &&
+        !toolsetsArr.length &&
+        !workflowBlocksArr.length &&
+        !workflowTriggersArr.length) {
+        return complete(undefined);
+    }
+    const { zodToProviderToolSchema } = await import('../build/server/zod-to-provider-tool-schema.js');
+    const slugByToolId = new Map();
+    const cataloguedToolsets = [];
+    for (const ts of toolsetsArr) {
+        if (!ts?.id) {
+            return errored({ code: 'CATALOG_VALIDATION_FAILED', message: 'Toolset is missing an id' });
+        }
+        const slug = `app:${ts.id.replace('.', ':')}`;
+        cataloguedToolsets.push({
+            slug,
+            name: ts.name,
+            description: ts.description,
+            iconKey: null,
+            subGroup: ts.subGroup ?? null,
+        });
+        for (const toolId of ts.tools ?? []) {
+            slugByToolId.set(toolId, slug);
+        }
+    }
+    const cataloguedTools = [];
+    const cataloguedAgentTools = [];
+    const cataloguedActions = [];
+    for (const tool of toolsArr) {
+        if (!tool?.id) {
+            return errored({ code: 'CATALOG_VALIDATION_FAILED', message: 'Tool is missing an id' });
+        }
+        const inputs = zodToProviderToolSchema(tool.inputs);
+        const outputs = zodToProviderToolSchema(tool.outputs);
+        const baseTool = {
+            id: tool.id,
+            name: tool.name,
+            description: tool.description,
+            inputsJsonSchema: inputs.jsonSchema,
+            outputsJsonSchema: outputs.jsonSchema,
+            requiresConnection: Boolean(tool.config?.requiresConnection),
+            timeoutMs: tool.config?.timeout ?? 15000,
+            streaming: Boolean(tool.agent?.streaming ?? tool.config?.streaming),
+            refs: outputs.refs,
+        };
+        cataloguedTools.push(baseTool);
+        if (tool.agent) {
+            const toolsetSlug = slugByToolId.get(tool.id) ?? `app:unknown:default`;
+            cataloguedAgentTools.push({
+                ...baseTool,
+                agentName: tool.agent.name ?? tool.id,
+                agentDescription: tool.agent.description ?? tool.description,
+                toolsetSlug,
+                idempotent: tool.agent.idempotent ?? tool.config?.idempotent,
+            });
+        }
+        if (tool.action) {
+            cataloguedActions.push({
+                toolId: tool.id,
+                label: tool.action.label,
+                description: tool.action.description,
+                iconKey: null,
+                color: tool.action.color,
+                surface: tool.action.surface,
+                requiresConfirmation: tool.action.requiresConfirmation,
+                confirmationMessage: tool.action.confirmationMessage,
+            });
+        }
+    }
+    const cataloguedTriggers = [];
+    const cataloguedWorkflowTriggers = [];
+    const cataloguedAgentTriggers = [];
+    for (const trigger of workflowTriggersArr) {
+        if (!trigger?.id) {
+            return errored({ code: 'CATALOG_VALIDATION_FAILED', message: 'Trigger is missing an id' });
+        }
+        const triggerInputs = serializeWorkflowSchemaInputs(trigger.schema);
+        cataloguedTriggers.push({
+            id: trigger.id,
+            label: trigger.label,
+            description: trigger.description,
+            iconKey: null,
+            color: trigger.color,
+            inputsJsonSchema: triggerInputs,
+            refs: [],
+        });
+        if (trigger.workflow) {
+            cataloguedWorkflowTriggers.push({
+                triggerId: trigger.id,
+                label: trigger.label,
+                description: trigger.description,
+                iconKey: null,
+                color: trigger.color,
+                inputsJsonSchema: triggerInputs,
+                refs: [],
+            });
+        }
+        if (trigger.agent) {
+            cataloguedAgentTriggers.push({
+                triggerId: trigger.id,
+                label: trigger.agent.label ?? trigger.label,
+                description: trigger.agent.description ?? trigger.description,
+                iconKey: null,
+                color: trigger.color,
+                inputsJsonSchema: triggerInputs,
+                refs: [],
+            });
+        }
+    }
+    const cataloguedBlocks = [];
+    for (const block of workflowBlocksArr) {
+        if (!block?.id) {
+            return errored({ code: 'CATALOG_VALIDATION_FAILED', message: 'Block is missing an id' });
+        }
+        cataloguedBlocks.push({
+            id: block.id,
+            label: block.label,
+            description: block.description,
+            iconKey: null,
+            color: block.color,
+            inputsJsonSchema: serializeWorkflowSchemaInputs(block.schema),
+            toolMap: block.toolMap ?? {},
+            refs: [],
+        });
+    }
+    const catalog = {
+        tools: cataloguedTools,
+        triggers: cataloguedTriggers,
+        toolsets: cataloguedToolsets,
+        workflow: {
+            blocks: cataloguedBlocks,
+            triggers: cataloguedWorkflowTriggers,
+        },
+        agent: {
+            tools: cataloguedAgentTools,
+            triggers: cataloguedAgentTriggers,
+            toolsets: cataloguedToolsets,
+        },
+        actions: cataloguedActions,
+    };
+    try {
+        JSON.stringify(catalog);
+    }
+    catch (error) {
+        return errored({
+            code: 'CATALOG_NOT_SERIALIZABLE',
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return complete(catalog);
+}
+function serializeWorkflowSchemaInputs(schema) {
+    if (!schema || typeof schema !== 'object' || !schema.inputs)
+        return {};
+    const out = {};
+    for (const [key, field] of Object.entries(schema.inputs)) {
+        const fieldNode = field;
+        out[key] = typeof fieldNode?.toJSON === 'function' ? fieldNode.toJSON() : field;
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auxx/sdk",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "CLI tool and SDK for creating Auxx apps",
   "type": "module",
   "bin": {
@@ -38,6 +38,10 @@
       "types": "./lib/root/workflow/index.d.ts",
       "import": "./lib/root/workflow/index.js"
     },
+    "./tools": {
+      "types": "./lib/root/tools/index.d.ts",
+      "import": "./lib/root/tools/index.js"
+    },
     "./shared": {
       "types": "./lib/shared/index.d.ts",
       "import": "./lib/shared/index.js"