@llm-dev-ops/agentics-cli 1.4.87 → 1.4.90

package/dist/server/dependencies.d.ts

@@ -0,0 +1,178 @@
+import type { DbClient, ErpClient } from '../infra/clients.js';
+export interface AuditEntry {
+    id: string;
+    entity_type: string;
+    entity_id: string;
+    action: string;
+    actor: string;
+    payload: unknown;
+    created_at: string;
+}
+export interface IAuditPort {
+    log(entityType: string, entityId: string, action: string, actor: string, payload: unknown): Promise<AuditEntry>;
+}
+export interface DomainEnterpriseSolutionRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IDomainEnterpriseSolutionPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<DomainEnterpriseSolutionRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: DomainEnterpriseSolutionRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<DomainEnterpriseSolutionRecord | null>;
+}
+export interface MonitoringAlertsRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IMonitoringAlertsPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<MonitoringAlertsRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: MonitoringAlertsRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<MonitoringAlertsRecord | null>;
+}
+export interface OngoingRegularStakeholderRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IOngoingRegularStakeholderPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<OngoingRegularStakeholderRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: OngoingRegularStakeholderRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<OngoingRegularStakeholderRecord | null>;
+}
+export interface RiskMitigationPlanRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IRiskMitigationPlanPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<RiskMitigationPlanRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: RiskMitigationPlanRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<RiskMitigationPlanRecord | null>;
+}
+export interface TargetEnterpriseSystemRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface ITargetEnterpriseSystemPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<TargetEnterpriseSystemRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: TargetEnterpriseSystemRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<TargetEnterpriseSystemRecord | null>;
+}
+export interface UnderwritingRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IUnderwritingPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<UnderwritingRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: UnderwritingRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<UnderwritingRecord | null>;
+}
+export interface ScopedPilotReduceRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IScopedPilotReducePort {
+    execute(command: string, payload: Record<string, unknown>): Promise<ScopedPilotReduceRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: ScopedPilotReduceRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<ScopedPilotReduceRecord | null>;
+}
+export interface ReEvaluateRiskRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IReEvaluateRiskPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<ReEvaluateRiskRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: ReEvaluateRiskRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<ReEvaluateRiskRecord | null>;
+}
+export interface RecommendationRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IRecommendationPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<RecommendationRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: RecommendationRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<RecommendationRecord | null>;
+}
+export interface ApiGatewayRecord {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    data: Record<string, unknown>;
+}
+export interface IApiGatewayPort {
+    execute(command: string, payload: Record<string, unknown>): Promise<ApiGatewayRecord>;
+    query(filters: Record<string, unknown>, limit: number, offset: number): Promise<{
+        rows: ApiGatewayRecord[];
+        total: number;
+    }>;
+    getById(id: string): Promise<ApiGatewayRecord | null>;
+}
+export interface Dependencies {
+    readonly domainEnterpriseSolution: IDomainEnterpriseSolutionPort;
+    readonly monitoringAlerts: IMonitoringAlertsPort;
+    readonly ongoingRegularStakeholder: IOngoingRegularStakeholderPort;
+    readonly riskMitigationPlan: IRiskMitigationPlanPort;
+    readonly targetEnterpriseSystem: ITargetEnterpriseSystemPort;
+    readonly underwriting: IUnderwritingPort;
+    readonly scopedPilotReduce: IScopedPilotReducePort;
+    readonly reEvaluateRisk: IReEvaluateRiskPort;
+    readonly recommendation: IRecommendationPort;
+    readonly apiGateway: IApiGatewayPort;
+    readonly audit: IAuditPort;
+    readonly erp: ErpClient;
+}
+export declare function createDependencies(db: DbClient, erp: ErpClient): Dependencies;

package/dist/server/dependencies.js

