@pikku/deploy-azure 0.12.0

package/dist/adapter.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Azure Functions provider adapter for the Pikku deploy pipeline.
+ *
+ * Uses the Azure Functions v4 Node.js programming model where functions
+ * are registered in code via app.http(), app.storageQueue(), app.timer()
+ * rather than function.json files.
+ */
+type DeploymentHandler = {
+    type: 'fetch';
+    routes: Array<{
+        method: string;
+        route: string;
+        pikkuFuncId: string;
+    }>;
+} | {
+    type: 'queue';
+    queueName: string;
+} | {
+    type: 'scheduled';
+    schedule: string;
+    taskName: string;
+};
+interface DeploymentUnit {
+    name: string;
+    role: string;
+    functionIds: string[];
+    services: Array<{
+        capability: string;
+        sourceServiceName: string;
+    }>;
+    dependsOn: string[];
+    handlers: DeploymentHandler[];
+    tags: string[];
+}
+interface DeploymentManifest {
+    projectId: string;
+    units: DeploymentUnit[];
+    queues: Array<{
+        name: string;
+        consumerUnit: string;
+        consumerFunctionId: string;
+    }>;
+    scheduledTasks: Array<{
+        name: string;
+        schedule: string;
+        unitName: string;
+        functionId: string;
+    }>;
+    channels: Array<{
+        name: string;
+        route: string;
+        unitName: string;
+    }>;
+    agents: Array<{
+        name: string;
+        unitName: string;
+        model: string;
+    }>;
+    mcpEndpoints: Array<{
+        unitName: string;
+    }>;
+    workflows: Array<{
+        name: string;
+        orchestratorUnit: string;
+    }>;
+    secrets: Array<{
+        secretId: string;
+        displayName: string;
+        description?: string;
+    }>;
+    variables: Array<{
+        variableId: string;
+        displayName: string;
+        description?: string;
+    }>;
+}
+interface EntryGenerationContext {
+    unit: DeploymentUnit;
+    unitDir: string;
+    bootstrapPath: string;
+    configImport: string;
+    configVar: string;
+    servicesImport: string;
+    servicesVar: string;
+    singletonServicesImport: string;
+    servicesType: string;
+}
+export declare class AzureProviderAdapter {
+    readonly name = "azure";
+    readonly deployDirName = "azure";
+    /**
+     * Externals for esbuild. Azure Functions runs on Node.js.
+     * Same as Lambda — node builtins + Azure SDK packages.
+     */
+    getExternals(): string[];
+    generateEntrySource(ctx: EntryGenerationContext): string;
+    /**
+     * Generates entry source for function/workflow-step units.
+     * Uses Azure Functions v4 app.http(), app.storageQueue(), app.timer().
+     */
+    private generateCombinedEntry;
+    /**
+     * Generates entry source for channel units (WebSocket via Web PubSub).
+     */
+    private generateChannelEntry;
+    /**
+     * Generates entry source for mcp, agent, and workflow units.
+     */
+    private generateGatewayEntry;
+    private generatePlatformServicesBlock;
+    private generateGatewayPlatformServicesBlock;
+    /**
+     * No per-unit config files — Azure Functions v4 uses code-based registration.
+     */
+    generateUnitConfigs(_unit: DeploymentUnit, _manifest: DeploymentManifest, _projectId: string): Map<string, string>;
+    generateInfraManifest(manifest: DeploymentManifest): string | null;
+    /**
+     * Generates host.json and local.settings.json for the Function App.
+     */
+    generateProviderConfigs(manifest: DeploymentManifest): Map<string, string>;
+}
+export {};

package/dist/adapter.js