@@ -0,0 +1,321 @@
+// Generated by Phase 4 pipeline — do not edit manually
+import { ConsoleTelemetry } from '../infra/telemetry.js';
+class AuditAdapter {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async log(entityType, entityId, action, actor, payload) {
+        const id = crypto.randomUUID();
+        const now = new Date().toISOString();
+        await this.db.execute('INSERT INTO audit_log (id, entity_type, entity_id, action, actor, payload, created_at) VALUES (:1, :2, :3, :4, :5, :6, :7)', [id, entityType, entityId, action, actor, JSON.stringify(payload), now]);
+        return { id, entity_type: entityType, entity_id: entityId, action, actor, payload, created_at: now };
+    }
+}
+class DomainEnterpriseSolutionAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('domain_enterprise_solution', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO domain_enterprise_solution_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('domain_enterprise_solution', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM domain_enterprise_solution_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM domain_enterprise_solution_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM domain_enterprise_solution_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class MonitoringAlertsAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('monitoring_alerts', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO monitoring_alerts_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('monitoring_alerts', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM monitoring_alerts_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM monitoring_alerts_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM monitoring_alerts_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class OngoingRegularStakeholderAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('ongoing_regular_stakeholder', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO ongoing_regular_stakeholder_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('ongoing_regular_stakeholder', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM ongoing_regular_stakeholder_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM ongoing_regular_stakeholder_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM ongoing_regular_stakeholder_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class RiskMitigationPlanAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('risk_mitigation_plan', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO risk_mitigation_plan_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('risk_mitigation_plan', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM risk_mitigation_plan_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM risk_mitigation_plan_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM risk_mitigation_plan_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class TargetEnterpriseSystemAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('target_enterprise_system', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO target_enterprise_system_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('target_enterprise_system', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM target_enterprise_system_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM target_enterprise_system_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM target_enterprise_system_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class UnderwritingAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('underwriting', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO underwriting_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('underwriting', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM underwriting_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM underwriting_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM underwriting_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class ScopedPilotReduceAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('scoped_pilot_reduce', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO scoped_pilot_reduce_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('scoped_pilot_reduce', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM scoped_pilot_reduce_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM scoped_pilot_reduce_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM scoped_pilot_reduce_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class ReEvaluateRiskAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('re_evaluate_risk', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO re_evaluate_risk_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('re_evaluate_risk', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM re_evaluate_risk_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM re_evaluate_risk_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM re_evaluate_risk_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class RecommendationAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('recommendation', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO recommendation_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('recommendation', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM recommendation_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM recommendation_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM recommendation_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+class ApiGatewayAdapter {
+    db;
+    telemetry;
+    constructor(db, telemetry) {
+        this.db = db;
+        this.telemetry = telemetry;
+    }
+    async execute(command, payload) {
+        return this.telemetry.withSpan('api_gateway', command, {}, async () => {
+            const id = crypto.randomUUID();
+            const now = new Date().toISOString();
+            await this.db.execute('INSERT INTO api_gateway_records (id, status, created_at, updated_at, data) VALUES (:1, :2, :3, :4, :5)', [id, 'active', now, now, JSON.stringify(payload)]);
+            return { id, status: 'active', created_at: now, updated_at: now, data: payload };
+        });
+    }
+    async query(filters, limit, offset) {
+        return this.telemetry.withSpan('api_gateway', 'query', {}, async () => {
+            void filters;
+            const countRows = await this.db.query('SELECT COUNT(*) as cnt FROM api_gateway_records', []);
+            const total = countRows[0]?.cnt ?? 0;
+            const dataRows = await this.db.query(`SELECT * FROM api_gateway_records ORDER BY created_at DESC LIMIT ${limit} OFFSET ${offset}`, []);
+            return { rows: dataRows, total };
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.query('SELECT * FROM api_gateway_records WHERE id = :1', [id]);
+        return rows[0] ?? null;
+    }
+}
+export function createDependencies(db, erp) {
+    const telemetry = new ConsoleTelemetry();
+    return {
+        domainEnterpriseSolution: new DomainEnterpriseSolutionAdapter(db, telemetry),
+        monitoringAlerts: new MonitoringAlertsAdapter(db, telemetry),
+        ongoingRegularStakeholder: new OngoingRegularStakeholderAdapter(db, telemetry),
+        riskMitigationPlan: new RiskMitigationPlanAdapter(db, telemetry),
+        targetEnterpriseSystem: new TargetEnterpriseSystemAdapter(db, telemetry),
+        underwriting: new UnderwritingAdapter(db, telemetry),
+        scopedPilotReduce: new ScopedPilotReduceAdapter(db, telemetry),
+        reEvaluateRisk: new ReEvaluateRiskAdapter(db, telemetry),
+        recommendation: new RecommendationAdapter(db, telemetry),
+        apiGateway: new ApiGatewayAdapter(db, telemetry),
+        audit: new AuditAdapter(db),
+        erp,
+    };
+}

package/dist/server/health.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from 'hono';
+export declare const healthRouter: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/health.js

@@ -0,0 +1,9 @@
+// Generated by Phase 4 pipeline — do not edit manually
+import { Hono } from 'hono';
+export const healthRouter = new Hono();
+healthRouter.get('/healthz', (c) => {
+    return c.json({ status: 'ok' }, 200);
+});
+healthRouter.get('/readyz', (c) => {
+    return c.json({ status: 'ready' }, 200);
+});

package/dist/server/main.d.ts

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

package/dist/server/main.js

@@ -0,0 +1,21 @@
+// Generated by Phase 4 pipeline — do not edit manually
+import { serve } from '@hono/node-server';
+import { app } from './routes.js';
+const PORT = parseInt(process.env.PORT ?? '8080', 10);
+serve({ fetch: app.fetch, port: PORT }, (info) => {
+    process.stdout.write(JSON.stringify({
+        severity: 'INFO',
+        message: 'HTTP server started',
+        port: info.port,
+        pid: process.pid,
+        timestamp: new Date().toISOString(),
+    }) + '\n');
+});
+process.on('SIGTERM', () => {
+    process.stdout.write(JSON.stringify({
+        severity: 'INFO',
+        message: 'Received SIGTERM — shutting down gracefully',
+        timestamp: new Date().toISOString(),
+    }) + '\n');
+    process.exit(0);
+});

package/dist/server/middleware.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareHandler } from 'hono';
+export declare const correlationMiddleware: MiddlewareHandler;
+export declare const iamMiddleware: MiddlewareHandler;
+export declare const loggingMiddleware: MiddlewareHandler;

package/dist/server/middleware.js

@@ -0,0 +1,106 @@
+// Generated by Phase 4 pipeline — do not edit manually
+import { createMiddleware } from 'hono/factory';
+import * as crypto from 'node:crypto';
+import * as jwt from 'jsonwebtoken';
+import jwksClient from 'jwks-rsa';
+// ---------------------------------------------------------------------------
+// Correlation ID middleware
+// ---------------------------------------------------------------------------
+export const correlationMiddleware = createMiddleware(async (c, next) => {
+    const correlationId = c.req.header('X-Correlation-ID') ?? crypto.randomUUID();
+    c.set('correlationId', correlationId);
+    c.header('X-Correlation-ID', correlationId);
+    await next();
+});
+// ---------------------------------------------------------------------------
+// IAM token validation middleware (JWKS-backed JWT verification)
+// ---------------------------------------------------------------------------
+const JWKS_URI = process.env.IAM_JWKS_URI ?? 'https://www.googleapis.com/oauth2/v3/certs';
+const IAM_AUDIENCE = process.env.IAM_AUDIENCE ?? '';
+const IAM_ISSUERS = (process.env.IAM_ISSUERS ?? 'https://accounts.google.com').split(',').map(s => s.trim());
+const jwksRsa = jwksClient({
+    jwksUri: JWKS_URI,
+    cache: true,
+    cacheMaxAge: 600_000,
+    rateLimit: true,
+    jwksRequestsPerMinute: 10,
+});
+function getSigningKey(kid) {
+    return new Promise((resolve, reject) => {
+        jwksRsa.getSigningKey(kid, (err, key) => {
+            if (err || !key)
+                return reject(err ?? new Error('No signing key found'));
+            resolve(key.getPublicKey());
+        });
+    });
+}
+export const iamMiddleware = createMiddleware(async (c, next) => {
+    const path = new URL(c.req.url).pathname;
+    if (path === '/health/healthz' || path === '/health/readyz') {
+        await next();
+        return;
+    }
+    const authHeader = c.req.header('Authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+        return c.json({ error: { code: 'UNAUTHORIZED', message: 'Missing Bearer token' } }, 401);
+    }
+    const token = authHeader.slice(7);
+    if (!token) {
+        return c.json({ error: { code: 'UNAUTHORIZED', message: 'Empty token' } }, 401);
+    }
+    try {
+        const decoded = jwt.decode(token, { complete: true });
+        if (!decoded || typeof decoded === 'string' || !decoded.header.kid) {
+            return c.json({ error: { code: 'UNAUTHORIZED', message: 'Malformed token: missing kid' } }, 401);
+        }
+        const signingKey = await getSigningKey(decoded.header.kid);
+        const verifyOptions = {
+            algorithms: ['RS256', 'RS384', 'RS512', 'ES256', 'ES384'],
+        };
+        if (IAM_ISSUERS.length > 0 && IAM_ISSUERS[0] !== '') {
+            verifyOptions.issuer = IAM_ISSUERS;
+        }
+        if (IAM_AUDIENCE) {
+            verifyOptions.audience = IAM_AUDIENCE;
+        }
+        const payload = jwt.verify(token, signingKey, verifyOptions);
+        c.set('iamClaims', payload);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Token verification failed';
+        return c.json({ error: { code: 'UNAUTHORIZED', message } }, 401);
+    }
+    await next();
+});
+// ---------------------------------------------------------------------------
+// Structured JSON request/response logging middleware
+// ---------------------------------------------------------------------------
+export const loggingMiddleware = createMiddleware(async (c, next) => {
+    const startTime = Date.now();
+    const correlationId = c.get('correlationId');
+    process.stdout.write(JSON.stringify({
+        severity: 'INFO',
+        message: 'request received',
+        httpRequest: {
+            method: c.req.method,
+            url: c.req.url,
+            userAgent: c.req.header('user-agent'),
+        },
+        correlationId,
+        timestamp: new Date().toISOString(),
+    }) + '\n');
+    await next();
+    const durationMs = Date.now() - startTime;
+    process.stdout.write(JSON.stringify({
+        severity: 'INFO',
+        message: 'request completed',
+        httpRequest: {
+            method: c.req.method,
+            url: c.req.url,
+            status: c.res.status,
+            latency: `${durationMs}ms`,
+        },
+        correlationId,
+        timestamp: new Date().toISOString(),
+    }) + '\n');
+});

package/dist/server/routes.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { InforClient } from '../erp-client/client.js';
+declare const erpClientInstance: InforClient;
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { app, erpClientInstance };