@@ -0,0 +1,272 @@
+/**
+ * Azure Functions provider adapter for the Pikku deploy pipeline.
+ *
+ * Uses the Azure Functions v4 Node.js programming model where functions
+ * are registered in code via app.http(), app.storageQueue(), app.timer()
+ * rather than function.json files.
+ */
+import { generateInfraManifest } from './infra-manifest.js';
+import { generateHostJson, generateLocalSettings } from './host-json.js';
+function getHandlerTypes(unit) {
+    const types = new Set();
+    for (const handler of unit.handlers) {
+        types.add(handler.type);
+    }
+    return [...types];
+}
+export class AzureProviderAdapter {
+    name = 'azure';
+    deployDirName = 'azure';
+    /**
+     * Externals for esbuild. Azure Functions runs on Node.js.
+     * Same as Lambda — node builtins + Azure SDK packages.
+     */
+    getExternals() {
+        const builtins = [
+            'buffer',
+            'crypto',
+            'events',
+            'fs',
+            'http',
+            'https',
+            'net',
+            'os',
+            'path',
+            'querystring',
+            'stream',
+            'string_decoder',
+            'tls',
+            'url',
+            'util',
+            'zlib',
+            'child_process',
+            'worker_threads',
+            'assert',
+            'dns',
+            'dgram',
+            'readline',
+            'tty',
+            'v8',
+            'vm',
+        ];
+        return ['node:*', ...builtins, '@azure/*'];
+    }
+    generateEntrySource(ctx) {
+        const { unit } = ctx;
+        if (unit.role === 'channel') {
+            return this.generateChannelEntry(ctx);
+        }
+        if (unit.role === 'mcp' || unit.role === 'agent') {
+            return this.generateGatewayEntry(ctx);
+        }
+        if (unit.role === 'workflow') {
+            return this.generateGatewayEntry(ctx, true);
+        }
+        return this.generateCombinedEntry(ctx);
+    }
+    /**
+     * Generates entry source for function/workflow-step units.
+     * Uses Azure Functions v4 app.http(), app.storageQueue(), app.timer().
+     */
+    generateCombinedEntry(ctx) {
+        const handlerTypes = getHandlerTypes(ctx.unit);
+        const lines = [
+            `// Generated Azure Functions entry for "${ctx.unit.name}" (${ctx.unit.role})`,
+            `import { app } from '@azure/functions'`,
+            `import { createAzureHandler } from '@pikku/azure-functions'`,
+            `import { AzureQueueService } from '@pikku/azure-functions'`,
+            `import { JsonConsoleLogger } from '@pikku/core/services'`,
+            ctx.configImport,
+            ctx.servicesImport,
+            ctx.singletonServicesImport,
+            `import { requiredSingletonServices } from './.pikku/pikku-services.gen.js'`,
+            `import '${ctx.bootstrapPath}'`,
+            ``,
+            ...this.generatePlatformServicesBlock(ctx),
+            ``,
+            `const handlers = createAzureHandler(`,
+            `  { createConfig: ${ctx.configVar}, createSingletonServices: ${ctx.servicesVar}, createPlatformServices },`,
+            `  ${JSON.stringify(handlerTypes)}`,
+            `)`,
+            ``,
+        ];
+        // Register Azure Functions v4 triggers
+        for (const handler of ctx.unit.handlers) {
+            if (handler.type === 'fetch') {
+                for (const route of handler.routes) {
+                    const method = route.method.toLowerCase();
+                    const azureRoute = route.route.replace(/:(\w+)/g, '{$1}');
+                    lines.push(`app.http('${ctx.unit.name}-${method}-${safeName(route.route)}', {`, `  methods: ['${route.method}'],`, `  route: '${azureRoute}',`, `  authLevel: 'anonymous',`, `  handler: handlers.http,`, `})`, ``);
+                }
+            }
+            if (handler.type === 'queue') {
+                lines.push(`app.storageQueue('${ctx.unit.name}-queue-${safeName(handler.queueName)}', {`, `  queueName: '${handler.queueName}',`, `  connection: 'AzureWebJobsStorage',`, `  handler: handlers.queue,`, `})`, ``);
+            }
+            if (handler.type === 'scheduled') {
+                lines.push(`app.timer('${ctx.unit.name}-timer-${safeName(handler.taskName)}', {`, `  schedule: '${toAzureCron(handler.schedule)}',`, `  handler: handlers.timer,`, `})`, ``);
+            }
+        }
+        // If no explicit routes but has fetch handler (RPC access)
+        if (handlerTypes.includes('fetch') &&
+            !ctx.unit.handlers.some((h) => h.type === 'fetch' && h.routes.length > 0)) {
+            lines.push(`app.http('${ctx.unit.name}-rpc', {`, `  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],`, `  route: '__pikku/${ctx.unit.name}/{*restOfPath}',`, `  authLevel: 'anonymous',`, `  handler: handlers.http,`, `})`, ``);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generates entry source for channel units (WebSocket via Web PubSub).
+     */
+    generateChannelEntry(ctx) {
+        const lines = [
+            `// Generated Azure Functions WebSocket entry for "${ctx.unit.name}" (${ctx.unit.role})`,
+            `import { app } from '@azure/functions'`,
+            `import { createAzureWebSocketHandler } from '@pikku/azure-functions'`,
+            `import { JsonConsoleLogger } from '@pikku/core/services'`,
+            ctx.configImport,
+            ctx.servicesImport,
+            ctx.singletonServicesImport,
+            `import { requiredSingletonServices } from './.pikku/pikku-services.gen.js'`,
+            `import '${ctx.bootstrapPath}'`,
+            ``,
+            ...this.generatePlatformServicesBlock(ctx),
+            ``,
+            `const handlers = createAzureWebSocketHandler(`,
+            `  { createConfig: ${ctx.configVar}, createSingletonServices: ${ctx.servicesVar}, createPlatformServices }`,
+            `)`,
+            ``,
+            `app.http('${ctx.unit.name}-connect', {`,
+            `  methods: ['GET'],`,
+            `  route: 'ws/${ctx.unit.name}',`,
+            `  authLevel: 'anonymous',`,
+            `  handler: handlers.negotiate,`,
+            `})`,
+            ``,
+        ];
+        return lines.join('\n');
+    }
+    /**
+     * Generates entry source for mcp, agent, and workflow units.
+     */
+    generateGatewayEntry(ctx, includeQueueHandler = false) {
+        const bindingEntries = ctx.unit.dependsOn.map((dep) => {
+            return `    '${fromKebab(dep)}': process.env.AZURE_FUNC_URL_${toScreamingSnake(dep)} || ''`;
+        });
+        const bindingsMap = `{\n${bindingEntries.join(',\n')}\n  }`;
+        const handlerTypes = includeQueueHandler
+            ? `["fetch", "queue"]`
+            : `["fetch"]`;
+        const lines = [
+            `// Generated Azure Functions gateway entry for "${ctx.unit.name}" (${ctx.unit.role})`,
+            `import { app } from '@azure/functions'`,
+            `import { createAzureHandler } from '@pikku/azure-functions'`,
+            `import { AzureQueueService, AzureDeploymentService } from '@pikku/azure-functions'`,
+            `import { JsonConsoleLogger } from '@pikku/core/services'`,
+            ctx.configImport,
+            ctx.servicesImport,
+            ctx.singletonServicesImport,
+            `import { requiredSingletonServices } from './.pikku/pikku-services.gen.js'`,
+            `import '${ctx.bootstrapPath}'`,
+            ``,
+            ...this.generateGatewayPlatformServicesBlock(ctx, bindingsMap),
+            ``,
+            `const handlers = createAzureHandler(`,
+            `  { createConfig: ${ctx.configVar}, createSingletonServices: ${ctx.servicesVar}, createPlatformServices },`,
+            `  ${handlerTypes}`,
+            `)`,
+            ``,
+        ];
+        // Register HTTP routes for the gateway
+        for (const handler of ctx.unit.handlers) {
+            if (handler.type === 'fetch') {
+                for (const route of handler.routes) {
+                    const method = route.method.toLowerCase();
+                    const azureRoute = route.route.replace(/:(\w+)/g, '{$1}');
+                    lines.push(`app.http('${ctx.unit.name}-${method}-${safeName(route.route)}', {`, `  methods: ['${route.method}'],`, `  route: '${azureRoute}',`, `  authLevel: 'anonymous',`, `  handler: handlers.http,`, `})`, ``);
+                }
+            }
+            if (handler.type === 'queue') {
+                lines.push(`app.storageQueue('${ctx.unit.name}-queue', {`, `  queueName: '${handler.queueName}',`, `  connection: 'AzureWebJobsStorage',`, `  handler: handlers.queue,`, `})`, ``);
+            }
+        }
+        // Catch-all for RPC if no explicit routes
+        if (!ctx.unit.handlers.some((h) => h.type === 'fetch' && h.routes.length > 0)) {
+            lines.push(`app.http('${ctx.unit.name}-rpc', {`, `  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],`, `  route: '__pikku/${ctx.unit.name}/{*restOfPath}',`, `  authLevel: 'anonymous',`, `  handler: handlers.http,`, `})`, ``);
+        }
+        return lines.join('\n');
+    }
+    generatePlatformServicesBlock(ctx) {
+        return [
+            `const createPlatformServices = async (): Promise<${ctx.servicesType}> => {`,
+            `  const services: ${ctx.servicesType} = {}`,
+            `  const logger = new JsonConsoleLogger()`,
+            `  services.logger = logger`,
+            `  if (requiredSingletonServices.queueService) {`,
+            `    services.queueService = new AzureQueueService()`,
+            `  }`,
+            `  return services`,
+            `}`,
+        ];
+    }
+    generateGatewayPlatformServicesBlock(ctx, bindingsMap) {
+        return [
+            `const createPlatformServices = async (existingServices?: Record<string, unknown>): Promise<${ctx.servicesType}> => {`,
+            `  const services: ${ctx.servicesType} = {}`,
+            `  const logger = new JsonConsoleLogger()`,
+            `  services.logger = logger`,
+            `  if (requiredSingletonServices.queueService) {`,
+            `    services.queueService = new AzureQueueService()`,
+            `  }`,
+            `  services.deploymentService = new AzureDeploymentService(`,
+            `    existingServices?.jwt as any,`,
+            `    existingServices?.secrets as any,`,
+            `    ${bindingsMap}`,
+            `  )`,
+            `  return services`,
+            `}`,
+        ];
+    }
+    /**
+     * No per-unit config files — Azure Functions v4 uses code-based registration.
+     */
+    generateUnitConfigs(_unit, _manifest, _projectId) {
+        return new Map();
+    }
+    generateInfraManifest(manifest) {
+        const infraManifest = generateInfraManifest(manifest);
+        return JSON.stringify(infraManifest, null, 2);
+    }
+    /**
+     * Generates host.json and local.settings.json for the Function App.
+     */
+    generateProviderConfigs(manifest) {
+        const configs = new Map();
+        configs.set('host.json', generateHostJson());
+        configs.set('local.settings.json', generateLocalSettings(manifest.secrets, manifest.variables));
+        return configs;
+    }
+}
+function toScreamingSnake(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/-/g, '_')
+        .toUpperCase();
+}
+function fromKebab(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function safeName(str) {
+    return str.replace(/[^a-zA-Z0-9]/g, '-').replace(/-+/g, '-');
+}
+/**
+ * Converts 5-field UNIX cron to 6-field Azure cron (NCrontab).
+ * Azure uses: {second} {minute} {hour} {day} {month} {day-of-week}
+ */
+function toAzureCron(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length >= 6)
+        return schedule;
+    if (parts.length === 5) {
+        return `0 ${schedule}`;
+    }
+    return schedule;
+}

package/dist/host-json.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generates host.json for Azure Functions.
+ *
+ * This is the global configuration file for the Function App.
+ */
+export declare function generateHostJson(): string;
+/**
+ * Generates local.settings.json for Azure Functions local dev.
+ *
+ * Contains environment variables and connection strings.
+ */
+export declare function generateLocalSettings(secrets: Array<{
+    secretId: string;
+}>, variables: Array<{
+    variableId: string;
+}>): string;

package/dist/host-json.js

@@ -0,0 +1,48 @@
+/**
+ * Generates host.json for Azure Functions.
+ *
+ * This is the global configuration file for the Function App.
+ */
+export function generateHostJson() {
+    return JSON.stringify({
+        version: '2.0',
+        logging: {
+            applicationInsights: {
+                samplingSettings: {
+                    isEnabled: true,
+                    excludedTypes: 'Request',
+                },
+            },
+        },
+        extensionBundle: {
+            id: 'Microsoft.Azure.Functions.ExtensionBundle',
+            version: '[4.*, 5.0.0)',
+        },
+        extensions: {
+            http: {
+                routePrefix: '',
+            },
+        },
+    }, null, 2);
+}
+/**
+ * Generates local.settings.json for Azure Functions local dev.
+ *
+ * Contains environment variables and connection strings.
+ */
+export function generateLocalSettings(secrets, variables) {
+    const values = {
+        AzureWebJobsStorage: 'UseDevelopmentStorage=true',
+        FUNCTIONS_WORKER_RUNTIME: 'node',
+    };
+    for (const secret of secrets) {
+        values[secret.secretId] = '';
+    }
+    for (const variable of variables) {
+        values[variable.variableId] = '';
+    }
+    return JSON.stringify({
+        IsEncrypted: false,
+        Values: values,
+    }, null, 2);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @pikku/deploy-azure — Azure Functions adapter for Pikku.
+ *
+ * Generates Azure Functions v4 entry points with code-based trigger
+ * registration, host.json, and local.settings.json.
+ */
+import { AzureProviderAdapter } from './adapter.js';
+export { AzureProviderAdapter };
+export declare const createAdapter: () => AzureProviderAdapter;
+export { generateInfraManifest } from './infra-manifest.js';
+export { generateHostJson, generateLocalSettings } from './host-json.js';
+export type { AzureInfraManifest, AzureUnitManifest, AzureQueueResource, AzureBlobResource, AzureTimerResource, AzureWebPubSubResource, } from './types.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @pikku/deploy-azure — Azure Functions adapter for Pikku.
+ *
+ * Generates Azure Functions v4 entry points with code-based trigger
+ * registration, host.json, and local.settings.json.
+ */
+import { AzureProviderAdapter } from './adapter.js';
+export { AzureProviderAdapter };
+export const createAdapter = () => new AzureProviderAdapter();
+export { generateInfraManifest } from './infra-manifest.js';
+export { generateHostJson, generateLocalSettings } from './host-json.js';

package/dist/infra-manifest.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Generates an Azure-specific infrastructure manifest from a provider-agnostic
+ * DeploymentManifest.
+ */
+import type { AzureInfraManifest } from './types.js';
+type DeploymentHandler = {
+    type: 'fetch';
+    routes: Array<{
+        method: string;
+        route: string;
+        pikkuFuncId: string;
+    }>;
+} | {
+    type: 'queue';
+    queueName: string;
+} | {
+    type: 'scheduled';
+    schedule: string;
+    taskName: string;
+};
+interface DeploymentUnit {
+    name: string;
+    role: string;
+    functionIds: string[];
+    services: Array<{
+        capability: string;
+        sourceServiceName: string;
+    }>;
+    dependsOn: string[];
+    handlers: DeploymentHandler[];
+    tags: string[];
+}
+interface DeploymentManifest {
+    projectId: string;
+    units: DeploymentUnit[];
+    queues: Array<{
+        name: string;
+        consumerUnit: string;
+        consumerFunctionId: string;
+    }>;
+    scheduledTasks: Array<{
+        name: string;
+        schedule: string;
+        unitName: string;
+        functionId: string;
+    }>;
+    channels: Array<{
+        name: string;
+        route: string;
+        unitName: string;
+    }>;
+    agents: Array<{
+        name: string;
+        unitName: string;
+        model: string;
+    }>;
+    mcpEndpoints: Array<{
+        unitName: string;
+    }>;
+    workflows: Array<{
+        name: string;
+        orchestratorUnit: string;
+    }>;
+    secrets: Array<{
+        secretId: string;
+        displayName: string;
+        description?: string;
+    }>;
+    variables: Array<{
+        variableId: string;
+        displayName: string;
+        description?: string;
+    }>;
+}
+export declare function generateInfraManifest(manifest: DeploymentManifest): AzureInfraManifest;
+export {};

package/dist/infra-manifest.js

@@ -0,0 +1,79 @@
+/**
+ * Generates an Azure-specific infrastructure manifest from a provider-agnostic
+ * DeploymentManifest.
+ */
+export function generateInfraManifest(manifest) {
+    const projectId = manifest.projectId;
+    // Storage queues
+    const storageQueues = [];
+    for (const q of manifest.queues) {
+        storageQueues.push({
+            name: q.name,
+            consumerUnit: q.consumerUnit,
+        });
+    }
+    // Blob containers — if any unit needs object-storage
+    const needsStorage = manifest.units.some((u) => u.services.some((s) => s.capability === 'object-storage'));
+    const blobContainers = needsStorage ? [{ name: `${projectId}-storage`, binding: 'STORAGE' }] : [];
+    // Timer triggers
+    const timerTriggers = [];
+    for (const unit of manifest.units) {
+        for (const handler of unit.handlers) {
+            if (handler.type === 'scheduled') {
+                timerTriggers.push({
+                    unit: unit.name,
+                    schedule: handler.schedule,
+                    name: handler.taskName,
+                });
+            }
+        }
+    }
+    // Web PubSub — one per channel unit
+    const webPubSub = [];
+    for (const unit of manifest.units) {
+        if (unit.role === 'channel') {
+            webPubSub.push({ unit: unit.name });
+        }
+    }
+    // Per-unit manifest
+    const units = {};
+    for (const unit of manifest.units) {
+        const capabilities = unit.services.map((s) => s.capability);
+        const routes = [];
+        for (const handler of unit.handlers) {
+            if (handler.type === 'fetch') {
+                for (const r of handler.routes) {
+                    routes.push({ method: r.method, route: r.route });
+                }
+            }
+        }
+        const handlerTypes = [...new Set(unit.handlers.map((h) => h.type))];
+        units[unit.name] = {
+            role: unit.role,
+            handlerTypes,
+            routes,
+            capabilities,
+            dependsOn: unit.dependsOn,
+        };
+    }
+    return {
+        projectId,
+        resources: {
+            storageQueues,
+            blobContainers,
+            timerTriggers,
+            webPubSub,
+        },
+        secrets: manifest.secrets.map((s) => ({
+            id: s.secretId,
+            displayName: s.displayName,
+            description: s.description,
+        })),
+        variables: manifest.variables.map((v) => ({
+            id: v.variableId,
+            displayName: v.displayName,
+            description: v.description,
+        })),
+        units,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Azure Functions specific types for the deploy adapter.
+ */
+export interface AzureInfraManifest {
+    projectId: string;
+    resources: {
+        storageQueues: AzureQueueResource[];
+        blobContainers: AzureBlobResource[];
+        timerTriggers: AzureTimerResource[];
+        webPubSub: AzureWebPubSubResource[];
+    };
+    secrets: Array<{
+        id: string;
+        displayName: string;
+        description?: string;
+    }>;
+    variables: Array<{
+        id: string;
+        displayName: string;
+        description?: string;
+    }>;
+    units: Record<string, AzureUnitManifest>;
+}
+export interface AzureQueueResource {
+    name: string;
+    consumerUnit: string;
+}
+export interface AzureBlobResource {
+    name: string;
+    binding: string;
+}
+export interface AzureTimerResource {
+    unit: string;
+    schedule: string;
+    name: string;
+}
+export interface AzureWebPubSubResource {
+    unit: string;
+}
+export interface AzureUnitManifest {
+    role: string;
+    handlerTypes: string[];
+    routes: Array<{
+        method: string;
+        route: string;
+    }>;
+    capabilities: string[];
+    dependsOn: string[];
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Azure Functions specific types for the deploy adapter.
+ */
+export {};

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@pikku/deploy-azure",
+  "version": "0.12.0",
+  "type": "module",
+  "private": false,
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc -b",
+    "tsc": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "^5.9"
+  }
+}