Compare commits

..
Author SHA1 Message Date
Canina Hermes dc34c57a0c ci: route exact limited timestamp release branch to Stage
Deploy Canina / deploy (push) Successful in 2m51s
2026-10-30 13:28:55 +00:00
Canina Hermes c97ea01ba9 fix(blog): project truthful publication and substantive edit timestamps 2026-10-30 13:21:07 +00:00
Canina Automation 00ba4360cf fix(search): normalize search expansion lookup for hamza-ye variants
Deploy Canina / deploy (push) Successful in 2m42s
2026-10-27 11:56:13 +00:00
Canina Automation 8669d183d5 feat(search): add bidirectional domain aliases (taurine/taurin, carnitine) and include ingredientCardSlug
Deploy Canina / deploy (push) Successful in 2m8s
2026-10-27 11:49:15 +00:00
Canina Automation 66b9d75524 feat(search-pagination): implement normalized weighted search and standardized pagination across blogs, products and wiki
Deploy Canina / deploy (push) Successful in 4m25s
2026-10-27 11:39:55 +00:00
Canina Automation d3a0a61d79 feat(storefront): increase blog list limit to 200, resolve wiki taurine alias and expand related products search
Deploy Canina / deploy (push) Successful in 2m42s
2026-10-27 10:18:37 +00:00
Canina Automation 0ad39bb92c fix(blogs): enforce atomic optimistic update concurrency
Deploy Canina / deploy (push) Successful in 52s
2026-10-27 08:20:33 +00:00
Canina Automation 0e952ef701 fix(prod-ci): add --repair-empty to revalidation provisioning on production release
Deploy Canina / deploy (push) Successful in 39s
2026-10-26 20:30:19 +00:00
Canina Automation f1382e943c ci: retry production release after runner permission verification
Deploy Canina / deploy (push) Failing after 11s
2026-10-26 20:25:38 +00:00
Canina Automation 53fccc2d3c fix(ci): route production code-only release through safe locked deployment without migrations
Deploy Canina / deploy (push) Failing after 10s
2026-10-26 20:17:27 +00:00
Canina Automation 9ae839138c [verified] Fix Stage readiness against paginated public blogs contract
Deploy Canina / deploy (push) Successful in 39s
2026-10-26 19:19:26 +00:00
Canina Automation 0fa6abc53d [verified] fix Stage helper lock under daemon userns remapping
Deploy Canina / deploy (push) Failing after 7m24s
2026-10-26 18:50:29 +00:00
Canina Automation 2a32f31097 fix(stage): fence runtime authority and bound release transports
Deploy Canina / deploy (push) Failing after 5s
2026-10-26 18:25:16 +00:00
Canina Automation 52a7aebb51 fix(ci): prepare fail-closed exact-SHA code-only Stage release 2026-10-26 16:42:08 +00:00
Canina Automation af32ec14e1 fix(seo): provide explicit noindex and self-canonical for login and cart pages 2026-10-26 16:32:52 +00:00
Canina Automation e34156b2d3 fix(seo): normalize and safely encode wiki route slug to prevent double-encoding 404s 2026-10-26 16:32:52 +00:00
Canina Automation 721118787a fix(cache): restore backend-to-next revalidation and expose revalidation status safely
Deploy Canina / deploy (push) Successful in 1m10s
2026-10-26 15:12:10 +00:00
parsa aghaei 292ed7f920 fix(deploy): make stage_test_principal migration idempotent and resolve existing migrations before deploy
Deploy Canina / deploy (push) Successful in 1m7s
2026-10-26 14:00:35 +03:30
parsa aghaei 432f6a21c7 fix(deploy): resolve revalidation env missing and resolve legacy orchestration migrations
Deploy Canina / deploy (push) Failing after 1m2s
2026-10-26 13:45:41 +03:30
parsa aghaei 2087001ecd fix(ci): restore original working deploy.yml and direct deploy.sh from eb17c8e284
Deploy Canina / deploy (push) Failing after 2m59s
2026-10-26 12:57:29 +03:30
parsa aghaei ec93af0064 fix(admin): restore clean persian dashboard and monitoring page, remove extra workflows
Deploy Canina / deploy (push) Failing after 3s
2026-10-26 11:58:20 +03:30
parsa aghaei effe30ee58 feat(admin): remove governance, orchestration, approvals, tasks, and audit logs modules
Deploy Canina / deploy (push) Successful in 4m14s
2026-10-26 10:15:06 +03:30
devops 99f0c0d626 test(ops): fence rollout fixture evidence and systemctl writes
Deploy Canina / deploy (push) Failing after 1s
2026-10-26 05:10:41 +00:00
devops 1e27387016 fix(ops): retire exact CI-generated historical release deltas safely
Deploy Canina / deploy (push) Successful in 6m12s
2026-10-26 05:02:35 +00:00
devops c733a806bd test(ops): assert restored CI render state after acceptance
Deploy Canina / deploy (push) Failing after 2s
2026-10-26 04:58:26 +00:00
devops 23cbd693a8 test(ops): isolate host retention installer from rollout fixture
Deploy Canina / deploy (push) Failing after 2s
2026-10-26 04:58:12 +00:00
devops 366bc9fc88 fix(ops): conservative post-rollout retention and deterministic disk watch
Deploy Canina / deploy (push) Has been cancelled
2026-10-26 04:57:33 +00:00
devops b4420e54b7 fix(release): admit exact reviewed publisher SEO repair paths
Deploy Canina / deploy (push) Failing after 9h30m37s
2026-10-25 18:34:09 +00:00
devops 44d74d35e6 fix(blog): publish truthful image and team SEO metadata
Deploy Canina / deploy (push) Successful in 4m50s
2026-10-25 18:03:49 +00:00
devops 5897abcbad fix(ci): wait for final TCP server before schema restore
Approved narrow auth schema reconciliation / reconcile (push) Successful in 15s
Deploy Canina / deploy (push) Failing after 21s
2026-10-25 13:27:39 +00:00
devops b3b9e617b5 fix(stage): recreate cached frontend for release provenance 2026-10-25 13:26:49 +00:00
devops 6f9529d31f fix(release): admit exact schema CI push regression test
Deploy Canina / deploy (push) Successful in 2m17s
Approved narrow auth schema reconciliation / reconcile (push) Failing after 10s
2026-10-25 13:04:53 +00:00
devops c25b10f7f3 fix(ci): trigger approved auth schema operation on exact Gitea push refs 2026-10-25 13:04:34 +00:00
devops c69a779ecc fix(release): scope missing-column guard and allow exact schema repair 2026-10-25 12:59:40 +00:00
devops 688a0e4de5 fix(auth): prepare narrow approved CI schema reconciliation 2026-10-25 12:43:20 +00:00
devops cf9b80bbb3 fix(release): gate generated Prisma client against live production catalog 2026-10-25 12:43:20 +00:00
devops 2a341d3969 fix(deploy): supply internal npm registry build arg for production compose snapshot
Deploy Canina / deploy (push) Successful in 2m37s
2026-10-25 08:44:41 +00:00
devops 9275233d09 fix(release): admit audited freshness frontend fixes in production release allowlist
Deploy Canina / deploy (push) Failing after 1m50s
2026-10-25 08:34:29 +00:00
Canina Engineering 13dceaa460 fix(blog): expose author role and bound FAQ heading extraction
Deploy Canina / deploy (push) Successful in 10m28s
2026-10-25 08:19:44 +00:00
Canina Engineering 0ab2980ff4 fix(editorial): crash-safe upgrade with durable phase, previous metadata and recovery 2026-10-25 08:19:44 +00:00
devops fd14c05f3a fix(build): enforce secure TLS registry and binary verification 2026-10-25 08:19:30 +00:00
Canina Engineering cc0358bb12 fix(editorial): upgrade only verified installed runtime payload
Deploy Canina / deploy (push) Failing after 2m51s
2026-10-25 07:39:22 +00:00
Canina Engineering f94ef580fb fix(infra): integrate private revalidation provisioning and narrow release gates
Deploy Canina / deploy (push) Failing after 1m6s
2026-10-25 07:18:30 +00:00
devops 1bb6274b35 fix(frontend): restore full admin gates and preserve analytics protocol 2026-10-25 06:59:37 +00:00
Canina Engineering 448c250944 feat(deploy): gate immutable production CI promotion on audited Stage acceptance 2026-10-25 06:52:32 +00:00
Canina Engineering 5f5c3eb3b9 fix(infra): refresh Docker upstream DNS and provision revalidation runtime 2026-10-25 06:52:05 +00:00
Canina Engineering 3805057923 fix(blog): sort articles by raw publication timestamps 2026-10-25 06:42:52 +00:00
Canina Engineering f4678c48ca test(backend): isolate worker secrets and support HTTP listener 2026-10-25 06:30:18 +00:00
Canina Engineering c40e931168 fix(cache): target Next server for fallback revalidation 2026-10-25 05:51:26 +00:00
Hermes Agent e96a13b255 fix(editorial): synchronize corrected PMO skill bundle digest
Deploy Canina / deploy (push) Failing after 1m28s
2026-10-24 17:40:26 +00:00
Recovery Review 4413c2ef6c Test completed recovery over JWT HTTP Postgres and narrowly admit Stage reviewer
Deploy Canina / deploy (push) Failing after 1m25s
2026-10-24 17:35:56 +00:00
devops 65063e224a fix(editorial): constrain synthesis contract and admit fenced completed-run recovery 2026-10-24 17:35:42 +00:00
Hermes Agent c8063b5f2a fix(ci): admit exact installed runner evidence in ownership preflight
Deploy Canina / deploy (push) Successful in 3m44s
2026-10-24 16:32:27 +00:00
devops bfeb464bfb fix(editorial): honor functional bring-up model and completion policy
Deploy Canina / deploy (push) Failing after 1m30s
2026-10-24 16:26:50 +00:00
devops 860324e3a9 fix(editorial): retain bounded timeout session evidence and budget headroom
Deploy Canina / deploy (push) Successful in 3m44s
2026-10-24 15:38:04 +00:00
devops f705511164 fix(ci): install durable Stage cleanup worker during guarded rollout
Deploy Canina / deploy (push) Successful in 4m56s
2026-10-24 13:04:35 +00:00
devops 70a5449d35 fix(auth): persist generation-fenced Stage principal cleanup retries 2026-10-24 13:04:35 +00:00
devops 80a2e188cf fix(auth): fence temporary Stage credentials by account generation 2026-10-24 13:04:35 +00:00
devops e036c5d436 feat(stage): add opt-in bounded CI editorial test principal 2026-10-24 13:04:35 +00:00
devops ed77f87ab5 fix(editorial): preflight installed CLI and categorize profile failures
Deploy Canina / deploy (push) Successful in 3m17s
2026-10-24 11:31:48 +00:00
devops 4712433903 feat(admin): add fenced expired editorial run recovery control
Deploy Canina / deploy (push) Successful in 4m46s
2026-10-24 10:58:18 +00:00
devops f4add07780 fix(editorial): migrate exact CI ownership and fence failed research runs
Deploy Canina / deploy (push) Successful in 5m1s
2026-10-24 10:28:30 +00:00
devops 01b6f1d3d7 fix(editorial): fence runner identity before claim and expose safe stages 2026-10-24 10:28:30 +00:00
devops 60a4e14b4b fix(orchestration): expose queued Gate1 expiry and audited renewal
Deploy Canina / deploy (push) Successful in 4m51s
2026-10-24 09:53:07 +00:00
devops 6e465663bd test(editorial): resolve runner imports under CI discovery
Deploy Canina / deploy (push) Successful in 3m11s
2026-10-24 09:07:05 +00:00
devops b1142bd0c0 feat(editorial): implement bounded canonical-profile research runner
Deploy Canina / deploy (push) Failing after 1m22s
2026-10-24 09:01:46 +00:00
devops 50d0df822c fix(orchestration): atomically queue approvals with optional not-before schedule
Deploy Canina / deploy (push) Successful in 4m56s
2026-10-24 06:16:20 +00:00
devops ab2f330eb8 fix(admin): open fresh card decisions in confirmation dialog
Deploy Canina / deploy (push) Successful in 4m34s
2026-10-24 05:24:39 +00:00
devops ca3d4f6a16 fix(users): preserve superadmin roles and enforce actor privilege boundary 2026-10-24 05:14:22 +00:00
devops 3321bac22d fix(admin): render users list contract and allowlist user projection
Deploy Canina / deploy (push) Successful in 4m37s
2026-10-24 04:46:26 +00:00
devops 3e78b89cc1 fix(orchestration): provision explicit Stage owner Gate1 review access
Deploy Canina / deploy (push) Successful in 4m40s
Preserve independent proposer checks, canonical Admin UUID allowlist and deny ordinary admins. Revalidate pinned owner in read-only CI preflight; expose server-advertised card decisions and distinguish reservation from unknown real cost. Verified backend 42 HTTP/service/config tests and build; admin 18 relevant tests, app tsc and Vite build; 3 CI config tests and bash syntax.
2026-10-24 04:25:35 +00:00
devops bfb1841370 Add bounded approved editorial brief ingestion pending independent QA
Deploy Canina / deploy (push) Successful in 4m32s
2026-10-24 04:08:17 +00:00
devops 6ba2c51403 Fix orchestration actor role normalization at HTTP boundary
Deploy Canina / deploy (push) Successful in 4m50s
2026-10-24 04:01:38 +00:00
devops ba0aa5ee4e Isolate PMO credential from existing differently owned credentials directory
Deploy Canina / deploy (push) Successful in 4m30s
2026-10-24 03:45:51 +00:00
devops 7485c89e9b feat(editorial): wire serialized Stage runtime install and PMO proposal client
Deploy Canina / deploy (push) Failing after 1m23s
2026-10-24 03:41:43 +00:00
devops 8869ce2583 feat(editorial): add blocked profile policy distribution and isolated installer 2026-10-24 03:32:46 +00:00
devops 64419f6755 feat(orchestration): bind PMO editorial proposals to owner Gate1 2026-10-24 03:27:00 +00:00
devops 8cedc2cd67 feat(orchestration): expose owner Gate1 queue and audited hold decisions
Deploy Canina / deploy (push) Successful in 3m9s
2026-10-24 02:28:58 +00:00
devops 65a6fe1f0c Repair Persian RTL orchestration panel and honest unavailable states
Deploy Canina / deploy (push) Successful in 2m1s
Preserve bounded command safety and snapshot provenance; render structured Persian records without translating human evidence. Validated app/node TypeScript, Vite build and 394 tests across 64 files in private Node 22 runner.
2026-10-23 20:48:52 +00:00
devops afbee9cf70 Fix nginx access to admin fonts and correct Shabnam asset path
Deploy Canina / deploy (push) Successful in 2m23s
2026-10-23 20:16:25 +00:00
devops 5984242ce4 Add authenticated fixed Tech one-shot adapter with bounded transport and admission
Deploy Canina / deploy (push) Successful in 3m10s
2026-10-23 19:36:56 +00:00
devops c523acc9e8 Add separately admitted Tech source ingestion with retained unknown cost 2026-10-23 19:36:56 +00:00
271 changed files with 9419 additions and 12151 deletions

No files matched your search

+4
View File
@@ -12,3 +12,7 @@ uploads
**/uploads
*.pdf
graphify-out
**/.revalidation.env*
**/.support*.env*
**/*runtime.env
**/release.override.json
+33 -18
View File
@@ -5,30 +5,45 @@ on:
branches:
- main
- develop
- release/blog-timestamp-limited-20261030
jobs:
deploy:
runs-on: canina
steps:
- name: Authenticated host Stage deployment (Production blocked)
shell: bash
- name: Run deploy.sh from within the scripts folder
env:
BRANCH: ${{ github.ref_name }}
DEPLOY_REF: ${{ github.ref }}
DEPLOY_SHA: ${{ github.sha }}
DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
DEPLOY_KNOWN_HOSTS: ${{ secrets.DEPLOY_KNOWN_HOSTS }}
GITHUB_ACTIONS: 'true'
run: |
set -euo pipefail
set +x
[[ "${BRANCH}" == develop ]] || { echo 'Production blocked' >&2; exit 2; }
[[ "${DEPLOY_SHA}" =~ ^[0-9a-f]{40}$ ]] || exit 2
# Provision DEPLOY_KNOWN_HOSTS from an independently verified host key.
# Never use baked-in /opt/services, runner SSH keys or docker.sock.
[[ -n "${DEPLOY_KEY}" && -n "${DEPLOY_KNOWN_HOSTS}" ]] || { echo 'Host boundary requires DEPLOY_KEY and verified DEPLOY_KNOWN_HOSTS' >&2; exit 2; }
export http_proxy="" https_proxy="" HTTP_PROXY="" HTTPS_PROXY=""
set -eu
case "${DEPLOY_REF}" in
refs/heads/main) BRANCH=main; STAGE_SOURCE_REF= ;;
refs/heads/develop|refs/heads/release/blog-timestamp-limited-20261030)
BRANCH=develop; STAGE_SOURCE_REF="$DEPLOY_REF" ;;
*) printf 'Unsupported deployment ref\n' >&2; exit 2 ;;
esac
# Bind downloads and both release dispatchers to the exact event commit.
case "$DEPLOY_SHA" in
*[!0-9a-f]*|'') exit 2 ;;
esac
[ "${#DEPLOY_SHA}" -eq 40 ] || exit 2
export BRANCH STAGE_SOURCE_REF
# 1. رفع مشکل DNS و غیرفعال کردن پروکسی برای دامنه محلی
echo "87.248.133.138 git.parsaaghayi.ir" >> /etc/hosts
export http_proxy=""
export https_proxy=""
export HTTP_PROXY=""
export HTTPS_PROXY=""
export no_proxy="git.parsaaghayi.ir,localhost,127.0.0.1,87.248.133.138"
umask 077
wrapper=$(mktemp)
trap 'rm -f "$wrapper"' EXIT
wget --no-proxy -qO "$wrapper" "https://git.parsaaghayi.ir/parsa/canina/raw/commit/${DEPLOY_SHA}/scripts/ci-host-deploy.sh"
bash "$wrapper"
# 2. دانلود و اجرای اسکریپت deploy.sh بر اساس برنچ جاری
mkdir -p scripts
wget --no-proxy -qO scripts/deploy.sh https://git.parsaaghayi.ir/parsa/canina/raw/commit/${DEPLOY_SHA}/scripts/deploy.sh
wget --no-proxy -qO scripts/release-cache-stage.sh https://git.parsaaghayi.ir/parsa/canina/raw/commit/${DEPLOY_SHA}/scripts/release-cache-stage.sh
wget --no-proxy -qO scripts/release-cache-prod.sh https://git.parsaaghayi.ir/parsa/canina/raw/commit/${DEPLOY_SHA}/scripts/release-cache-prod.sh
chmod +x scripts/deploy.sh
cd scripts
./deploy.sh "${BRANCH}"
@@ -1,24 +0,0 @@
name: Hermes runtime contract review (NO DEPLOY)
on:
workflow_dispatch:
permissions:
contents: read
jobs:
contract-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '22'
cache: npm
cache-dependency-path: backend/package-lock.json
- run: npm ci --ignore-scripts --no-audit
working-directory: backend
- run: npm test -- --runInBand hermes-management
working-directory: backend
- run: npx tsc -p src/hermes-management/tsconfig.contract.json --noEmit
working-directory: backend
- run: npx tsc -p src/hermes-management/tsconfig.contract.json
working-directory: backend
# No SSH, Docker socket, secrets, deployments, dispatch or runtime mutation.
+4
View File
@@ -16,3 +16,7 @@ playwright-report/
playwright/.auth/
blob-report/
# Python CI helpers must not dirty immutable release checkouts.
__pycache__/
*.pyc
+9 -9
View File
@@ -1,4 +1,4 @@
FROM node:20-alpine AS app-builder
FROM node:22-alpine AS app-builder
USER root
WORKDIR /app
ENV NEXT_TELEMETRY_DISABLED=1
@@ -7,18 +7,17 @@ ENV NEXT_PUBLIC_API_URL=https://api.canina.ir/api
# Optional: Use Nexus as npm registry
ARG NPM_REGISTRY=
RUN if [ -n "$NPM_REGISTRY" ]; then \
npm config set registry "$NPM_REGISTRY" && \
npm config set strict-ssl false; \
npm config set registry "$NPM_REGISTRY"; \
fi
COPY frontend/application/package*.json ./
RUN npm ci --include=dev --prefer-offline --no-audit
RUN npm ci --include=dev --prefer-offline --no-audit && test -x node_modules/.bin/next
COPY frontend/application ./
ARG NEXT_PUBLIC_API_URL
ENV NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL
RUN npm run build
FROM node:20-alpine AS admin-builder
FROM node:22-alpine AS admin-builder
USER root
WORKDIR /app
ENV VITE_API_URL=https://api.canina.ir/api
@@ -26,18 +25,17 @@ ENV VITE_API_URL=https://api.canina.ir/api
# Optional: Use Nexus as npm registry (inherits build-arg)
ARG NPM_REGISTRY=
RUN if [ -n "$NPM_REGISTRY" ]; then \
npm config set registry "$NPM_REGISTRY" && \
npm config set strict-ssl false; \
npm config set registry "$NPM_REGISTRY"; \
fi
COPY frontend/admin-panel/package*.json ./
RUN npm ci --include=dev --prefer-offline --no-audit
RUN npm ci --include=dev --prefer-offline --no-audit && test -x node_modules/.bin/vite
COPY frontend/admin-panel ./
ARG VITE_API_URL
ENV VITE_API_URL=$VITE_API_URL
RUN npm run build
FROM node:20-alpine
FROM node:22-alpine
USER root
RUN addgroup -S nginx 2>/dev/null || true && adduser -S nginx -G nginx 2>/dev/null || true
RUN mkdir -p /var/log/nginx /var/cache/nginx /run/nginx /etc/nginx/conf.d /etc/nginx/http.d
@@ -49,6 +47,8 @@ RUN chown -R nginx:nginx /var/log/nginx /var/cache/nginx /run/nginx 2>/dev/null
WORKDIR /app
COPY --from=app-builder /app .
COPY --from=admin-builder /app/dist ./admin_static
# Build-context umask must not make public assets unreadable by nginx workers.
RUN chmod -R a+rX /app/admin_static
COPY nginx.conf /etc/nginx/conf.d/default.conf
COPY nginx.conf /etc/nginx/http.d/default.conf
+3 -2
View File
@@ -12,7 +12,6 @@ ENV npm_config_cache=/tmp/npm-cache
ARG NPM_REGISTRY=
RUN if [ -n "$NPM_REGISTRY" ]; then \
npm config set registry "$NPM_REGISTRY" && \
npm config set strict-ssl false && \
echo "Using npm registry: $NPM_REGISTRY"; \
fi
@@ -32,8 +31,10 @@ RUN http_proxy=http://172.17.0.1:8888 https_proxy=http://172.17.0.1:8888 \
FROM node:20-alpine
USER root
RUN http_proxy=http://172.17.0.1:8888 https_proxy=http://172.17.0.1:8888 apk add --no-cache openssl || apk add --no-cache openssl || true
RUN mkdir -p /app/uploads && chown node:node /app/uploads
RUN mkdir -p /app/uploads /app/private-stage-test && chmod 700 /app/private-stage-test && chown node:node /app/uploads /app/private-stage-test
WORKDIR /app
ARG STAGE_TEST_ARTIFACT_SHA=disabled
RUN printf "%s" "$STAGE_TEST_ARTIFACT_SHA" > /app/STAGE_TEST_ARTIFACT_SHA
ENV PRISMA_HIDE_UPDATE_MESSAGE=true
COPY --chown=node:node --from=builder /app/package*.json ./
COPY --chown=node:node --from=builder /app/tsconfig.json ./tsconfig.json
@@ -0,0 +1,3 @@
-- Scheduling is distinct from immutable approval validity. Existing queues run immediately.
ALTER TABLE "prepare_workflow_outbox" ADD COLUMN "not_before" TIMESTAMPTZ;
CREATE INDEX "prepare_workflow_outbox_due_idx" ON "prepare_workflow_outbox" ("status", "not_before", "created_at");
@@ -0,0 +1 @@
ALTER TABLE "users" ADD COLUMN IF NOT EXISTS "auth_expires_at" TIMESTAMPTZ, ADD COLUMN IF NOT EXISTS "stage_test_session" VARCHAR(64), ADD COLUMN IF NOT EXISTS "stage_test_generation" UUID;
@@ -0,0 +1,14 @@
-- Drop legacy governance and orchestration tables
DROP TABLE IF EXISTS "prepare_workflow_outbox" CASCADE;
DROP TABLE IF EXISTS "orchestration_kill_switches" CASCADE;
DROP TABLE IF EXISTS "orchestration_budget_ledger" CASCADE;
DROP TABLE IF EXISTS "orchestration_events" CASCADE;
DROP TABLE IF EXISTS "orchestration_approval_decisions" CASCADE;
DROP TABLE IF EXISTS "orchestration_dependencies" CASCADE;
DROP TABLE IF EXISTS "orchestration_attestations" CASCADE;
DROP TABLE IF EXISTS "orchestration_artifacts" CASCADE;
DROP TABLE IF EXISTS "orchestration_runs" CASCADE;
DROP TABLE IF EXISTS "orchestration_tasks" CASCADE;
DROP TABLE IF EXISTS "department_tasks" CASCADE;
DROP TABLE IF EXISTS "audit_logs" CASCADE;
DROP TABLE IF EXISTS "approval_requests" CASCADE;
+3 -232
View File
@@ -16,6 +16,9 @@ model User {
mobile String @unique @db.VarChar(15)
password String? @db.VarChar(255)
role String @default("User_PetOwner") @db.VarChar(30)
authExpiresAt DateTime? @map("auth_expires_at") @db.Timestamptz()
stageTestGeneration String? @map("stage_test_generation") @db.Uuid
stageTestSession String? @map("stage_test_session") @db.VarChar(64)
walletBalance Decimal @default(0.00) @map("wallet_balance") @db.Decimal(15, 2)
charityDonationTotal Decimal @default(0.00) @map("charity_donation_total") @db.Decimal(15, 2)
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
@@ -1017,235 +1020,3 @@ model SmsCampaign {
@@map("sms_campaigns")
}
// ------------------------------------------------------------------------------
// 5. ApprovalRequest (CEO Governance & Decision Gate)
// ------------------------------------------------------------------------------
model ApprovalRequest {
id String @id @default(uuid()) @db.Uuid
department String @db.VarChar(50)
category String @db.VarChar(50)
title String @db.VarChar(255)
payload Json @db.JsonB
testContext Json? @map("test_context") @db.JsonB
status String @default("PENDING") @db.VarChar(30)
ceoNotes String? @map("ceo_notes") @db.Text
executedAt DateTime? @map("executed_at") @db.Timestamptz()
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
updatedAt DateTime @default(now()) @updatedAt @map("updated_at") @db.Timestamptz()
@@index([department])
@@index([category])
@@index([status])
@@index([createdAt])
@@map("approval_requests")
}
// ------------------------------------------------------------------------------
// 6. AuditLog (System & Database Changes History)
// ------------------------------------------------------------------------------
model AuditLog {
id String @id @default(uuid()) @db.Uuid
entity String @db.VarChar(50) // e.g. product, blog, order, approval, settings
entityId String? @map("entity_id") @db.VarChar(100)
action String @db.VarChar(50) // CREATE, UPDATE, DELETE, EXECUTE, APPROVE, REJECT
department String? @db.VarChar(50) // devops, seo, content, vet, commerce, pmo
actor String @default("SYSTEM") @db.VarChar(100)
summary String @db.VarChar(255)
oldValues Json? @map("old_values") @db.JsonB
newValues Json? @map("new_values") @db.JsonB
metadata Json? @db.JsonB
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
@@index([entity])
@@index([action])
@@index([department])
@@index([createdAt])
@@map("audit_logs")
}
// ------------------------------------------------------------------------------
// 7. DepartmentTask (Autonomous Corporate Task & Kanban Manager)
// ------------------------------------------------------------------------------
model DepartmentTask {
id String @id @default(uuid()) @db.Uuid
code String @unique @db.VarChar(50)
department String @db.VarChar(50) // devops, seo, content, vet, commerce, pmo
title String @db.VarChar(255)
description String? @db.Text
status String @default("BACKLOG") @db.VarChar(30) // BACKLOG, IN_PROGRESS, IN_REVIEW, APPROVED, DEPLOYING, DONE
priority String @default("MEDIUM") @db.VarChar(20) // LOW, MEDIUM, HIGH, CRITICAL
assignee String? @db.VarChar(100)
acceptanceCriteria Json? @map("acceptance_criteria") @db.JsonB
executionLogs Json? @map("execution_logs") @db.JsonB
deliverableUrl String? @map("deliverable_url") @db.VarChar(255)
approvalId String? @map("approval_id") @db.Uuid
startedAt DateTime? @map("started_at") @db.Timestamptz()
completedAt DateTime? @map("completed_at") @db.Timestamptz()
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
updatedAt DateTime @default(now()) @updatedAt @map("updated_at") @db.Timestamptz()
@@index([department])
@@index([status])
@@index([priority])
@@index([createdAt])
@@map("department_tasks")
}
// Orchestration v4 additive models. Legacy governance tables remain untouched.
model OrchestrationTask {
id String @id @default(uuid()) @db.Uuid
key String @unique @db.VarChar(120)
title String @db.VarChar(255)
department String @db.VarChar(50)
state String @default("DRAFT") @db.VarChar(40)
operationMode String @map("operation_mode") @db.VarChar(30)
modelTier String? @map("model_tier") @db.VarChar(2)
budgetLimitCents Int @map("budget_limit_cents")
version Int @default(1)
metadata Json @default("{}") @db.JsonB
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz()
runs OrchestrationRun[]
dependencies OrchestrationDependency[] @relation("task_dependencies")
dependedOnBy OrchestrationDependency[] @relation("task_dependents")
decisions OrchestrationApprovalDecision[]
events OrchestrationEvent[]
budgetLedger OrchestrationBudgetLedger[]
@@index([state, createdAt])
@@index([department, state])
@@map("orchestration_tasks")
}
model OrchestrationRun {
id String @id @default(uuid()) @db.Uuid
taskId String @map("task_id") @db.Uuid
attempt Int @default(1)
status String @default("PENDING") @db.VarChar(30)
commitSha String @map("commit_sha") @db.VarChar(64)
environment String @db.VarChar(50)
retryClass String? @map("retry_class") @db.VarChar(30)
idempotencyKey String @unique @map("idempotency_key") @db.VarChar(150)
startedAt DateTime? @map("started_at") @db.Timestamptz()
finishedAt DateTime? @map("finished_at") @db.Timestamptz()
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
task OrchestrationTask @relation(fields:[taskId],references:[id],onDelete:Restrict)
artifacts OrchestrationArtifact[]
attestations OrchestrationAttestation[]
approvals OrchestrationApprovalDecision[]
@@unique([taskId, attempt])
@@index([taskId, status])
@@map("orchestration_runs")
}
model OrchestrationArtifact {
id String @id @default(uuid()) @db.Uuid
runId String @map("run_id") @db.Uuid
kind String @db.VarChar(50)
uri String @db.Text
sha256 String @db.Char(64)
sizeBytes BigInt? @map("size_bytes")
metadata Json @default("{}") @db.JsonB
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
run OrchestrationRun @relation(fields:[runId],references:[id],onDelete:Restrict)
@@unique([runId, sha256])
@@map("orchestration_artifacts")
}
model OrchestrationAttestation {
id String @id @default(uuid()) @db.Uuid
runId String @map("run_id") @db.Uuid
kind String @db.VarChar(50)
subjectHash String @map("subject_hash") @db.Char(64)
predicate Json @db.JsonB
signer String @db.VarChar(150)
signature String? @db.Text
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
run OrchestrationRun @relation(fields:[runId],references:[id],onDelete:Restrict)
@@unique([runId, kind, subjectHash, signer])
@@map("orchestration_attestations")
}
model OrchestrationDependency {
id String @id @default(uuid()) @db.Uuid
taskId String @map("task_id") @db.Uuid
dependsOnTaskId String @map("depends_on_task_id") @db.Uuid
kind String @default("BLOCKS") @db.VarChar(30)
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
task OrchestrationTask @relation("task_dependencies",fields:[taskId],references:[id],onDelete:Restrict)
dependsOnTask OrchestrationTask @relation("task_dependents",fields:[dependsOnTaskId],references:[id],onDelete:Restrict)
@@unique([taskId, dependsOnTaskId])
@@map("orchestration_dependencies")
}
model OrchestrationApprovalDecision {
id String @id @default(uuid()) @db.Uuid
taskId String @map("task_id") @db.Uuid
gate Int
decision String @db.VarChar(20)
actorId String @map("actor_id") @db.VarChar(100)
notes String? @db.Text
expiresAt DateTime @map("expires_at") @db.Timestamptz()
idempotencyKey String @unique @map("idempotency_key") @db.VarChar(150)
runId String? @map("run_id") @db.Uuid
artifactHash String? @map("artifact_hash") @db.Char(64)
commitSha String? @map("commit_sha") @db.VarChar(64)
environment String? @db.VarChar(50)
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
task OrchestrationTask @relation(fields:[taskId],references:[id],onDelete:Restrict)
run OrchestrationRun? @relation(fields:[runId],references:[id],onDelete:Restrict)
@@index([taskId, gate, createdAt])
@@map("orchestration_approval_decisions")
}
model OrchestrationEvent {
id String @id @default(uuid()) @db.Uuid
taskId String? @map("task_id") @db.Uuid
eventType String @map("event_type") @db.VarChar(60)
fromState String? @map("from_state") @db.VarChar(40)
toState String? @map("to_state") @db.VarChar(40)
sequence Int
actorId String @map("actor_id") @db.VarChar(100)
idempotencyKey String? @unique @map("idempotency_key") @db.VarChar(150)
payload Json @default("{}") @db.JsonB
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
task OrchestrationTask? @relation(fields:[taskId],references:[id],onDelete:Restrict)
@@unique([taskId, sequence])
@@index([eventType, createdAt])
@@map("orchestration_events")
}
model OrchestrationBudgetLedger {
id String @id @default(uuid()) @db.Uuid
taskId String @map("task_id") @db.Uuid
amountCents Int @map("amount_cents")
kind String @db.VarChar(40)
idempotencyKey String @unique @map("idempotency_key") @db.VarChar(150)
actorId String @map("actor_id") @db.VarChar(100)
metadata Json @default("{}") @db.JsonB
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
task OrchestrationTask @relation(fields:[taskId],references:[id],onDelete:Restrict)
@@index([taskId, createdAt])
@@map("orchestration_budget_ledger")
}
model OrchestrationKillSwitch {
scope String @id @db.VarChar(80)
level String @db.VarChar(30)
active Boolean @default(true)
reason String @db.Text
actorId String @map("actor_id") @db.VarChar(100)
version Int @default(1)
updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz()
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
@@map("orchestration_kill_switches")
}
// Transactional dispatch intent. Lease tokens are server-only fencing credentials.
model PrepareWorkflowOutbox {
id String @id @default(uuid()) @db.Uuid
taskId String @unique @map("task_id") @db.Uuid
status String @default("PENDING") @db.VarChar(20)
attempts Int @default(0)
leaseOwner String? @map("lease_owner") @db.VarChar(100)
leaseToken String? @map("lease_token") @db.Uuid
leaseUntil DateTime? @map("lease_until") @db.Timestamptz()
heartbeatAt DateTime? @map("heartbeat_at") @db.Timestamptz()
runId String? @map("run_id") @db.Uuid
reservationId String? @map("reservation_id") @db.Uuid
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz()
@@index([status, leaseUntil])
@@map("prepare_workflow_outbox")
}
@@ -0,0 +1,73 @@
import { ForbiddenException } from "@nestjs/common";
import { AdminService } from "./admin.service";
import { AdminController } from "./admin.controller";
// All identities and credentials here are disposable test fixtures.
describe("admin user privilege boundary", () => {
let service: any;
let prisma: any;
const owner = { id: "owner-fixture", role: "SUPER_ADMIN" };
const admin = { id: "admin-fixture", role: "ADMIN" };
beforeEach(() => {
prisma = {
user: {
findUnique: jest.fn().mockResolvedValue({ id: "target-fixture", role: "SUPER_ADMIN" }),
update: jest.fn().mockImplementation(async ({ data }) => ({ role: "SUPER_ADMIN", ...data })),
create: jest.fn(),
},
walletTransaction: { create: jest.fn() },
$transaction: jest.fn(),
};
service = new AdminService(prisma, {} as never, {} as never);
});
it("allows an authenticated superadmin password-only edit without changing the exact role", async () => {
const result = await service.updateUser("target-fixture", { password: "Fixture-only-123" }, owner);
expect(result.role).toBe("SUPER_ADMIN");
expect(prisma.user.update.mock.calls[0][0].data).not.toHaveProperty("role");
});
it.each(["ADMIN", "Admin", "User_PetOwner"])("denies %s assigning superadmin on create", async role => {
prisma.user.findUnique.mockResolvedValue(null);
await expect(service.createUser({ firstName: "Test", lastName: "Fixture", mobile: "09120000001", role: "SUPER_ADMIN" }, { id: "actor", role })).rejects.toBeInstanceOf(ForbiddenException);
expect(prisma.user.create).not.toHaveBeenCalled();
});
it.each(["SUPER_ADMIN", "super-admin", "AdminSuper"])("denies ordinary admin escalation to %s", async role => {
prisma.user.findUnique.mockResolvedValue({ id: admin.id, role: "Admin" });
await expect(service.updateUser(admin.id, { role }, admin)).rejects.toBeInstanceOf(ForbiddenException);
expect(prisma.user.update).not.toHaveBeenCalled();
});
it.each([{ password: "Fixture-only-123" }, { email: "fixture@example.test" }, { mobile: "09120000001" }, { role: "Admin" }, { walletBalance: 1 }, { firstName: "Changed" }])("denies ordinary admin editing superadmin", async dto => {
await expect(service.updateUser("target-fixture", dto, admin)).rejects.toBeInstanceOf(ForbiddenException);
expect(prisma.user.update).not.toHaveBeenCalled();
});
it("denies alternate role endpoint revocation", async () => {
await expect(service.updateUserRole("target-fixture", "Admin", admin)).rejects.toBeInstanceOf(ForbiddenException);
expect(prisma.user.update).not.toHaveBeenCalled();
});
it("denies deleting superadmin", async () => {
await expect(service.deleteUser("target-fixture", admin)).rejects.toBeInstanceOf(ForbiddenException);
expect(prisma.$transaction).not.toHaveBeenCalled();
});
it("denies changing superadmin wallet", async () => {
await expect(service.adjustUserWallet("target-fixture", 1, "deposit", "fixture", admin)).rejects.toBeInstanceOf(ForbiddenException);
expect(prisma.walletTransaction.create).not.toHaveBeenCalled();
});
it("accepts ADMIN alias for ordinary CRUD and authorized promotion/revocation", async () => {
prisma.user.findUnique.mockResolvedValue({ id: "target-fixture", role: "User_PetOwner" });
await service.updateUser("target-fixture", { role: "ADMIN" }, admin);
await service.updateUser("target-fixture", { role: "SUPER_ADMIN" }, owner);
prisma.user.findUnique.mockResolvedValue({ id: "target-fixture", role: "SUPER_ADMIN" });
await service.updateUserRole("target-fixture", "Admin", owner);
expect(prisma.user.update).toHaveBeenCalledTimes(3);
});
it("fails closed without authenticated actor or with API key superadmin", async () => {
await expect(service.updateUser("target-fixture", { role: "Admin" })).rejects.toBeInstanceOf(ForbiddenException);
await expect(service.updateUser("target-fixture", { role: "Admin" }, { ...owner, isApiKey: true })).rejects.toBeInstanceOf(ForbiddenException);
});
it("controller forwards authenticated request identity, not DTO identity", async () => {
const svc = { updateUser: jest.fn().mockResolvedValue({}) };
const controller: any = new AdminController(svc as never, {} as never);
const dto = { firstName: "Test" };
await controller.updateUser("target-fixture", dto, { user: admin });
expect(svc.updateUser).toHaveBeenCalledWith("target-fixture", dto, admin);
});
});
@@ -0,0 +1,72 @@
import { Test } from "@nestjs/testing";
import { ExecutionContext } from "@nestjs/common";
import { firstValueFrom, of } from "rxjs";
import { AdminService } from "./admin.service";
import { AdminController } from "./admin.controller";
import { PrismaService } from "../prisma/prisma.service";
import { RedisService } from "../redis/redis.service";
import { RevalidationService } from "../common/revalidation/revalidation.service";
import { DecimalInterceptor } from "../common/interceptors/decimal.interceptor";
import { Prisma } from "@prisma/client";
describe("admin users list contract", () => {
const prisma = { user: { findMany: jest.fn(), count: jest.fn() } };
let service: AdminService;
beforeEach(async () => {
jest.clearAllMocks();
const module = await Test.createTestingModule({
providers: [
AdminService,
{ provide: PrismaService, useValue: prisma },
{ provide: RedisService, useValue: {} },
{ provide: RevalidationService, useValue: {} },
],
}).compile();
service = module.get(AdminService);
});
it("returns only allowlisted list fields with aggregates through the controller and decimal interceptor", async () => {
// Deliberately return extra fields even if the query selects safely.
prisma.user.findMany.mockResolvedValue([{
id: "fixture-user", firstName: "Fixture", lastName: "User",
mobile: "fixture-mobile", email: null, role: "ADMIN",
walletBalance: new Prisma.Decimal(0), charityDonationTotal: new Prisma.Decimal(12),
createdAt: new Date("2026-01-01T00:00:00Z"),
password: "test-only-password-hash", passwordHash: "test-only-hash",
refreshToken: "test-only-token", futureSecret: "must-not-leak",
walletTransactions: [{ transactionReference: "private-reference" }],
addresses: [], orders: [{ totalAmount: new Prisma.Decimal(100) }, { totalAmount: 25 }],
_count: { orders: 3, reviews: 2, blogComments: 1, pets: 4 },
}]);
prisma.user.count.mockResolvedValue(11);
const controller = new AdminController(service, {} as never);
const result = await controller.getUsers({ page: 2, limit: 10 });
const body = await firstValueFrom(new DecimalInterceptor().intercept({} as ExecutionContext, { handle: () => of(result) }));
expect(body).toEqual({
data: [{
id: "fixture-user", firstName: "Fixture", lastName: "User", mobile: "fixture-mobile",
email: null, role: "ADMIN", walletBalance: "0", charityDonationTotal: "12",
createdAt: new Date("2026-01-01T00:00:00Z"), addresses: [],
totalSpent: 125, ordersCount: 3, reviewsCount: 3, petsCount: 4,
}],
meta: { total: 11, page: 2, limit: 10, lastPage: 2 },
});
const query = prisma.user.findMany.mock.calls[0][0];
expect(query.select).toBeDefined();
expect(query.select.password).toBeUndefined();
expect(query.include).toBeUndefined();
expect(query.skip).toBe(10);
});
it("preserves the empty paginated list contract and filters", async () => {
prisma.user.findMany.mockResolvedValue([]);
prisma.user.count.mockResolvedValue(0);
expect(await service.getUsers({ search: "fixture", role: "ADMIN" })).toEqual({
data: [], meta: { total: 0, page: 1, limit: 10, lastPage: 1 },
});
expect(prisma.user.findMany).toHaveBeenCalledWith(expect.objectContaining({
where: expect.objectContaining({ role: "ADMIN", OR: expect.any(Array) }),
}));
});
});
+12 -8
View File
@@ -7,6 +7,7 @@ import {
Body,
Param,
Query,
Req,
UseGuards,
BadRequestException,
} from "@nestjs/common";
@@ -27,6 +28,7 @@ import {
} from "@nestjs/swagger";
import { CreateUserDto, UpdateUserDto } from "./dto/user.dto";
import type { UserAdminActor } from "./user-role-policy";
import { SettingsService } from "../settings/settings.service";
import { RolesGuard } from "../common/guards/roles.guard";
@@ -62,8 +64,8 @@ export class AdminController {
@Post("users")
@ApiOperation({ summary: "ایجاد کاربر جدید توسط ادمین" })
async createUser(@Body() dto: CreateUserDto) {
const user = await this.adminService.createUser(dto);
async createUser(@Body() dto: CreateUserDto, @Req() req?: { user?: UserAdminActor }) {
const user = await this.adminService.createUser(dto, req?.user);
return {
success: true,
message: "کاربر جدید با موفقیت ایجاد شد",
@@ -80,8 +82,8 @@ export class AdminController {
@Put("users/:id")
@ApiOperation({ summary: "ویرایش مشخصات کامل کاربر" })
async updateUser(@Param("id") id: string, @Body() dto: UpdateUserDto) {
const user = await this.adminService.updateUser(id, dto);
async updateUser(@Param("id") id: string, @Body() dto: UpdateUserDto, @Req() req?: { user?: UserAdminActor }) {
const user = await this.adminService.updateUser(id, dto, req?.user);
return {
success: true,
message: "اطلاعات کاربر با موفقیت ویرایش شد",
@@ -91,8 +93,8 @@ export class AdminController {
@Delete("users/:id")
@ApiOperation({ summary: "حذف کاربر و داده‌های مرتبط" })
async deleteUser(@Param("id") id: string) {
await this.adminService.deleteUser(id);
async deleteUser(@Param("id") id: string, @Req() req?: { user?: UserAdminActor }) {
await this.adminService.deleteUser(id, req?.user);
return {
success: true,
message: "کاربر با موفقیت از سیستم حذف شد",
@@ -101,8 +103,8 @@ export class AdminController {
@Put("users/:id/role")
@ApiOperation({ summary: "تغییر نقش کاربر" })
async updateUserRole(@Param("id") id: string, @Body("role") role: string) {
const user = await this.adminService.updateUserRole(id, role);
async updateUserRole(@Param("id") id: string, @Body("role") role: string, @Req() req?: { user?: UserAdminActor }) {
const user = await this.adminService.updateUserRole(id, role, req?.user);
return { success: true, data: user };
}
@@ -113,6 +115,7 @@ export class AdminController {
@Body("amount") amount: number,
@Body("type") type: "deposit" | "withdrawal" | "refund",
@Body("description") description?: string,
@Req() req?: { user?: UserAdminActor },
) {
const numAmount = Number(amount);
if (!numAmount || isNaN(numAmount) || numAmount <= 0) {
@@ -130,6 +133,7 @@ export class AdminController {
numAmount,
type,
description,
req?.user,
);
return {
success: true,
-6
View File
@@ -21,9 +21,6 @@ import { CompetitorPricingController } from "./competitor-pricing.controller";
import { B2BLeadsController } from "./b2b-leads.controller";
import { PricingSuggestionsController } from "./pricing-suggestions.controller";
import { SmsCampaignsController } from "./sms-campaigns.controller";
import { ApprovalsController } from "./approvals.controller";
import { AuditLogsController } from "./audit-logs.controller";
import { DepartmentTasksController } from "./department-tasks.controller";
import { PrismaModule } from "../prisma/prisma.module";
import { RedisModule } from "../redis/redis.module";
import { SettingsModule } from "../settings/settings.module";
@@ -46,9 +43,6 @@ import { SupportChatAnalyticsService } from "./support-chat-analytics.service";
B2BLeadsController,
PricingSuggestionsController,
SmsCampaignsController,
ApprovalsController,
AuditLogsController,
DepartmentTasksController,
SupportChatAnalyticsController,
],
providers: [
+75 -27
View File
@@ -61,15 +61,10 @@ export class CouponInput {
targets?: CouponTargetInput[];
}
const ALLOWED_USER_ROLES = [
"User_PetOwner",
"User_Vet",
"User_Clinic",
"User_PetShop",
"Customer",
"Admin",
"SUPER_ADMIN",
];
import { ALLOWED_USER_ROLES, assertUserMutationAllowed } from "./user-role-policy";
import type { UserAdminActor } from "./user-role-policy";
import { randomUUID } from "crypto";
import { authorizeStageSession, STAGE_TEST_ID, STAGE_TEST_EMAIL, STAGE_TEST_MOBILE } from "../auth/stage-test-principal";
@Injectable()
export class AdminService {
@@ -168,12 +163,17 @@ export class AdminService {
skip,
take: limit,
orderBy: { [sortField]: sortDirection },
include: {
select: {
id: true,
firstName: true,
lastName: true,
mobile: true,
email: true,
role: true,
walletBalance: true,
charityDonationTotal: true,
createdAt: true,
addresses: true,
walletTransactions: {
orderBy: { createdAt: "desc" },
take: 20,
},
orders: {
where: { status: { not: "CANCELLED" } },
select: { totalAmount: true },
@@ -197,9 +197,19 @@ export class AdminService {
(acc, curr) => acc + (Number(curr.totalAmount) || 0),
0,
) || 0;
const { orders: _orders, ...rest } = u;
// Explicit response allowlist: never expose authentication fields or
// new model columns implicitly through this administrative list.
return {
...rest,
id: u.id,
firstName: u.firstName,
lastName: u.lastName,
mobile: u.mobile,
email: u.email,
role: u.role,
walletBalance: u.walletBalance,
charityDonationTotal: u.charityDonationTotal,
createdAt: u.createdAt,
addresses: u.addresses,
totalSpent,
ordersCount: u._count?.orders || 0,
reviewsCount: (u._count?.reviews || 0) + (u._count?.blogComments || 0),
@@ -227,7 +237,12 @@ export class AdminService {
return user;
}
async createUser(dto: CreateUserDto) {
async createUser(dto: CreateUserDto, actor?: UserAdminActor) {
assertUserMutationAllowed(actor, undefined, dto.role);
return this.persistUser(dto);
}
private async persistUser(dto: CreateUserDto, stage?: { session: string; expiresAt: Date; generation?: string }) {
const mobile = normalizeMobile(dto.mobile);
const existingMobile = await this.prisma.user.findUnique({
where: { mobile },
@@ -260,6 +275,7 @@ export class AdminService {
return this.prisma.user.create({
data: {
...(stage ? { id: STAGE_TEST_ID, stageTestGeneration:stage.generation || randomUUID(), stageTestSession: stage.session, authExpiresAt: stage.expiresAt } : {}),
firstName: dto.firstName.trim(),
lastName: dto.lastName.trim(),
mobile,
@@ -274,7 +290,30 @@ export class AdminService {
});
}
async updateUser(id: string, dto: UpdateUserDto) {
// Explicit CI seed authority, NOT a fabricated SUPER_ADMIN actor. Not controller-exposed.
async provisionStageTestPrincipal(env: NodeJS.ProcessEnv, sha: string, password: string) {
const grant = authorizeStageSession(env, sha);
const existing = await this.prisma.user.findFirst({where:{OR:[{id:STAGE_TEST_ID},{email:STAGE_TEST_EMAIL},{mobile:STAGE_TEST_MOBILE}]}});
if (existing) {
if (existing.id !== STAGE_TEST_ID || existing.email !== STAGE_TEST_EMAIL || existing.mobile !== STAGE_TEST_MOBILE || existing.stageTestSession !== grant.session || (env.STAGE_TEST_GENERATION && existing.stageTestGeneration !== env.STAGE_TEST_GENERATION) || existing.role !== 'SUPER_ADMIN' || !existing.authExpiresAt || existing.authExpiresAt.getTime() <= Date.now() || !await bcrypt.compare(password, existing.password || '')) throw new Error('Refusing existing or unowned principal');
return existing; // Never renew TTL on retry.
}
if (password.length < 32) throw new Error('Server generated secret required');
return this.persistUser({firstName:'Stage',lastName:'CI independent reviewer',email:STAGE_TEST_EMAIL,mobile:STAGE_TEST_MOBILE,role:'SUPER_ADMIN',password}, {session:grant.session,expiresAt:new Date(Date.now()+grant.ttl*1000),generation:env.STAGE_TEST_GENERATION});
}
async cleanupStageTestPrincipal(env: NodeJS.ProcessEnv, sha: string, onRevoked: () => void = () => undefined) {
const grant = authorizeStageSession(env, sha);
const existing = await this.prisma.user.findUnique({where:{id:STAGE_TEST_ID}});
if (!existing) { onRevoked(); return; }
if (existing.email !== STAGE_TEST_EMAIL || existing.mobile !== STAGE_TEST_MOBILE || existing.stageTestSession !== grant.session || !existing.authExpiresAt || (env.STAGE_TEST_GENERATION && existing.stageTestGeneration !== env.STAGE_TEST_GENERATION)) throw new Error('Refusing unowned principal cleanup');
// Revoke before relational cleanup; failed cleanup cannot leave valid tokens.
await this.prisma.user.update({where:{id:STAGE_TEST_ID,stageTestSession:grant.session,stageTestGeneration:existing.stageTestGeneration},data:{authExpiresAt:new Date(0),password:''}});
onRevoked();
return this.deleteUserRecords(STAGE_TEST_ID, {session:grant.session,generation:existing.stageTestGeneration});
}
async updateUser(id: string, dto: UpdateUserDto, actor?: UserAdminActor) {
if (id === "12345678-1234-1234-1234-123456789012") {
throw new BadRequestException(
"امکان ویرایش حساب ادمین پیش‌فرض وجود ندارد",
@@ -286,6 +325,8 @@ export class AdminService {
throw new NotFoundException(`کاربری با شناسه ${id} یافت نشد`);
}
assertUserMutationAllowed(actor, user.role, dto.role);
const normalizedMobile = dto.mobile
? normalizeMobile(dto.mobile)
: undefined;
@@ -340,17 +381,11 @@ export class AdminService {
});
}
async updateUserRole(id: string, role: string) {
if (!ALLOWED_USER_ROLES.includes(role)) {
throw new BadRequestException("نقش کاربری مشخص شده نامعتبر است");
}
return this.prisma.user.update({
where: { id },
data: { role },
});
async updateUserRole(id: string, role: string, actor?: UserAdminActor) {
return this.updateUser(id, { role }, actor);
}
async deleteUser(id: string) {
async deleteUser(id: string, actor?: UserAdminActor) {
if (id === "12345678-1234-1234-1234-123456789012") {
throw new BadRequestException("امکان حذف حساب ادمین پیش‌فرض وجود ندارد");
}
@@ -360,7 +395,17 @@ export class AdminService {
throw new NotFoundException(`کاربری با شناسه ${id} یافت نشد`);
}
assertUserMutationAllowed(actor, user.role);
return this.deleteUserRecords(id);
}
private async deleteUserRecords(id: string, stage?: {session:string; generation:string|null}) {
return this.prisma.$transaction(async (tx) => {
if (stage) {
// Acquire the row lock with an exact fence before deleting any related rows.
await tx.user.update({where:{id,stageTestSession:stage.session,stageTestGeneration:stage.generation},data:{authExpiresAt:new Date(0),password:''}});
}
await tx.userAddress.deleteMany({ where: { userId: id } });
await tx.walletTransaction.deleteMany({ where: { userId: id } });
await tx.pet.deleteMany({ where: { userId: id } });
@@ -1397,12 +1442,15 @@ export class AdminService {
amount: number,
type: "deposit" | "withdrawal" | "refund",
description?: string,
actor?: UserAdminActor,
) {
const user = await this.prisma.user.findUnique({ where: { id: userId } });
if (!user) {
throw new NotFoundException(`کاربری با شناسه ${userId} یافت نشد.`);
}
assertUserMutationAllowed(actor, user.role);
const transaction = await this.prisma.walletTransaction.create({
data: {
userId,
@@ -1,25 +0,0 @@
import { GoneException } from '@nestjs/common';
import { ApprovalsController } from './approvals.controller';
import { PrismaService } from '../prisma/prisma.service';
describe('ApprovalsController retired mutation boundary',()=>{
const access=jest.fn();
const prisma=new Proxy({},{get:(_target,key)=>{access(key);throw new Error('Database access forbidden');}});
const controller=new ApprovalsController(prisma as PrismaService);
beforeEach(()=>access.mockClear());
it('create {department:SEO,category:SEO,title:Legacy,payload:{}} returns 410 without reading or writing persistence',async()=>{
await expect(controller.create({department:'SEO',category:'SEO',title:'Legacy',payload:{}})).rejects.toBeInstanceOf(GoneException);
await expect(controller.create({department:'SEO',category:'SEO',title:'Legacy',payload:{}})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
it('decide missing, {decision:APPROVED} returns 410 without reading or writing persistence',async()=>{
await expect(controller.decide('missing', {decision:'APPROVED'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.decide('missing', {decision:'APPROVED'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
it('decide missing, {decision:REJECTED} returns 410 without reading or writing persistence',async()=>{
await expect(controller.decide('missing', {decision:'REJECTED'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.decide('missing', {decision:'REJECTED'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
});
-134
View File
@@ -1,134 +0,0 @@
import {
Controller,
Get,
Post,
Put,
Body,
Param,
Query,
UseGuards,
NotFoundException,
GoneException,
} from "@nestjs/common";
import { ApiTags, ApiBearerAuth, ApiOperation } from "@nestjs/swagger";
import { JwtAuthGuard } from "../auth/jwt-auth.guard";
import { RolesGuard } from "../common/guards/roles.guard";
import { Roles } from "../common/decorators/roles.decorator";
import { PrismaService } from "../prisma/prisma.service";
import {
CreateApprovalRequestDto,
DecideApprovalDto,
QueryApprovalDto,
} from "./dto/approval-request.dto";
@ApiTags("Admin - CEO Approvals & Governance")
@ApiBearerAuth()
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles("Admin", "SUPER_ADMIN")
@Controller("admin/approvals")
export class ApprovalsController {
constructor(private readonly prisma: PrismaService) {}
@Get()
@ApiOperation({ summary: "لیست موارد کارتابل تاییدات مدیریت" })
async findAll(@Query() query: QueryApprovalDto) {
const page = Number(query.page) || 1;
const limit = Number(query.limit) || 100;
const skip = (page - 1) * limit;
const where: any = {};
if (query.department) where.department = query.department;
if (query.category) where.category = query.category;
if (query.status) where.status = query.status;
const [total, items, pendingCount] = await Promise.all([
(this.prisma as any).approvalRequest.count({ where }),
(this.prisma as any).approvalRequest.findMany({
where,
skip,
take: limit,
orderBy: { createdAt: "desc" },
}),
(this.prisma as any).approvalRequest.count({
where: { status: "PENDING" },
}),
]);
return {
success: true,
data: items,
meta: {
total,
page,
limit,
totalPages: Math.ceil(total / limit),
pendingCount,
},
};
}
@Get(":id")
@ApiOperation({ summary: "دریافت جزییات یک آیتم کارتابل" })
async findOne(@Param("id") id: string) {
const item = await (this.prisma as any).approvalRequest.findUnique({
where: { id },
});
if (!item) {
throw new NotFoundException(`Approval request ${id} not found`);
}
return { success: true, data: item };
}
@Post()
@ApiOperation({ summary: "ثبت آیتم جدید جهت تایید مدیریت (از طرف سیستم یا دپارتمان‌ها)" })
async create(@Body() dto: CreateApprovalRequestDto) {
throw new GoneException("Legacy orchestration mutations are retired. Orchestration v4 remains read-only; no replacement mutation is enabled.");
}
@Post(":id/test")
@ApiOperation({ summary: "اجرای شبیه‌سازی تست زنده برای آیتم کارتابل" })
async runTestSimulation(@Param("id") id: string) {
const item = await (this.prisma as any).approvalRequest.findUnique({
where: { id },
});
if (!item) {
throw new NotFoundException(`Approval request ${id} not found`);
}
let testResult: any = { status: "SIMULATION_SUCCESS" };
if (item.category === "PRICING") {
const payload = item.payload as any;
testResult = {
impact: "Price change simulation",
currentPrice: payload.currentPrice,
newPrice: payload.newPrice,
marginDiff: payload.newPrice && payload.buyPrice
? (((payload.newPrice - payload.buyPrice) / payload.newPrice) * 100).toFixed(1) + "%"
: "N/A",
torobFeedReflectEstimate: "< 5 seconds",
};
} else if (item.category === "PURCHASE_ORDER") {
const payload = item.payload as any;
testResult = {
document: "PO Pre-check",
itemsCount: payload.items ? payload.items.length : 1,
totalEstimatedCost: payload.totalCost || "محاسبه بر اساس نرخ خرید",
fulfillmentCapacity: "انبار آماده پذیرش",
};
} else {
testResult = {
executionSafe: true,
summary: "تست سلامت اولیه و اعتبارسنجی مقادیر با موفقیت انجام شد.",
};
}
return { success: true, testResult };
}
@Put(":id/decide")
@ApiOperation({ summary: "تصمیم‌گیری مدیرعامل (تایید یا رد همراه با یادداشت)" })
async decide(@Param("id") id: string, @Body() dto: DecideApprovalDto) {
throw new GoneException("Legacy orchestration mutations are retired. Orchestration v4 remains read-only; no replacement mutation is enabled.");
}
}
@@ -1,94 +0,0 @@
import {
Controller,
Get,
Post,
Body,
Query,
UseGuards,
Param,
} from "@nestjs/common";
import { ApiTags, ApiBearerAuth, ApiOperation } from "@nestjs/swagger";
import { JwtAuthGuard } from "../auth/jwt-auth.guard";
import { RolesGuard } from "../common/guards/roles.guard";
import { Roles } from "../common/decorators/roles.decorator";
import { PrismaService } from "../prisma/prisma.service";
@ApiTags("Admin - System Audit & History")
@ApiBearerAuth()
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles("Admin", "SUPER_ADMIN")
@Controller("admin/audit-logs")
export class AuditLogsController {
constructor(private readonly prisma: PrismaService) {}
@Get()
@ApiOperation({ summary: "لیست لاگ‌های تغییرات دیتابیس و سیستم" })
async findAll(@Query() query: any) {
const page = Number(query.page) || 1;
const limit = Number(query.limit) || 30;
const skip = (page - 1) * limit;
const where: any = {};
if (query.entity) where.entity = query.entity;
if (query.action) where.action = query.action;
if (query.department) where.department = query.department;
if (query.search) {
where.OR = [
{ summary: { contains: query.search, mode: "insensitive" } },
{ actor: { contains: query.search, mode: "insensitive" } },
{ entityId: { contains: query.search, mode: "insensitive" } },
];
}
const [total, items] = await Promise.all([
(this.prisma as any).auditLog.count({ where }),
(this.prisma as any).auditLog.findMany({
where,
skip,
take: limit,
orderBy: { createdAt: "desc" },
}),
]);
return {
success: true,
data: items,
meta: {
total,
page,
limit,
totalPages: Math.ceil(total / limit),
},
};
}
@Get("recent")
@ApiOperation({ summary: "آخرین رخدادهای سیستم برای ویجت داشبورد" })
async getRecent(@Query("limit") limitParam?: string) {
const limit = Number(limitParam) || 10;
const items = await (this.prisma as any).auditLog.findMany({
take: limit,
orderBy: { createdAt: "desc" },
});
return { success: true, data: items };
}
@Post()
@ApiOperation({ summary: "ثبت لاگ جدید در تاریخچه سیستم" })
async create(@Body() body: any) {
const item = await (this.prisma as any).auditLog.create({
data: {
entity: body.entity,
entityId: body.entityId ? String(body.entityId) : null,
action: body.action || "UPDATE",
department: body.department || "system",
actor: body.actor || "ADMIN",
summary: body.summary,
oldValues: body.oldValues || null,
newValues: body.newValues || null,
metadata: body.metadata || null,
},
});
return { success: true, data: item };
}
}
+117
View File
@@ -0,0 +1,117 @@
import { BadRequestException, ConflictException, NotFoundException } from "@nestjs/common";
import { BlogsService } from "./blogs.service";
// Stateful transactional double: deliberately interleave after snapshot read.
// Complements the DB integration test; it does not assert PostgreSQL locking.
describe("BlogsService atomic optimistic update", () => {
const token = "2026-10-24T23:36:08.501Z";
let row: any;
let service: BlogsService;
let prisma: any;
let revalidate: jest.Mock;
let afterRead: (() => void) | undefined;
let failRelations: boolean;
beforeEach(() => {
row = { id: "b1", slug: "post", title: "Original", updatedAt: new Date(token), tags: ["old"] };
afterRead = undefined;
failRelations = false;
const blog = {
findUnique: jest.fn(async () => {
const snapshot = { ...row };
afterRead?.();
return snapshot;
}),
updateMany: jest.fn(async ({ where, data }) => {
if (row.updatedAt >= where.updatedAt.gte && row.updatedAt < where.updatedAt.lt) {
row = { ...row, ...data };
return { count: 1 };
}
return { count: 0 };
}),
update: jest.fn(async ({ data }) => {
if (failRelations) throw new Error("relation failure");
row = { ...row, ...data };
return { ...row };
}),
};
// Serialize transactions like row locks. Rollback restores only transaction writes.
let tail = Promise.resolve();
prisma = { blog, $transaction: jest.fn((cb) => {
const next = tail.then(async () => {
const before = { ...row };
try { return await cb({ blog }); } catch (error) { row = before; throw error; }
});
tail = next.catch(() => undefined);
return next;
}) };
revalidate = jest.fn().mockResolvedValue(true);
service = new BlogsService(prisma, { revalidateBlog: revalidate } as any);
});
it.each([null, 0, 123, true, {}, [], "", "garbage", "2026-02-30T00:00:00.000Z", "2026-10-24", "2026-10-24T23:36:08.501001Z"])("rejects invalid token %p without mutations", async (value) => {
await expect(service.updateBlog("b1", { title: "bad", expectedUpdatedAt: value })).rejects.toBeInstanceOf(ConflictException);
expect(prisma.blog.update).not.toHaveBeenCalled();
expect(prisma.blog.updateMany).not.toHaveBeenCalled();
expect(revalidate).not.toHaveBeenCalled();
});
it("rejects stale token and leaves all relations untouched", async () => {
await expect(service.updateBlog("b1", { expectedUpdatedAt: "2026-10-20T00:00:00.000Z", tagNames: ["new"], categoryId: "c" })).rejects.toBeInstanceOf(ConflictException);
expect(row.tags).toEqual(["old"]);
expect(prisma.blog.update).not.toHaveBeenCalled();
expect(revalidate).not.toHaveBeenCalled();
});
it.each([token, "2026-10-25T01:36:08.501+02:00"])("accepts current token %s and atomically includes relations", async (expectedUpdatedAt) => {
const result = await service.updateBlog("b1", { title: "new", expectedUpdatedAt, authorId: "a", categoryId: "c", tagNames: ["new"] });
expect(result.title).toBe("new");
expect(prisma.$transaction).toHaveBeenCalledTimes(1);
expect(prisma.blog.updateMany).toHaveBeenCalledWith({ where: { id: "b1", updatedAt: { gte: new Date(token), lt: new Date(new Date(token).getTime() + 1) } }, data: { updatedAt: expect.any(Date) } });
expect(prisma.blog.update.mock.calls[0][0].data).toMatchObject({ author: { connect: { id: "a" } }, category: { connect: { id: "c" } }, tags: { set: [], connectOrCreate: expect.any(Array) } });
expect(prisma.blog.update.mock.calls[0][0].data).not.toHaveProperty("expectedUpdatedAt");
expect(result.updatedAt.getTime()).toBeGreaterThan(new Date(token).getTime());
expect(revalidate).toHaveBeenCalledTimes(1);
});
it("detects writer interleaving after read before write", async () => {
afterRead = () => { row = { ...row, title: "winner", updatedAt: new Date("2026-10-24T23:36:08.502Z"), tags: ["winner"] }; };
await expect(service.updateBlog("b1", { expectedUpdatedAt: token, title: "loser", tagNames: ["loser"] })).rejects.toBeInstanceOf(ConflictException);
expect(row.title).toBe("winner");
expect(row.tags).toEqual(["winner"]);
expect(prisma.blog.update).not.toHaveBeenCalled();
expect(revalidate).not.toHaveBeenCalled();
});
it("permits exactly one of two requests sharing a token", async () => {
const results = await Promise.allSettled([service.updateBlog("b1", { expectedUpdatedAt: token, title: "a" }), service.updateBlog("b1", { expectedUpdatedAt: token, title: "b" })]);
expect(results.filter(r => r.status === "fulfilled")).toHaveLength(1);
const rejected = results.find(r => r.status === "rejected") as PromiseRejectedResult;
expect(rejected.reason).toBeInstanceOf(ConflictException);
expect(revalidate).toHaveBeenCalledTimes(1);
});
it("advances token even when clock is within same millisecond", async () => {
jest.useFakeTimers().setSystemTime(new Date(token));
try {
await service.updateBlog("b1", { expectedUpdatedAt: token, title: "first" });
await expect(service.updateBlog("b1", { expectedUpdatedAt: token, title: "second" })).rejects.toBeInstanceOf(ConflictException);
} finally { jest.useRealTimers(); }
});
it("rolls back claim on nested relation failure without invalidating cache", async () => {
failRelations = true;
await expect(service.updateBlog("b1", { expectedUpdatedAt: token, tagNames: ["new"] })).rejects.toThrow("relation failure");
expect(row.updatedAt.toISOString()).toBe(token);
expect(row.tags).toEqual(["old"]);
expect(revalidate).not.toHaveBeenCalled();
});
it("preserves legacy omission without demanding a token", async () => {
await service.updateBlog("b1", { title: "legacy" });
expect(row.title).toBe("legacy");
expect(prisma.$transaction).not.toHaveBeenCalled();
});
it("returns 404 for a missing blog", async () => {
prisma.blog.findUnique.mockResolvedValue(null);
await expect(service.updateBlog("missing", { expectedUpdatedAt: token })).rejects.toBeInstanceOf(NotFoundException);
});
it("does not fail committed writes if revalidation throws", async () => {
revalidate.mockRejectedValue(new Error("cache down"));
const result = await service.updateBlog("b1", { expectedUpdatedAt: token, title: "saved" });
expect(result.cacheRevalidation).toBe("failed");
expect(row.title).toBe("saved");
});
});
+121 -2
View File
@@ -54,6 +54,8 @@ describe("Admin BlogsService", () => {
}).compile();
service = module.get<BlogsService>(BlogsService);
mockRevalidationService.revalidateBlog.mockReset();
mockRevalidationService.revalidateBlog.mockResolvedValue(true);
jest.clearAllMocks();
});
@@ -200,7 +202,10 @@ describe("Admin BlogsService", () => {
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith(
"new-health-post",
);
expect(result).toEqual(createdBlog);
expect(result).toEqual({
...createdBlog,
cacheRevalidation: "success",
});
});
it("allowlists create fields and blocks server-owned and unknown fields", async () => {
@@ -272,6 +277,66 @@ describe("Admin BlogsService", () => {
}),
);
});
it("should expose cacheRevalidation status on create result without failing persistence", async () => {
const blogData = {
title: "Health Post",
slug: "health-post",
content: "Content",
};
const createdBlog = { id: "blog-1", ...blogData };
mockPrisma.blog.create.mockResolvedValue(createdBlog);
mockRevalidationService.revalidateBlog.mockResolvedValue(true);
const result = await service.createBlog(blogData, "user-admin-1");
expect(mockPrisma.blog.create).toHaveBeenCalled();
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith("health-post");
expect(result).toEqual({
...createdBlog,
cacheRevalidation: "success",
});
});
it("should return cacheRevalidation 'failed' when revalidation fails without failing persistence", async () => {
const blogData = {
title: "Health Post",
slug: "health-post",
content: "Content",
};
const createdBlog = { id: "blog-1", ...blogData };
mockPrisma.blog.create.mockResolvedValue(createdBlog);
mockRevalidationService.revalidateBlog.mockResolvedValue(false);
const result = await service.createBlog(blogData, "user-admin-1");
expect(mockPrisma.blog.create).toHaveBeenCalled();
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith("health-post");
expect(result).toEqual({
...createdBlog,
cacheRevalidation: "failed",
});
});
it("should catch unexpected revalidation exceptions on create and return cacheRevalidation 'failed'", async () => {
const blogData = {
title: "Health Post",
slug: "health-post",
content: "Content",
};
const createdBlog = { id: "blog-1", ...blogData };
mockPrisma.blog.create.mockResolvedValue(createdBlog);
mockRevalidationService.revalidateBlog.mockRejectedValue(new Error("Frontend offline"));
const result = await service.createBlog(blogData, "user-admin-1");
expect(mockPrisma.blog.create).toHaveBeenCalled();
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith("health-post");
expect(result).toEqual({
...createdBlog,
cacheRevalidation: "failed",
});
});
});
describe("updateBlog", () => {
@@ -314,7 +379,61 @@ describe("Admin BlogsService", () => {
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith(
"my-post",
);
expect(result).toEqual(updated);
expect(result).toEqual({
...updated,
cacheRevalidation: "success",
});
});
it("should expose cacheRevalidation status on update result without failing persistence", async () => {
const existing = { id: "b1", slug: "my-post", title: "Old Title" };
mockPrisma.blog.findUnique.mockResolvedValue(existing);
const updated = { ...existing, title: "New Title" };
mockPrisma.blog.update.mockResolvedValue(updated);
mockRevalidationService.revalidateBlog.mockResolvedValue(true);
const result = await service.updateBlog("b1", { title: "New Title" });
expect(mockPrisma.blog.update).toHaveBeenCalled();
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith("my-post");
expect(result).toEqual({
...updated,
cacheRevalidation: "success",
});
});
it("should return cacheRevalidation 'failed' when revalidation fails on update without failing persistence", async () => {
const existing = { id: "b1", slug: "my-post", title: "Old Title" };
mockPrisma.blog.findUnique.mockResolvedValue(existing);
const updated = { ...existing, title: "New Title" };
mockPrisma.blog.update.mockResolvedValue(updated);
mockRevalidationService.revalidateBlog.mockResolvedValue(false);
const result = await service.updateBlog("b1", { title: "New Title" });
expect(mockPrisma.blog.update).toHaveBeenCalled();
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith("my-post");
expect(result).toEqual({
...updated,
cacheRevalidation: "failed",
});
});
it("should catch unexpected revalidation exceptions on update and return cacheRevalidation 'failed'", async () => {
const existing = { id: "b1", slug: "my-post", title: "Old Title" };
mockPrisma.blog.findUnique.mockResolvedValue(existing);
const updated = { ...existing, title: "New Title" };
mockPrisma.blog.update.mockResolvedValue(updated);
mockRevalidationService.revalidateBlog.mockRejectedValue(new Error("Revalidation timeout"));
const result = await service.updateBlog("b1", { title: "New Title" });
expect(mockPrisma.blog.update).toHaveBeenCalled();
expect(mockRevalidationService.revalidateBlog).toHaveBeenCalledWith("my-post");
expect(result).toEqual({
...updated,
cacheRevalidation: "failed",
});
});
});
+93 -14
View File
@@ -1,5 +1,6 @@
import {
BadRequestException,
ConflictException,
Injectable,
NotFoundException,
OnModuleInit,
@@ -255,8 +256,21 @@ export class BlogsService implements OnModuleInit, OnModuleDestroy {
},
});
await this.revalidationService.revalidateBlog(created.slug);
return created;
let cacheRevalidation: "success" | "failed" = "failed";
try {
const revalidated = await this.revalidationService.revalidateBlog(created.slug);
cacheRevalidation = revalidated ? "success" : "failed";
} catch (err: any) {
this.logger.warn(
`Cache revalidation failed for created blog [${created.slug}]: ${err?.message}`,
);
cacheRevalidation = "failed";
}
return {
...created,
cacheRevalidation,
};
}
async updateBlog(id: string, data: any) {
@@ -272,8 +286,30 @@ export class BlogsService implements OnModuleInit, OnModuleDestroy {
readingTime,
markContentUpdated,
contentUpdatedAt,
expectedUpdatedAt,
} = data;
const conflict = () => new ConflictException(
"CONCURRENT_MODIFICATION: Blog has been modified by another process",
);
let expectedTime: number | undefined;
if (expectedUpdatedAt !== undefined) {
// Only accept the millisecond, timezone-qualified ISO token returned by GET
// (or an equivalent offset). Avoid Date's coercion of null, numbers, arrays,
// and its normalization of impossible calendar dates.
const match = typeof expectedUpdatedAt === "string" && expectedUpdatedAt.match(
/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(Z|[+-]\d{2}:\d{2})$/,
);
if (!match) throw conflict();
expectedTime = Date.parse(expectedUpdatedAt);
const calendar = new Date(`${match[1]}-${match[2]}-${match[3]}T00:00:00.000Z`);
if (!Number.isFinite(expectedTime) ||
calendar.toISOString().slice(0, 10) !== `${match[1]}-${match[2]}-${match[3]}` ||
Number(match[4]) > 23 || Number(match[5]) > 59 || Number(match[6]) > 59) {
throw conflict();
}
}
const mutableScalarFields = [
"title",
"slug",
@@ -390,25 +426,68 @@ export class BlogsService implements OnModuleInit, OnModuleDestroy {
};
}
const updated = await this.prisma.blog.update({
where: { id },
data: updatePayload,
include: {
author: { select: { firstName: true, lastName: true } },
category: true,
tags: true,
},
});
const include = {
author: { select: { firstName: true, lastName: true } },
category: true,
tags: true,
};
// Legacy UI requests without a token intentionally retain last-write-wins.
// Guarded requests claim the row using a DB predicate, not the earlier read.
const updated = expectedTime === undefined
? await this.prisma.blog.update({ where: { id }, data: updatePayload, include })
: await this.prisma.$transaction(async (tx) => {
// PostgreSQL timestamptz defaults to microseconds; JSON/JS Dates expose
// milliseconds. Match the entire represented millisecond, then move
// strictly beyond it (including same-ms writes and clock rollback).
const claimedAt = new Date(Math.max(Date.now(), expectedTime + 1));
const claim = await tx.blog.updateMany({
where: {
id,
updatedAt: {
gte: new Date(expectedTime),
lt: new Date(expectedTime + 1),
},
},
data: { updatedAt: claimedAt },
});
if (claim.count !== 1) throw conflict();
// The claim holds the row lock until this nested mutation commits.
// Any relation failure rolls back both the claim and all data writes.
return tx.blog.update({
where: { id },
data: { ...updatePayload, updatedAt: claimedAt },
include,
});
});
await this.revalidationService.revalidateBlog(updated.slug);
return updated;
let cacheRevalidation: "success" | "failed" = "failed";
try {
const revalidated = await this.revalidationService.revalidateBlog(updated.slug);
cacheRevalidation = revalidated ? "success" : "failed";
} catch (err: any) {
this.logger.warn(
`Cache revalidation failed for updated blog [${updated.slug}]: ${err?.message}`,
);
cacheRevalidation = "failed";
}
return {
...updated,
cacheRevalidation,
};
}
async deleteBlog(id: string) {
const blog = await this.prisma.blog.findUnique({ where: { id } });
if (!blog) throw new NotFoundException("Blog not found");
const res = await this.prisma.blog.delete({ where: { id } });
await this.revalidationService.revalidateBlog(blog.slug);
try {
await this.revalidationService.revalidateBlog(blog.slug);
} catch (err: any) {
this.logger.warn(
`Cache revalidation failed for deleted blog [${blog.slug}]: ${err?.message}`,
);
}
return res;
}
@@ -1,84 +0,0 @@
import { BadRequestException } from "@nestjs/common";
import { assertTaskCanComplete } from "./department-task-completion.policy";
describe("department task completion policy", () => {
it("rejects model-only output without a live deliverable", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: null,
acceptanceCriteria: { criteria: ["live URL responds 200"] },
executionLogs: [{ status: "COMPLETED_BY_AGENT" }],
}),
).toThrow(BadRequestException);
});
it("rejects completion without acceptance criteria", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "https://canina.ir/blog/verified",
acceptanceCriteria: null,
executionLogs: [{ status: "QA_PASSED" }],
}),
).toThrow(BadRequestException);
});
it("rejects completion without QA evidence", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "https://canina.ir/blog/verified",
acceptanceCriteria: { criteria: ["HTTP 200"] },
executionLogs: [{ status: "COMPLETED_BY_AGENT" }],
}),
).toThrow(BadRequestException);
});
it("allows completion with URL, criteria and QA evidence", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "https://canina.ir/blog/verified",
acceptanceCriteria: { criteria: ["HTTP 200"] },
executionLogs: [{ status: "QA_PASSED" }],
}),
).not.toThrow();
});
it("rejects pseudo-protocol canina:// deliverable URLs", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "canina://blog/sample-article",
acceptanceCriteria: { criteria: ["HTTP 200"] },
executionLogs: [{ status: "QA_PASSED" }],
}),
).toThrow(BadRequestException);
});
it("rejects git://stage staging or repo URLs as verifiable deliverable", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "git://stage/canina-repo#commit123",
acceptanceCriteria: { criteria: ["HTTP 200"] },
executionLogs: [{ status: "QA_PASSED" }],
}),
).toThrow(BadRequestException);
});
it("rejects missing or placeholder post-tsk article deliverables", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "https://canina.ir/blog/post-tsk-49102",
acceptanceCriteria: { criteria: ["HTTP 200"] },
executionLogs: [{ status: "QA_PASSED" }],
}),
).toThrow(BadRequestException);
});
it("rejects completion when QA evidence reports missing article or 404 error", () => {
expect(() =>
assertTaskCanComplete({
deliverableUrl: "https://canina.ir/blog/verified-article",
acceptanceCriteria: { criteria: ["HTTP 200"] },
executionLogs: [{ status: "QA_PASSED", note: "HTTP 404 - مقاله یافت نشد" }],
}),
).toThrow(BadRequestException);
});
});
@@ -1,93 +0,0 @@
import { BadRequestException } from "@nestjs/common";
export interface CompletableTask {
code?: string | null;
title?: string | null;
deliverableUrl?: string | null;
acceptanceCriteria?: unknown;
executionLogs?: unknown;
}
function hasAcceptanceCriteria(criteria: unknown): boolean {
if (!criteria) return false;
if (typeof criteria === "string") return criteria.trim().length > 0;
if (Array.isArray(criteria)) return criteria.length > 0;
if (typeof criteria === "object") {
const value = criteria as Record<string, unknown>;
const items = value.criteria;
return Array.isArray(items) ? items.length > 0 : Object.keys(value).length > 0;
}
return false;
}
function hasValidQaEvidence(logs: unknown): boolean {
if (!Array.isArray(logs)) return false;
const validPassStatuses = ["QA_PASSED", "VERIFIED", "PRODUCTION_VERIFIED"];
let foundValidPass = false;
for (const log of logs) {
if (!log || typeof log !== "object") continue;
const entry = log as Record<string, unknown>;
const status = String(entry.status || "").toUpperCase();
const note = String(entry.note || "").toLowerCase();
// Rejection of invalid QA claims: 404, missing article, not found, post-tsk
if (
note.includes("404") ||
note.includes("مقاله یافت نشد") ||
note.includes("not found") ||
note.includes("missing article") ||
note.includes("post-tsk")
) {
return false;
}
if (validPassStatuses.includes(status)) {
foundValidPass = true;
}
}
return foundValidPass;
}
export function assertTaskCanComplete(task: CompletableTask): void {
const rawUrl = task.deliverableUrl?.trim();
if (!rawUrl) {
throw new BadRequestException("DONE requires a verifiable deliverable URL");
}
const lowerUrl = rawUrl.toLowerCase();
// Reject internal pseudo-protocols
if (lowerUrl.startsWith("canina://") || lowerUrl.includes("canina://")) {
throw new BadRequestException("Deliverable URL cannot use pseudo-protocol canina://; an independently verifiable HTTP(S) URL is required");
}
// Reject git repository pointers or staging branches as production deliverables
if (lowerUrl.startsWith("git://") || lowerUrl.includes("git://stage")) {
throw new BadRequestException("Deliverable URL cannot be a git staging reference; an independently verifiable HTTP(S) URL is required");
}
// Must be an HTTP or HTTPS URL
if (!lowerUrl.startsWith("http://") && !lowerUrl.startsWith("https://")) {
throw new BadRequestException("DONE requires an independently verifiable HTTP or HTTPS deliverable URL");
}
// Reject deleted or placeholder post-tsk articles
if (/post[-_]?tsk/i.test(rawUrl)) {
throw new BadRequestException("Deliverable URL references an unverified or deleted post-tsk placeholder article");
}
if (task.title && /post[-_]?tsk/i.test(task.title)) {
throw new BadRequestException("Task references an unverified or deleted post-tsk article");
}
if (task.code && /post[-_]?tsk/i.test(task.code)) {
throw new BadRequestException("Task references an unverified or deleted post-tsk code");
}
if (!hasAcceptanceCriteria(task.acceptanceCriteria)) {
throw new BadRequestException("DONE requires explicit acceptance criteria");
}
if (!hasValidQaEvidence(task.executionLogs)) {
throw new BadRequestException("DONE requires QA/production verification evidence");
}
}
@@ -1,25 +0,0 @@
import { GoneException } from '@nestjs/common';
import { DepartmentTasksController } from './department-tasks.controller';
import { PrismaService } from '../prisma/prisma.service';
describe('DepartmentTasksController retired mutation boundary',()=>{
const access=jest.fn();
const prisma=new Proxy({},{get:(_target,key)=>{access(key);throw new Error('Database access forbidden');}});
const controller=new DepartmentTasksController(prisma as PrismaService);
beforeEach(()=>access.mockClear());
it('create {department:SEO,title:Legacy} returns 410 without reading or writing persistence',async()=>{
await expect(controller.create({department:'SEO',title:'Legacy'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.create({department:'SEO',title:'Legacy'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
it('updateStatus missing, {status:DONE} returns 410 without reading or writing persistence',async()=>{
await expect(controller.updateStatus('missing', {status:'DONE'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.updateStatus('missing', {status:'DONE'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
it('updateStatus missing, {status:TODO} returns 410 without reading or writing persistence',async()=>{
await expect(controller.updateStatus('missing', {status:'TODO'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.updateStatus('missing', {status:'TODO'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
});
@@ -1,127 +0,0 @@
import {
Controller,
Get,
Post,
Put,
Body,
Param,
Query,
UseGuards,
NotFoundException,
GoneException,
} from "@nestjs/common";
import { ApiTags, ApiBearerAuth, ApiOperation } from "@nestjs/swagger";
import { JwtAuthGuard } from "../auth/jwt-auth.guard";
import { RolesGuard } from "../common/guards/roles.guard";
import { Roles } from "../common/decorators/roles.decorator";
import { PrismaService } from "../prisma/prisma.service";
@ApiTags("Admin - Department & Agent Tasks")
@ApiBearerAuth()
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles("Admin", "SUPER_ADMIN")
@Controller("admin/department-tasks")
export class DepartmentTasksController {
constructor(private readonly prisma: PrismaService) {}
@Get()
@ApiOperation({ summary: "لیست تسک‌های دپارتمان‌ها و ایجنت‌ها" })
async findAll(@Query() query: any) {
const page = Number(query.page) || 1;
const limit = Number(query.limit) || 100;
const skip = (page - 1) * limit;
const where: any = {};
if (query.department) where.department = query.department;
if (query.status) where.status = query.status;
if (query.priority) where.priority = query.priority;
if (query.search) {
where.OR = [
{ code: { contains: query.search, mode: "insensitive" } },
{ title: { contains: query.search, mode: "insensitive" } },
{ description: { contains: query.search, mode: "insensitive" } },
];
}
const [total, items] = await Promise.all([
(this.prisma as any).departmentTask.count({ where }),
(this.prisma as any).departmentTask.findMany({
where,
skip,
take: limit,
orderBy: [{ priority: "desc" }, { createdAt: "desc" }],
}),
]);
return {
success: true,
data: items,
meta: {
total,
page,
limit,
totalPages: Math.ceil(total / limit),
},
};
}
@Get("stats")
@ApiOperation({ summary: "آمار تسک‌ها به تفکیک استیت و دپارتمان" })
async getStats() {
const tasks = await (this.prisma as any).departmentTask.findMany({
select: { department: true, status: true, priority: true },
});
const statusCounts: Record<string, number> = {
TODO: 0,
IN_PROGRESS: 0,
TEST: 0,
DONE: 0,
BACKLOG: 0,
IN_REVIEW: 0,
APPROVED: 0,
DEPLOYING: 0,
};
const departmentCounts: Record<string, number> = {};
for (const t of tasks) {
statusCounts[t.status] = (statusCounts[t.status] || 0) + 1;
departmentCounts[t.department] = (departmentCounts[t.department] || 0) + 1;
}
return {
success: true,
data: {
total: tasks.length,
byStatus: statusCounts,
byDepartment: departmentCounts,
},
};
}
@Get(":id")
@ApiOperation({ summary: "دریافت جزییات یک تسک" })
async findOne(@Param("id") id: string) {
const task = await (this.prisma as any).departmentTask.findUnique({
where: { id },
});
if (!task) throw new NotFoundException(`Task ${id} not found`);
return { success: true, data: task };
}
@Post()
@ApiOperation({ summary: "ایجاد تسک جدید سازمانی" })
async create(@Body() body: any) {
throw new GoneException("Legacy orchestration mutations are retired. Orchestration v4 remains read-only; no replacement mutation is enabled.");
}
@Put(":id/status")
@ApiOperation({ summary: "تغییر وضعیت تسک همراه با لاگ اجرا" })
async updateStatus(
@Param("id") id: string,
@Body() body: { status: string; logNote?: string; deliverableUrl?: string }
) {
throw new GoneException("Legacy orchestration mutations are retired. Orchestration v4 remains read-only; no replacement mutation is enabled.");
}
}
@@ -1,68 +0,0 @@
import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
import { IsString, IsOptional, IsObject } from "class-validator";
export class CreateApprovalRequestDto {
@ApiProperty({ description: "دپارتمان مبدا (DEV, SUPPLY, FINANCE, SEO, CRM, CONTENT)" })
@IsString()
department: string;
@ApiProperty({ description: "دسته‌بندی (PRICING, PURCHASE_ORDER, CAMPAIGN, DEPLOY, etc)" })
@IsString()
category: string;
@ApiProperty({ description: "عنوان مورد تایید" })
@IsString()
title: string;
@ApiProperty({ description: "داده‌های تغییرات پیشنهادی" })
@IsObject()
payload: Record<string, any>;
@ApiPropertyOptional({ description: "داده‌های سناریوی تست و ارزیابی" })
@IsOptional()
@IsObject()
testContext?: Record<string, any>;
}
export class DecideApprovalDto {
@ApiProperty({ description: "تصمیم: APPROVED یا REJECTED" })
@IsString()
decision: "APPROVED" | "REJECTED";
@ApiPropertyOptional({ description: "توضیحات و یادداشت مدیرعامل" })
@IsOptional()
@IsString()
ceoNotes?: string;
@ApiPropertyOptional({ description: "نتیجه اقدام مدیریتی یا استراتژیک" })
@IsOptional()
@IsString()
outcome?: string;
@ApiPropertyOptional({ description: "مستندات و مدرک اقدام مدیریتی" })
@IsOptional()
@IsString()
evidence?: string;
}
export class QueryApprovalDto {
@ApiPropertyOptional()
@IsOptional()
department?: string;
@ApiPropertyOptional()
@IsOptional()
category?: string;
@ApiPropertyOptional()
@IsOptional()
status?: string;
@ApiPropertyOptional()
@IsOptional()
page?: number;
@ApiPropertyOptional()
@IsOptional()
limit?: number;
}
+5
View File
@@ -5,9 +5,12 @@ import {
IsEmail,
MinLength,
IsNumber,
IsIn,
} from "class-validator";
import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
import { ALLOWED_USER_ROLES } from "../user-role-policy";
export class CreateUserDto {
@ApiProperty({ description: "نام کاربر", example: "علی" })
@IsNotEmpty({ message: "نام الزامی است" })
@@ -41,6 +44,7 @@ export class CreateUserDto {
@ApiPropertyOptional({ description: "نقش کاربر", example: "User_PetOwner" })
@IsOptional()
@IsString()
@IsIn(ALLOWED_USER_ROLES)
role?: string;
@ApiPropertyOptional({ description: "موجودی اولیه کیف پول", example: 0 })
@@ -85,6 +89,7 @@ export class UpdateUserDto {
@ApiPropertyOptional({ description: "نقش کاربر", example: "User_PetOwner" })
@IsOptional()
@IsString()
@IsIn(ALLOWED_USER_ROLES)
role?: string;
@ApiPropertyOptional({ description: "موجودی کیف پول", example: 500000 })
@@ -1,52 +0,0 @@
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { ApprovalsController } from './approvals.controller';
import { DepartmentTasksController } from './department-tasks.controller';
import { PrismaService } from '../prisma/prisma.service';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { RolesGuard } from '../common/guards/roles.guard';
describe('retired legacy orchestration HTTP boundary', () => {
let app: INestApplication;
const dbAccess = jest.fn();
const prisma = new Proxy({}, {get: (_target, key) => {
// Nest inspects provider thenables and lifecycle hooks during setup.
if (["then", "onModuleInit", "onApplicationBootstrap", "onModuleDestroy", "beforeApplicationShutdown", "onApplicationShutdown"].includes(String(key))) return undefined;
dbAccess(key);
throw new Error('Persistence must not be accessed');
}});
const routes = [
['post', '/admin/approvals'],
['put', '/admin/approvals/missing/decide'],
['post', '/admin/department-tasks'],
['put', '/admin/department-tasks/missing/status'],
] as const;
beforeAll(async () => {
const module = await Test.createTestingModule({
controllers: [ApprovalsController, DepartmentTasksController],
providers: [{provide: PrismaService, useValue: prisma}, RolesGuard],
}).overrideGuard(JwtAuthGuard).useValue({canActivate(context: any) {
const req = context.switchToHttp().getRequest();
if (!req.headers.authorization) return false;
req.user = {id: 'test-admin', role: req.headers.authorization};
return true;
}}).compile();
app = module.createNestApplication();
await app.init();
dbAccess.mockClear();
});
beforeEach(() => dbAccess.mockClear());
afterAll(async () => { if (app) await app.close(); });
it.each(routes)('%s %s returns explicit 410 for authorized callers before database access', async (method, path) => {
const response = await request(app.getHttpServer())[method](path)
.set('Authorization', 'Admin').send({decision:'APPROVED',status:'DONE'}).expect(410);
expect(response.body.message).toContain('retired');
expect(dbAccess).not.toHaveBeenCalled();
});
it.each(routes)('%s %s retains anonymous and customer authorization guards', async (method, path) => {
await request(app.getHttpServer())[method](path).send({}).expect(403);
await request(app.getHttpServer())[method](path).set('Authorization','CUSTOMER').send({}).expect(403);
expect(dbAccess).not.toHaveBeenCalled();
});
});
+27
View File
@@ -0,0 +1,27 @@
import { ForbiddenException } from "@nestjs/common";
export const ALLOWED_USER_ROLES = [
"User_PetOwner", "User_Vet", "User_Clinic", "User_PetShop",
"User_Wholesale", "User_B2B", "Customer", "Admin", "ADMIN", "SUPER_ADMIN",
];
export interface UserAdminActor {
id?: string;
role?: string;
isApiKey?: boolean;
}
// Match RolesGuard semantics; keep stored values unchanged.
export function isSuperAdminRole(role?: string): boolean {
const normalized = typeof role === "string" ? role.toLowerCase().replace(/[_-]/g, "") : "";
return normalized === "superadmin" || normalized === "adminsuper";
}
export function assertUserMutationAllowed(actor?: UserAdminActor, currentRole?: string, nextRole?: string): void {
const role = actor?.role?.toLowerCase().replace(/[_-]/g, "");
const isSuperAdmin = !!actor?.id && !actor.isApiKey && isSuperAdminRole(actor.role);
if ((!actor?.id && !actor?.isApiKey) || (role !== "admin" && !isSuperAdmin) ||
((isSuperAdminRole(currentRole) || isSuperAdminRole(nextRole)) && !isSuperAdmin)) {
throw new ForbiddenException("فقط مدیر ارشد مجاز به مدیریت حساب و نقش مدیر ارشد است");
}
}
-9
View File
@@ -1,6 +1,3 @@
import { registerPrepareWorker } from './orchestration-worker/worker-registration';
import { RouterUsageModule } from './router-usage/router-usage.module';
import { runtimeReadRegistration } from './hermes-management/runtime-read.registration';
import { TasksModule } from './common/services/tasks.module';
import { Module, NestModule, MiddlewareConsumer } from "@nestjs/common";
import { PrismaModule } from "./prisma/prisma.module";
@@ -40,17 +37,11 @@ import { DoctorsModule } from "./doctors/doctors.module";
import { FaqModule } from "./faq/faq.module";
import { MenuModule } from "./menu/menu.module";
import { RevalidationModule } from "./common/revalidation/revalidation.module";
import { OrchestrationModule } from "./orchestration/orchestration.module";
import { Request, Response, NextFunction } from "express";
@Module({
imports: [
...registerPrepareWorker(),
RouterUsageModule,
// Deny-all registration: no request identity or runtime credentials are accepted yet.
runtimeReadRegistration(),
OrchestrationModule,
SupportChatModule,
RevalidationModule,
SmsModule,
+15 -3
View File
@@ -14,6 +14,7 @@ import { SmsService } from "../common/services/sms.service";
import * as bcrypt from "bcryptjs";
import * as crypto from "crypto";
import { normalizeMobile } from "../common/utils/phone.utils";
import { assertPrincipalActive } from "./stage-test-principal";
import { getJwtRefreshSecret } from "./auth.constants";
export class RegisterInput {
@@ -200,7 +201,8 @@ export class AuthService {
});
}
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role };
assertPrincipalActive(user);
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role, ...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}) };
const tokens = await this.generateTokens(payload);
const { password: _p, ...safeUser } = user;
@@ -257,7 +259,8 @@ export class AuthService {
},
});
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role };
assertPrincipalActive(user);
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role, ...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}) };
const tokens = await this.generateTokens(payload);
const { password: _p, ...safeUser } = user;
@@ -300,7 +303,8 @@ export class AuthService {
});
}
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role };
assertPrincipalActive(user);
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role, ...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}) };
const tokens = await this.generateTokens(payload);
const { password: _pw, ...safeUser } = user;
@@ -326,10 +330,12 @@ export class AuthService {
if (dbAdmin && dbAdmin.password && body.password) {
const isMatch = await bcrypt.compare(body.password, dbAdmin.password);
if (isMatch) {
assertPrincipalActive(dbAdmin);
const payload = {
sub: dbAdmin.id,
email: dbAdmin.email,
role: dbAdmin.role,
...(dbAdmin.stageTestSession ? {stageTestSession:dbAdmin.stageTestSession, stageTestGeneration:dbAdmin.stageTestGeneration} : {}),
};
const tokens = await this.generateTokens(payload);
const { password: _p, ...safeUser } = dbAdmin;
@@ -443,11 +449,14 @@ export class AuthService {
const user = await this.prisma.user.findUnique({ where: { id: userId } });
if (user) {
assertPrincipalActive(user);
if (user.stageTestSession && (!user.stageTestGeneration || decoded.stageTestGeneration !== user.stageTestGeneration || decoded.stageTestSession !== user.stageTestSession)) throw new UnauthorizedException("Stage session revoked");
userPayload = {
sub: user.id,
email: user.email,
phoneNumber: user.mobile,
role: user.role,
...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}),
};
const { password: _p, ...restUser } = user;
safeUser = restUser;
@@ -487,12 +496,15 @@ export class AuthService {
email?: string;
role?: string;
mobile?: string;
stageTestSession?: string | null;
stageTestGeneration?: string | null;
}) {
const payload = {
sub: user.id,
email: user.email,
role: user.role,
phoneNumber: user.mobile,
...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}),
};
const tokens = await this.generateTokens(payload);
return {
+18
View File
@@ -0,0 +1,18 @@
import { AdminService } from '../admin/admin.service';
import { STAGE_TEST_ID, STAGE_TEST_EMAIL, STAGE_TEST_MOBILE } from './stage-test-principal';
const sha='a'.repeat(40), generation='8311eb41-23b4-4aab-ade2-e97b90debc11';
const env={APP_ENV:'stage',CI:'true',STAGE_TEST_PRINCIPAL_ENABLED:'true',STAGE_TEST_APPROVAL:'owner-authorized-stage-editorial',STAGE_TEST_SHA:sha,STAGE_TEST_SESSION:'cleanup-session',STAGE_TEST_TTL_SECONDS:'600',STAGE_TEST_GENERATION:generation};
describe('durable cleanup ownership fence',()=>{
it('does not revoke a replacement generation',async()=>{
const update=jest.fn();
const db={user:{findUnique:async()=>({id:STAGE_TEST_ID,email:STAGE_TEST_EMAIL,mobile:STAGE_TEST_MOBILE,stageTestSession:env.STAGE_TEST_SESSION,stageTestGeneration:'replacement',authExpiresAt:new Date()}),update}};
await expect(new AdminService(db as any,undefined as any,undefined as any).cleanupStageTestPrincipal(env,sha)).rejects.toThrow('Refusing');
expect(update).not.toHaveBeenCalled();
});
it('confirms revocation before relational deletion failure',async()=>{
const events:string[]=[];
const db={user:{findUnique:async()=>({id:STAGE_TEST_ID,email:STAGE_TEST_EMAIL,mobile:STAGE_TEST_MOBILE,stageTestSession:env.STAGE_TEST_SESSION,stageTestGeneration:generation,authExpiresAt:new Date()}),update:async()=>events.push('revoke')},$transaction:async()=>{events.push('delete');throw Error('FK failure');}};
await expect((new AdminService(db as any,undefined as any,undefined as any).cleanupStageTestPrincipal as any)(env,sha,()=>events.push('handle-removed'))).rejects.toThrow('FK failure');
expect(events).toEqual(['revoke','handle-removed','delete']);
});
});
+10
View File
@@ -2,6 +2,7 @@ import { ExtractJwt, Strategy } from "passport-jwt";
import { PassportStrategy } from "@nestjs/passport";
import { Injectable, UnauthorizedException } from "@nestjs/common";
import { UsersService } from "../users/users.service";
import { assertPrincipalActive } from "./stage-test-principal";
import { getJwtSecret } from "./auth.constants";
import { RedisService } from "../redis/redis.service";
@@ -12,6 +13,8 @@ export interface JwtPayload {
email?: string;
role?: string;
phoneNumber?: string;
stageTestSession?: string;
stageTestGeneration?: string;
}
@Injectable()
@@ -59,6 +62,13 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
if (!user) {
throw new UnauthorizedException("کاربر یافت نشد");
}
try { assertPrincipalActive(user); } catch { throw new UnauthorizedException("Principal expired"); }
if (user.stageTestSession) {
if (!user.stageTestGeneration || payload.stageTestGeneration !== user.stageTestGeneration || payload.stageTestSession !== user.stageTestSession) throw new UnauthorizedException("Stage session revoked");
const path = req.originalUrl?.split('?')[0] || '';
const allowed = req.method === 'GET' && /^\/api\/admin\/orchestration\/tasks(?:\/[a-f0-9-]+)?$/.test(path) || req.method === 'POST' && (/^\/api\/admin\/orchestration\/tasks$/.test(path) || /^\/api\/admin\/orchestration\/tasks\/[a-f0-9-]+\/(?:gates\/1\/decide|editorial-failure|editorial-completed-recovery)$/.test(path));
if (!allowed) throw new UnauthorizedException('Stage test scope denied');
}
return user;
}
}
@@ -0,0 +1,44 @@
import { PrismaClient } from '@prisma/client';
import { JwtService } from '@nestjs/jwt';
import { AuthService } from './auth.service';
import { RedisService } from '../redis/redis.service';
import { STAGE_TEST_ID } from './stage-test-principal';
import { createServer, Server } from 'http';
import { execFile } from 'child_process';
import { promisify } from 'util';
import { readFileSync, writeFileSync, existsSync } from 'fs';
const enabled=process.env.STAGE_PRINCIPAL_DISPOSABLE_TEST==='true';
(enabled?describe:describe.skip)('actual internal CLI disposable lifecycle',()=>{
const sha='a'.repeat(40), generation='b411eb41-23b4-4aab-ade2-e97b90debc11', session='cli-integration-session';
const handle=`/app/private-stage-test/${session}.json`;
const db=new PrismaClient({log:[]}), redis=new RedisService(); let server:Server;
const env={...process.env,APP_ENV:'stage',CI:'true',STAGE_TEST_PRINCIPAL_ENABLED:'true',STAGE_TEST_APPROVAL:'owner-authorized-stage-editorial',STAGE_TEST_SHA:sha,STAGE_TEST_SESSION:session,STAGE_TEST_TTL_SECONDS:'600',STAGE_TEST_GENERATION:generation};
const cli=(action:string)=>promisify(execFile)(process.execPath,['-r','ts-node/register','src/auth/stage-test-principal.cli.ts',action],{env,timeout:90000});
beforeAll(async()=>{
if(!process.env.DATABASE_URL?.endsWith('/principal_disposable')) throw Error('Disposable database only');
writeFileSync('/app/STAGE_TEST_ARTIFACT_SHA',sha); redis.onModuleInit();
const auth=new AuthService(db as any,new JwtService({secret:process.env.JWT_SECRET,signOptions:{expiresIn:'2h'}}),redis,undefined as any);
server=createServer(async(req,res)=>{
try {let body='';for await(const chunk of req) body+=chunk;
if(req.url!=='/api/auth/admin-login') {res.writeHead(404).end();return;}
const login=await auth.adminLogin(JSON.parse(body));res.setHeader('content-type','application/json');res.end(JSON.stringify(login));
} catch {res.writeHead(401).end();}
});
await new Promise<void>(r=>server.listen(3000,'127.0.0.1',r));
},120000);
afterAll(async()=>{await new Promise<void>(r=>server.close(()=>r()));redis.onModuleDestroy();await db.$disconnect();});
it('logs in using persisted credentials and removes handle on confirmed revocation despite failed delete',async()=>{
await cli('open'); expect(existsSync(handle)).toBe(true);
const credential=JSON.parse(readFileSync(handle,'utf8'));expect(credential.accessToken).toBeTruthy();
expect((await db.user.findUnique({where:{id:STAGE_TEST_ID}}))?.stageTestGeneration).toBe(generation);
await db.$executeRawUnsafe(`CREATE FUNCTION deny_principal_delete() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'test FK deletion failure'; END $$`);
await db.$executeRawUnsafe(`CREATE TRIGGER deny_principal_delete BEFORE DELETE ON users FOR EACH ROW EXECUTE FUNCTION deny_principal_delete()`);
try {
await expect(cli('close')).rejects.toThrow();
expect(existsSync(handle)).toBe(false);
const revoked=await db.user.findUnique({where:{id:STAGE_TEST_ID}});
expect(revoked?.authExpiresAt?.getTime()).toBe(0);expect(revoked?.password).toBe('');
} finally {await db.$executeRawUnsafe(`DROP TRIGGER deny_principal_delete ON users`);await db.$executeRawUnsafe(`DROP FUNCTION deny_principal_delete()`);}
await cli('close');expect(await db.user.findUnique({where:{id:STAGE_TEST_ID}})).toBeNull();
},240000);
});
@@ -0,0 +1,68 @@
import 'reflect-metadata';
import { PrismaClient } from '@prisma/client';
import { randomBytes } from 'crypto';
import { mkdirSync, openSync, writeFileSync, closeSync, readFileSync, statSync, unlinkSync, constants } from 'fs';
import { AdminService } from '../admin/admin.service';
import { authorizeStageSession, STAGE_TEST_EMAIL } from './stage-test-principal';
// CI-only internal seed command; deliberately not registered in AppModule.
async function main() {
const sha = readFileSync('/app/STAGE_TEST_ARTIFACT_SHA', 'utf8').trim();
const grant = authorizeStageSession(process.env, sha);
const action = process.argv[2];
if (action === 'cleanup-capability') { process.stdout.write('stage-generation-cleanup-v1'); return; }
if (!['open','close'].includes(action)) throw new Error('Unknown command');
const root = '/app/private-stage-test';
mkdirSync(root,{recursive:true,mode:0o700});
const st = statSync(root);
if (st.uid !== process.getuid!() || (st.mode & 0o777) !== 0o700) throw new Error('Unsafe private directory');
if (!/^[a-f0-9-]{36}$/.test(process.env.STAGE_TEST_GENERATION || '')) throw new Error('Generation required');
const handle = `${root}/${grant.session}.json`;
const removeHandle = () => { try {unlinkSync(handle);} catch(e:any) {if(e.code !== 'ENOENT') throw e;} };
const audit = (event:string) => {
const fd = openSync(`${root}/audit.jsonl`, constants.O_WRONLY|constants.O_CREAT|constants.O_APPEND|constants.O_NOFOLLOW,0o600);
try { writeFileSync(fd,JSON.stringify({event,sha,session:grant.session,at:new Date().toISOString()})+'\n'); } finally {closeSync(fd);}
};
const db = new PrismaClient({log:[]});
const service = new AdminService(db as any,undefined as any,undefined as any);
try {
audit(`${action}-requested`);
if(action === 'close') {
await service.cleanupStageTestPrincipal(process.env,sha,removeHandle);
audit('revoked-and-deleted');
return;
}
let fd:number;
let password:string;
try {
fd = openSync(handle,constants.O_WRONLY|constants.O_CREAT|constants.O_EXCL|constants.O_NOFOLLOW,0o600);
password = randomBytes(48).toString('base64url');
try {writeFileSync(fd,JSON.stringify({password}));} finally {closeSync(fd);}
} catch(e:any) {
if(e.code !== 'EEXIST') throw e;
fd = openSync(handle,constants.O_RDONLY|constants.O_NOFOLLOW);
try {
const {fstatSync} = await import('fs'); const s=fstatSync(fd);
if(!s.isFile() || s.uid !== process.getuid!() || (s.mode & 0o777) !== 0o600) throw new Error('Unsafe handle');
password=JSON.parse(readFileSync(fd,'utf8')).password;
} finally {closeSync(fd);}
}
const user=await service.provisionStageTestPrincipal(process.env,sha,password);
// Use deployed persisted-account HTTP login, never sign tokens here.
const response=await fetch('http://127.0.0.1:3000/api/auth/admin-login',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({email:STAGE_TEST_EMAIL,password}),signal:AbortSignal.timeout(15000)});
if(!response.ok) throw new Error('Persisted login failed');
const result:any=await response.json();
if(result.data?.user?.id !== user.id || result.data?.user?.role !== 'SUPER_ADMIN' || !result.data?.accessToken) throw new Error('Persisted login mismatch');
fd=openSync(handle,constants.O_WRONLY|constants.O_TRUNC|constants.O_NOFOLLOW);
try {writeFileSync(fd,JSON.stringify({password,...result.data,expiresAt:user.authExpiresAt}));} finally {closeSync(fd);}
audit('created-and-login-verified');
// Only an opaque local path is public. Never upload this file as a CI artifact.
process.stdout.write(`Stage credential handle: ${handle}\n`);
} catch {
audit('failed');
// Leave only a revoked account if relational cleanup fails.
await service.cleanupStageTestPrincipal(process.env,sha,removeHandle).catch(()=>undefined);
throw new Error('Stage test principal operation failed; inspect private audit');
} finally {await db.$disconnect();}
}
main().catch(()=>{process.stderr.write('Stage test principal denied or failed\n');process.exitCode=1;});
@@ -0,0 +1,58 @@
import { PrismaClient } from '@prisma/client';
import { randomBytes } from 'crypto';
import { JwtService } from '@nestjs/jwt';
import { AdminService } from '../admin/admin.service';
import { AuthService } from './auth.service';
import { UsersService } from '../users/users.service';
import { JwtStrategy } from './jwt.strategy';
import { RedisService } from '../redis/redis.service';
import { STAGE_TEST_ID, STAGE_TEST_EMAIL, STAGE_TEST_MOBILE } from './stage-test-principal';
const enabled=process.env.STAGE_PRINCIPAL_DISPOSABLE_TEST === 'true';
(enabled ? describe : describe.skip)('disposable persisted Stage principal lifecycle',()=>{
const sha='a'.repeat(40), grant={APP_ENV:'stage',CI:'true',STAGE_TEST_PRINCIPAL_ENABLED:'true',STAGE_TEST_APPROVAL:'owner-authorized-stage-editorial',STAGE_TEST_SHA:sha,STAGE_TEST_SESSION:'integration-session',STAGE_TEST_TTL_SECONDS:'600'};
const db=new PrismaClient({log:[]}); const redis=new RedisService();
let admin:AdminService,auth:AuthService,strategy:JwtStrategy,password:string;
beforeAll(async()=>{
// Deliberately require a disposable database name; never point this suite at Stage.
if(!process.env.DATABASE_URL?.endsWith('/principal_disposable')) throw new Error('Disposable database required');
redis.onModuleInit(); password=randomBytes(48).toString('base64url');
admin=new AdminService(db as any,redis,undefined as any);
auth=new AuthService(db as any,new JwtService({secret:process.env.JWT_SECRET,signOptions:{expiresIn:'2h'}}),redis,undefined as any);
strategy=new JwtStrategy(new UsersService(db as any),redis);
});
afterAll(async()=>{await admin.cleanupStageTestPrincipal(grant,sha); await db.$disconnect();redis.onModuleDestroy();});
it('rejects unowned collision and never changes it',async()=>{
const collision=await db.user.create({data:{firstName:'Unowned',lastName:'Account',email:STAGE_TEST_EMAIL,mobile:STAGE_TEST_MOBILE}});
try {
await expect(admin.provisionStageTestPrincipal(grant,sha,password)).rejects.toThrow('Refusing');
expect((await db.user.findUnique({where:{id:collision.id}}))?.role).toBe('User_PetOwner');
} finally {await db.user.delete({where:{id:collision.id}});}
});
it('creates through account service, logs in, verifies signed tokens, never renews retry TTL',async()=>{
const u=await admin.provisionStageTestPrincipal(grant,sha,password);
expect(u.id).toBe(STAGE_TEST_ID); expect(u.role).toBe('SUPER_ADMIN'); expect(u.password).not.toBe(password);
const retry=await admin.provisionStageTestPrincipal(grant,sha,password); expect(retry.authExpiresAt).toEqual(u.authExpiresAt);
await expect(admin.provisionStageTestPrincipal({...grant,STAGE_TEST_SESSION:'different-session'},sha,password)).rejects.toThrow('Refusing');
const login=await auth.adminLogin({email:STAGE_TEST_EMAIL,password});
const jwt=new JwtService({secret:process.env.JWT_SECRET});
const payload=jwt.verify(login.data.accessToken); expect(payload.sub).toBe(u.id);expect(payload.role).toBe('SUPER_ADMIN');
const req:any={method:'GET',originalUrl:'/api/admin/orchestration/tasks',headers:{authorization:`Bearer ${login.data.accessToken}`}};
expect((await strategy.validate(req,payload)).id).toBe(u.id);
await expect(strategy.validate({...req,originalUrl:'/api/admin/users'},payload)).rejects.toThrow('scope denied');
await expect(strategy.validate({...req,method:'POST',originalUrl:'/api/admin/orchestration/tasks/abcd/gates/2/decide'},payload)).rejects.toThrow('scope denied');
// Fixture time travel: persisted expiry is enforced independently of the long-lived signed token.
await db.user.update({where:{id:u.id},data:{authExpiresAt:new Date(0)}});
await expect(strategy.validate(req,payload)).rejects.toThrow();
await expect(auth.adminLogin({email:STAGE_TEST_EMAIL,password})).rejects.toThrow();
await expect(auth.refreshToken(login.data.refreshToken)).rejects.toThrow();
await admin.cleanupStageTestPrincipal(grant,sha);
await expect(strategy.validate(req,payload)).rejects.toThrow();
expect(await db.user.findUnique({where:{id:u.id}})).toBeNull();
const replacement=await admin.provisionStageTestPrincipal(grant,sha,password);
expect(replacement.stageTestGeneration).not.toBe(u.stageTestGeneration);
await expect(strategy.validate(req,payload)).rejects.toThrow();
await expect(auth.refreshToken(login.data.refreshToken)).rejects.toThrow();
const fresh=await auth.adminLogin({email:STAGE_TEST_EMAIL,password});
expect((await strategy.validate(req,jwt.verify(fresh.data.accessToken))).id).toBe(u.id);
});
});
@@ -0,0 +1,13 @@
import { assertPrincipalActive, authorizeStageSession } from './stage-test-principal';
const sha = 'a'.repeat(40);
const valid = { APP_ENV: 'stage', STAGE_TEST_PRINCIPAL_ENABLED: 'true', CI: 'true', STAGE_TEST_APPROVAL: 'owner-authorized-stage-editorial', STAGE_TEST_SHA: sha, STAGE_TEST_SESSION: 'editorial-20261024', STAGE_TEST_TTL_SECONDS: '600' };
describe('Stage CI authority', () => {
it('denies by default and in Production despite opt in', () => {
expect(() => authorizeStageSession({}, sha)).toThrow();
expect(() => authorizeStageSession({...valid, APP_ENV:'production'}, sha)).toThrow();
});
it('requires immutable matching SHA and bounded explicit authorization', () => {
expect(authorizeStageSession(valid, sha).ttl).toBe(600);
for(const patch of [{STAGE_TEST_SHA:'main'}, {STAGE_TEST_SHA:'b'.repeat(40)}, {STAGE_TEST_TTL_SECONDS:'3601'}, {STAGE_TEST_TTL_SECONDS:'0'}, {STAGE_TEST_APPROVAL:''}, {CI:''}]) expect(() => authorizeStageSession({...valid,...patch},sha)).toThrow();
});
});
+13
View File
@@ -0,0 +1,13 @@
// Internal seed authority only. No controller, JWT actor, or owner impersonation.
export const STAGE_TEST_ID = 'e876e7a0-738f-4e59-b6db-e270512ababc';
export const STAGE_TEST_EMAIL = 'stage-editorial-reviewer@ci.canina.invalid';
export const STAGE_TEST_MOBILE = '09999999071';
export function authorizeStageSession(env: NodeJS.ProcessEnv, artifactSha: string) {
if (env.APP_ENV !== 'stage' || env.STAGE_TEST_PRINCIPAL_ENABLED !== 'true' || env.CI !== 'true' || env.STAGE_TEST_APPROVAL !== 'owner-authorized-stage-editorial' || !/^[a-f0-9]{40}$/.test(artifactSha) || env.STAGE_TEST_SHA !== artifactSha || !/^[a-z0-9-]{8,64}$/.test(env.STAGE_TEST_SESSION || '')) throw new Error('Stage CI authority denied');
const ttl = Number(env.STAGE_TEST_TTL_SECONDS);
if (!Number.isInteger(ttl) || ttl < 60 || ttl > 3600) throw new Error('Bounded TTL required');
return {ttl, session:env.STAGE_TEST_SESSION!, sha:artifactSha};
}
export function assertPrincipalActive(user: { authExpiresAt?: Date | null }, now = Date.now()) {
if (user.authExpiresAt && user.authExpiresAt.getTime() <= now) throw new Error('Principal expired');
}
@@ -0,0 +1,32 @@
import { JwtService } from '@nestjs/jwt';
import { JwtStrategy } from './jwt.strategy';
import { AuthService } from './auth.service';
describe('Stage credentials remain fenced to their creation session', () => {
const id='e876e7a0-738f-4e59-b6db-e270512ababc';
const current={id, role:'SUPER_ADMIN', stageTestSession:'new-session', stageTestGeneration:'fresh-generation', authExpiresAt:new Date(Date.now()+600000)};
const redis:any={get:jest.fn(async()=> '1'),del:jest.fn(),set:jest.fn()};
beforeAll(()=> {process.env.JWT_SECRET='disposable-only-test-secret-at-least-32-characters';process.env.JWT_REFRESH_SECRET='disposable-only-refresh-secret-at-least-32-characters';});
it('rejects an old-session access token after fixed account ID is recreated',async()=>{
const strategy=new JwtStrategy({findById:async()=>current} as any,{get:async()=>null} as any);
const req:any={method:'GET',originalUrl:'/api/admin/orchestration/tasks',headers:{}};
await expect(strategy.validate(req,{sub:id,stageTestSession:'old-session'} as any)).rejects.toThrow();
await expect(strategy.validate(req,{sub:id})).rejects.toThrow();
await expect(strategy.validate(req,{sub:id,stageTestSession:'new-session',stageTestGeneration:'old-generation'} as any)).rejects.toThrow();
await expect(strategy.validate(req,{sub:id,stageTestSession:'new-session',stageTestGeneration:'fresh-generation'} as any)).resolves.toMatchObject({id});
});
it('rejects an old-session refresh token even while its Redis entry remains active',async()=>{
const jwt=new JwtService({secret:process.env.JWT_SECRET});
const auth=new AuthService({user:{findUnique:async()=>current}} as any,jwt,redis,undefined as any);
const token=jwt.sign({sub:id,jti:'old-refresh',role:'SUPER_ADMIN',stageTestSession:'old-session'},{secret:process.env.JWT_REFRESH_SECRET});
await expect(auth.refreshToken(token)).rejects.toThrow();
});
it('includes session fencing in newly issued credentials',async()=>{
const jwt=new JwtService({secret:process.env.JWT_SECRET});
const auth=new AuthService({} as any,jwt,redis,undefined as any);
const result=await auth.refresh(current);
expect(jwt.verify(result.data.accessToken).stageTestGeneration).toBe('fresh-generation');
expect(jwt.verify(result.data.accessToken).stageTestSession).toBe('new-session');
expect(jwt.verify(result.data.refreshToken,{secret:process.env.JWT_REFRESH_SECRET}).stageTestSession).toBe('new-session');
});
});
+47 -18
View File
@@ -2,8 +2,15 @@ import { Injectable, NotFoundException } from "@nestjs/common";
import { Prisma } from "@prisma/client";
import { PrismaService } from "../prisma/prisma.service";
import { PaginationDto } from "../common/dto/pagination.dto";
import {
createPaginationMeta,
extractSearchTokens,
normalizeSearchText,
calculateRelevanceScore,
} from "../common/utils/search.utils";
export interface BlogFilterDto extends PaginationDto {
categoryId?: string;
categorySlug?: string;
tagSlug?: string;
featured?: boolean | string;
@@ -20,6 +27,7 @@ export class BlogsService {
limit = 10,
sortBy = "publishedAt",
sortOrder = "desc",
categoryId,
categorySlug,
tagSlug,
featured,
@@ -32,20 +40,23 @@ export class BlogsService {
OR: [{ publishedAt: null }, { publishedAt: { lte: now } }],
};
if (search) {
const tokens = extractSearchTokens(search);
if (tokens.length > 0) {
whereClause.AND = [
{
OR: [
{ title: { contains: search, mode: "insensitive" } },
{ excerpt: { contains: search, mode: "insensitive" } },
{ content: { contains: search, mode: "insensitive" } },
{ keywords: { contains: search, mode: "insensitive" } },
],
OR: tokens.flatMap((token) => [
{ title: { contains: token, mode: "insensitive" } },
{ excerpt: { contains: token, mode: "insensitive" } },
{ keywords: { contains: token, mode: "insensitive" } },
{ tags: { some: { name: { contains: token, mode: "insensitive" } } } },
]),
},
];
}
if (categorySlug) {
if (categoryId && categoryId !== "ALL") {
whereClause.categoryId = categoryId;
} else if (categorySlug && categorySlug !== "all") {
whereClause.category = { slug: categorySlug };
}
@@ -57,13 +68,15 @@ export class BlogsService {
whereClause.featured = String(featured) === "true";
}
const skip = (Number(page) - 1) * Number(limit);
const safePage = Math.max(1, Number(page) || 1);
const safeLimit = Math.max(1, Number(limit) || 10);
const skip = (safePage - 1) * safeLimit;
const [data, total] = await Promise.all([
const [rawBlogs, total] = await Promise.all([
this.prisma.blog.findMany({
where: whereClause,
skip,
take: Number(limit),
skip: tokens.length > 0 ? undefined : skip,
take: tokens.length > 0 ? 100 : safeLimit,
orderBy: [
{
[sortBy === "createdAt" ? "createdAt" : "publishedAt"]: sortOrder,
@@ -88,14 +101,30 @@ export class BlogsService {
this.prisma.blog.count({ where: whereClause }),
]);
let data = rawBlogs;
if (tokens.length > 0 && search) {
data = [...rawBlogs]
.map((b) => ({
blog: b,
score: calculateRelevanceScore(
{
title: b.title,
slug: b.slug,
shortDescription: b.excerpt,
tags: b.tags,
},
search,
tokens,
),
}))
.sort((a, b) => b.score - a.score)
.map((item) => item.blog)
.slice(skip, skip + safeLimit);
}
return {
data,
meta: {
total,
page: Number(page),
lastPage: Math.ceil(total / Number(limit)) || 1,
limit: Number(limit),
},
meta: createPaginationMeta(total, safePage, safeLimit),
};
}
@@ -26,6 +26,16 @@ describe("RevalidationService", () => {
expect(service).toBeDefined();
});
it("uses the Next server rather than the nginx API proxy as production fallback", async () => {
delete process.env.FRONTEND_INTERNAL_URL;
delete process.env.FRONTEND_URL;
delete process.env.NEXT_PUBLIC_SITE_URL;
process.env.NODE_ENV = "production";
const fetchSpy = jest.spyOn(global, "fetch").mockResolvedValue({ ok: true } as Response);
await service.revalidate(["blogs"], ["/blog"]);
expect(fetchSpy).toHaveBeenCalledWith("http://frontend_prod:3000/api/revalidate", expect.anything());
});
describe("revalidateTag", () => {
it("should send POST request with tag and secret header and return true on 200", async () => {
const mockFetch = jest.spyOn(global, "fetch" as any).mockResolvedValue({
@@ -111,6 +121,48 @@ describe("RevalidationService", () => {
});
});
describe("revalidateBlog", () => {
it("should trigger all tags and paths for blog slug and return true when all succeed", async () => {
const tagSpy = jest
.spyOn(service, "revalidateTag")
.mockResolvedValue(true);
const pathSpy = jest
.spyOn(service, "revalidatePath")
.mockResolvedValue(true);
const result = await service.revalidateBlog("test-slug");
expect(tagSpy).toHaveBeenCalledWith("blogs");
expect(tagSpy).toHaveBeenCalledWith("home-data");
expect(tagSpy).toHaveBeenCalledWith("blog-test-slug");
expect(pathSpy).toHaveBeenCalledWith("/blog");
expect(pathSpy).toHaveBeenCalledWith("/sitemap.xml");
expect(pathSpy).toHaveBeenCalledWith("/");
expect(pathSpy).toHaveBeenCalledWith("/blog/test-slug");
expect(result).toBe(true);
});
it("should return false when a tag or path revalidation fails rather than swallowing false", async () => {
jest.spyOn(service, "revalidateTag").mockImplementation(async (tag: string) => {
return tag !== "blogs";
});
jest.spyOn(service, "revalidatePath").mockResolvedValue(true);
const result = await service.revalidateBlog("test-slug");
expect(result).toBe(false);
});
it("should catch unexpected revalidation errors and return false", async () => {
jest.spyOn(service, "revalidateTag").mockRejectedValue(new Error("Network disconnected"));
jest.spyOn(service, "revalidatePath").mockResolvedValue(true);
const result = await service.revalidateBlog("test-slug");
expect(result).toBe(false);
});
});
describe("revalidate batch", () => {
it("should send deduplicated tags and paths in one request", async () => {
const mockFetch = jest.spyOn(global, "fetch" as any).mockResolvedValue({ ok: true, status: 200 } as any);
@@ -10,7 +10,7 @@ export class RevalidationService {
process.env.FRONTEND_URL ||
process.env.NEXT_PUBLIC_SITE_URL ||
(process.env.NODE_ENV === "production"
? "http://frontend_prod:8080"
? "http://frontend_prod:3000"
: "http://localhost:3000");
return raw.replace(/\/+$/, "");
}
@@ -135,7 +135,7 @@ export class RevalidationService {
await Promise.allSettled(tasks);
}
async revalidateBlog(slug?: string): Promise<void> {
async revalidateBlog(slug?: string): Promise<boolean> {
const tasks: Promise<boolean>[] = [
this.revalidateTag("blogs"),
this.revalidateTag("home-data"),
@@ -149,7 +149,18 @@ export class RevalidationService {
tasks.push(this.revalidatePath(`/blog/${slug}`));
}
await Promise.allSettled(tasks);
try {
const results = await Promise.allSettled(tasks);
return (
results.length > 0 &&
results.every(
(result) => result.status === "fulfilled" && result.value === true,
)
);
} catch (err: any) {
this.logger.debug(`Revalidation blog skipped or failed: ${err?.message}`);
return false;
}
}
async revalidateSettings(): Promise<void> {
@@ -1,54 +0,0 @@
import { Injectable, Logger } from "@nestjs/common";
@Injectable()
export class HermesClientService {
private readonly logger = new Logger(HermesClientService.name);
private readonly baseUrl: string;
private readonly apiKey: string;
constructor() {
this.baseUrl = process.env.HERMES_GATEWAY_URL || "http://canina-bot:8642";
this.apiKey = process.env.HERMES_API_KEY || process.env.API_SERVER_KEY || "";
}
async checkHealth(): Promise<boolean> {
try {
const res = await fetch(`${this.baseUrl}/v1/health`, {
headers: {
Authorization: `Bearer ${this.apiKey}`,
},
});
return res.status === 200;
} catch (error: any) {
this.logger.error(`Hermes health check failed: ${error.message}`);
return false;
}
}
async triggerEvent(eventName: string, payload: Record<string, any>) {
try {
this.logger.log(`Dispatching event ${eventName} to Hermes Gateway`);
const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
method: "POST",
headers: {
Authorization: `Bearer ${this.apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "hermes-agent",
messages: [
{
role: "user",
content: `[EVENT:${eventName}] ${JSON.stringify(payload)}`,
},
],
}),
});
const data = await res.json();
return { success: true, data };
} catch (error: any) {
this.logger.warn(`Could not dispatch event to Hermes: ${error.message}`);
return { success: false, error: error.message };
}
}
}
@@ -0,0 +1,91 @@
import {
normalizeSearchText,
extractSearchTokens,
calculateRelevanceScore,
createPaginationMeta,
} from "./search.utils";
describe("search.utils", () => {
describe("createPaginationMeta", () => {
it("builds consistent pagination metadata", () => {
const meta = createPaginationMeta(52, 2, 10);
expect(meta).toEqual({
total: 52,
page: 2,
limit: 10,
totalPages: 6,
lastPage: 6,
hasNextPage: true,
hasPrevPage: true,
});
});
it("handles boundary zero and single page counts safely", () => {
const metaZero = createPaginationMeta(0, 1, 10);
expect(metaZero.totalPages).toBe(1);
expect(metaZero.hasNextPage).toBe(false);
expect(metaZero.hasPrevPage).toBe(false);
const metaOne = createPaginationMeta(5, 1, 10);
expect(metaOne.totalPages).toBe(1);
expect(metaOne.hasNextPage).toBe(false);
expect(metaOne.hasPrevPage).toBe(false);
});
});
describe("normalizeSearchText", () => {
it("normalizes Arabic kaf and yeh to Persian equivalents", () => {
expect(normalizeSearchText("قطره قلب كنينای ايران")).toBe("قطره قلب کنینای ایران");
});
it("strips parentheses, diacritics, and half-spaces", () => {
expect(normalizeSearchText("ال-کارنیتین (L-Carnitine) \u200c دارویی")).toBe("ال کارنیتین l carnitine دارویی");
expect(normalizeSearchText("مُکَمِّل")).toBe("مکمل");
});
it("converts Persian digits to English digits", () => {
expect(normalizeSearchText("محصول شماره ۱۲۳")).toBe("محصول شماره 123");
});
});
describe("extractSearchTokens", () => {
it("extracts meaningful tokens and removes stop words", () => {
const tokens = extractSearchTokens("بهترین قطره برای تقویت قلب سگ و گربه");
expect(tokens).toContain("قطره");
expect(tokens).toContain("تقویت");
expect(tokens).toContain("قلب");
expect(tokens).toContain("سگ");
expect(tokens).toContain("گربه");
expect(tokens).not.toContain("برای");
expect(tokens).not.toContain("و");
});
});
describe("calculateRelevanceScore", () => {
it("ranks exact title / ingredient matches far higher than general description mentions", () => {
const herzVital = {
title: "هیرتز ویتال (مکمل تقویت قلب) کنینا",
slug: "canina-herz-vital-100ml",
ingredients: [{ nameFa: "ال-کارنیتین (L-Carnitine)", nameEn: "L-Carnitine" }],
symptoms: [{ symptom: "بیماری قلبی" }],
shortDescription: "حمایت تخصصی از عضله قلب سگ و گربه",
description: "توضیحات مفصل درباره کارکرد قلب و عروق...",
};
const genericProduct = {
title: "پودر ویتامین پلاس سگ",
slug: "canina-vitamin-plus",
ingredients: [{ nameFa: "ویتامین A", nameEn: "Vitamin A" }],
symptoms: [],
shortDescription: "تقویت عمومی بدن",
description: "این مولتی ویتامین برای تمام اندام‌های بدن از جمله قلب، کبد و مفاصل مفید است.",
};
const tokens = extractSearchTokens("ال-کارنیتین قلب");
const scoreHerz = calculateRelevanceScore(herzVital, "ال-کارنیتین قلب", tokens);
const scoreGeneric = calculateRelevanceScore(genericProduct, "ال-کارنیتین قلب", tokens);
expect(scoreHerz).toBeGreaterThan(scoreGeneric * 4);
});
});
});
+251
View File
@@ -0,0 +1,251 @@
export interface PaginationMeta {
total: number;
page: number;
limit: number;
totalPages: number;
lastPage: number;
hasNextPage: boolean;
hasPrevPage: boolean;
}
export function createPaginationMeta(
total: number,
page: number,
limit: number,
): PaginationMeta {
const safeTotal = Math.max(0, Number(total) || 0);
const safeLimit = Math.max(1, Number(limit) || 10);
const safePage = Math.max(1, Number(page) || 1);
const totalPages = Math.ceil(safeTotal / safeLimit) || 1;
return {
total: safeTotal,
page: safePage,
limit: safeLimit,
totalPages,
lastPage: totalPages,
hasNextPage: safePage < totalPages,
hasPrevPage: safePage > 1,
};
}
const PERSIAN_ARABIC_DIGITS: Record<string, string> = {
"۰": "0", "۱": "1", "۲": "2", "۳": "3", "۴": "4",
"۵": "5", "۶": "6", "۷": "7", "۸": "8", "۹": "9",
"٠": "0", "١": "1", "٢": "2", "٣": "3", "٤": "4",
"٥": "5", "٦": "6", "٧": "7", "٨": "8", "٩": "9",
};
export const COMMON_STOP_WORDS = new Set([
"از", "به", "در", "با", "برای", "و", "یا", "که", "این", "آن", "ها", "های",
"تر", "ترین", "روی", "توی", "را", "تا", "بر", "اما", "اگر", "ولی", "یک",
"the", "a", "an", "and", "or", "for", "with", "in", "on", "at", "to", "of",
]);
export const SEARCH_EXPANSION_MAP: Record<string, string[]> = {
"تایورین": ["تورین", "taurine", "taurin"],
"تائورین": ["تورین", "taurine", "taurin"],
"تورین": ["تایورین", "تائورین", "taurine", "taurin"],
"taurine": ["تورین", "تایورین", "تائورین", "taurin"],
"taurin": ["تورین", "تایورین", "تائورین", "taurine"],
"کارنیتین": ["carnitine", "l-carnitine"],
"carnitine": ["کارنیتین", "l-carnitine"],
"گلوکزامین": ["گلوکوزامین", "glucosamine"],
"گلوکوزامین": ["گلوکزامین", "glucosamine"],
"glucosamine": ["گلوکوزامین", "گلوکزامین"],
"امگا": ["omega", "امگا ۳", "سالمون", "salmon"],
"omega": ["امگا", "امگا ۳", "salmon"],
"کندرویتین": ["chondroitin"],
"chondroitin": ["کندرویتین"],
"بیوتین": ["biotin"],
"biotin": ["بیوتین"],
"کلسیم": ["calcium"],
"calcium": ["کلسیم"],
};
/**
* Normalizes Persian and English text by standardizing characters,
* removing diacritics, half-spaces, punctuation, and folding case.
*/
export function normalizeSearchText(text?: string | null): string {
if (!text) return "";
let s = String(text);
// Convert Persian/Arabic digits
s = s.replace(/[۰-۹٠-٩]/g, (ch) => PERSIAN_ARABIC_DIGITS[ch] || ch);
// Normalize Arabic letters to standard Persian/English
s = s
.replace(/[يى]/g, "ی")
.replace(/[ك]/g, "ک")
.replace(/[ة]/g, "ه")
.replace(/[آأإٱ]/g, "ا")
.replace(/[ؤ]/g, "و")
.replace(/[ئ]/g, "ی");
// Remove Arabic/Persian diacritics (fatha, damma, kasra, tanwin, sukun, tashdid)
s = s.replace(/[\u064B-\u065F\u0670]/g, "");
// Replace half-space, non-breaking space, parentheses, brackets, quotes, punctuation with single space
s = s.replace(/[\u200B-\u200D\uFEFF\u00A0\u200E\u200F_~`!@#$%^&*()+=[\]{}|\\;:'",.<>/?،؛؟]/g, " ");
// Collapse hyphens surrounded by spaces or replace hyphen with space
s = s.replace(/-/g, " ");
// Lowercase & collapse whitespace
return s.toLowerCase().replace(/\s+/g, " ").trim();
}
/**
* Extracts meaningful tokens from a query, eliminating stop words
* unless the entire query only consists of stop words.
*/
export function extractSearchTokens(rawQuery?: string | null): string[] {
const normalized = normalizeSearchText(rawQuery);
if (!normalized) return [];
const rawTokens = normalized.split(" ").filter((t) => t.length > 0);
if (rawTokens.length === 0) return [];
// Filter out stop words
const meaningful = rawTokens.filter(
(t) => !COMMON_STOP_WORDS.has(t) && t.length >= 2,
);
// If filtering left nothing, return original non-empty tokens
const baseTokens = meaningful.length > 0 ? meaningful : rawTokens;
// Expand with domain aliases (e.g. تائورین <-> تورین <-> taurine)
const expanded = new Set<string>(baseTokens);
for (const token of baseTokens) {
const directAliases =
SEARCH_EXPANSION_MAP[token] ||
SEARCH_EXPANSION_MAP[token.toLowerCase()] ||
SEARCH_EXPANSION_MAP[normalizeSearchText(token)];
if (directAliases) {
for (const alias of directAliases) {
expanded.add(normalizeSearchText(alias));
}
}
}
return Array.from(expanded).filter((t) => t.length >= 2);
}
export interface SearchScoreItem {
artNo?: string | null;
barcode?: string | null;
slug?: string | null;
title?: string | null;
shortDescription?: string | null;
description?: string | null;
tags?: Array<{ name?: string | null } | string> | null;
ingredients?: Array<
| { ingredient?: string | null; nameFa?: string | null; nameEn?: string | null }
| string
> | null;
symptoms?: Array<{ symptom?: string | null } | string> | null;
}
/**
* Calculates a relevance score for a product or blog item against search tokens.
*/
export function calculateRelevanceScore(
item: SearchScoreItem,
rawQuery: string,
tokens: string[],
): number {
if (!rawQuery || tokens.length === 0) return 0;
const normalizedQuery = normalizeSearchText(rawQuery);
const normalizedTitle = normalizeSearchText(item.title);
const normalizedArtNo = normalizeSearchText(item.artNo);
const normalizedBarcode = normalizeSearchText(item.barcode);
const normalizedSlug = normalizeSearchText(item.slug);
let score = 0;
// Exact matches get massive priority
if (normalizedArtNo && normalizedArtNo === normalizedQuery) score += 200;
if (normalizedBarcode && normalizedBarcode === normalizedQuery) score += 180;
if (normalizedTitle && normalizedTitle === normalizedQuery) score += 150;
if (normalizedSlug && normalizedSlug === normalizedQuery) score += 140;
// Title starts with full query
if (normalizedTitle && normalizedTitle.startsWith(normalizedQuery)) score += 80;
// Title contains exact full query phrase
if (normalizedTitle && normalizedTitle.includes(normalizedQuery)) score += 60;
// Token level matching in title (highest relevance)
const titleTokens = normalizedTitle.split(" ");
for (const token of tokens) {
if (titleTokens.includes(token)) {
score += 35;
} else if (normalizedTitle.includes(token)) {
score += 20;
}
}
// Ingredient / scientific terms matching
if (item.ingredients && Array.isArray(item.ingredients)) {
for (const ing of item.ingredients) {
let ingName = "";
if (typeof ing === "string") {
ingName = ing;
} else if (ing) {
ingName = `${ing.ingredient || ""} ${ing.nameFa || ""} ${ing.nameEn || ""}`.trim();
}
const normIng = normalizeSearchText(ingName);
if (normIng.includes(normalizedQuery)) score += 40;
for (const token of tokens) {
if (normIng.includes(token)) score += 15;
}
}
}
// Symptoms matching
if (item.symptoms && Array.isArray(item.symptoms)) {
for (const sym of item.symptoms) {
const symName = typeof sym === "string" ? sym : sym.symptom || "";
const normSym = normalizeSearchText(symName);
if (normSym.includes(normalizedQuery)) score += 30;
for (const token of tokens) {
if (normSym.includes(token)) score += 10;
}
}
}
// Tags matching
if (item.tags && Array.isArray(item.tags)) {
for (const tag of item.tags) {
const tagName = typeof tag === "string" ? tag : tag.name || "";
const normTag = normalizeSearchText(tagName);
if (normTag.includes(normalizedQuery)) score += 25;
for (const token of tokens) {
if (normTag.includes(token)) score += 8;
}
}
}
// Short description matching
const normShort = normalizeSearchText(item.shortDescription);
if (normShort) {
for (const token of tokens) {
if (normShort.includes(token)) score += 5;
}
}
// Long description (low weight, capped so it never overwhelms title/ingredients)
const normDesc = normalizeSearchText(item.description);
if (normDesc) {
let descHits = 0;
for (const token of tokens) {
if (normDesc.includes(token)) descHits += 1;
}
score += Math.min(descHits * 2, 6);
}
return score;
}
@@ -1,149 +0,0 @@
import { HermesIntegrationService } from './hermes-integration.service';
import { HermesAdapter } from './hermes.adapter';
describe('backend-owned runtime authorization', () => {
const ctx = { subject: 'admin', profiles: ['seo'] };
const make = (allow = true, enabled = false) => {
const fetcher = jest
.fn()
.mockResolvedValue(
new Response(
JSON.stringify({ id: 'j', profile: 'seo', enabled: false }),
),
);
const authorize = jest.fn().mockResolvedValue(allow);
return {
fetcher,
authorize,
s: new HermesIntegrationService(
new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
),
{ authorize },
enabled,
),
};
};
it('denies missing principal, missing profile, denied policy before upstream IO', async () => {
const { s, fetcher } = make(false);
await expect(s.pauseCron(ctx, 'seo', 'j')).rejects.toMatchObject({
code: 'FORBIDDEN',
});
await expect(
s.pauseCron({ ...ctx, subject: '' }, 'seo', 'j'),
).rejects.toMatchObject({ code: 'FORBIDDEN' });
await expect(s.pauseCron(ctx, 'dev', 'j')).rejects.toMatchObject({
code: 'FORBIDDEN',
});
expect(fetcher).not.toHaveBeenCalled();
});
it('allows authorized pause but leaves resume disabled by default', async () => {
const { s, fetcher, authorize } = make();
await s.pauseCron(ctx, 'seo', 'j');
expect(authorize).toHaveBeenCalledWith(ctx, 'cron.pause', 'seo');
await expect(s.resumeCron(ctx, 'seo', 'j')).rejects.toMatchObject({
code: 'FORBIDDEN',
});
expect(fetcher).toHaveBeenCalledTimes(1);
});
it('fails closed on all execution and never forwards arbitrary events or RPC', async () => {
const { s, fetcher } = make();
expect(s.capabilities()).toMatchObject({
chat: false,
control: false,
eventDispatch: false,
cronResume: false,
});
await expect(s.chat(ctx, 'seo', 'hello')).rejects.toMatchObject({
code: 'UNSUPPORTED',
});
await expect(s.control(ctx, 'seo', 'interrupt')).rejects.toMatchObject({
code: 'UNSUPPORTED',
});
await expect(
s.dispatchEvent(ctx, 'seo', { type: 'order.created' }),
).rejects.toMatchObject({ code: 'FORBIDDEN' });
expect(fetcher).not.toHaveBeenCalled();
});
it('fails closed when authorization provider throws', async () => {
const a = new HermesAdapter({
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
});
const s = new HermesIntegrationService(a, {
authorize: () => Promise.reject(new Error('private')),
});
await expect(s.health(ctx)).rejects.toMatchObject({ code: 'FORBIDDEN' });
});
});
it('checks every read capability and filters the global profile roster', async () => {
const fetcher = jest.fn().mockImplementation((input: URL) => {
const payloads: Record<string, unknown> = {
'/api/health': {
ok: true,
version: 'x',
commit: 'x',
auth_required: true,
},
'/api/status': {
version: 'x',
gateway_running: false,
gateway_state: null,
overall: 'degraded',
active_agents: 0,
},
'/api/profiles': {
profiles: [
{ name: 'seo', is_default: false, gateway_running: false },
{ name: 'dev', is_default: false, gateway_running: false },
],
},
'/api/model/info': {
model: 'm',
provider: 'p',
effective_context_length: 1,
},
'/api/model/options': { providers: [] },
'/api/analytics/usage': {
period_days: 30,
totals: {
total_input: 0,
total_output: 0,
total_sessions: 0,
total_estimated_cost: 0,
},
},
'/api/sessions': { sessions: [], total: 0 },
'/api/cron/jobs': [],
};
return Promise.resolve(
new Response(JSON.stringify(payloads[input.pathname])),
);
});
const authorize = jest.fn().mockResolvedValue(true);
const s = new HermesIntegrationService(
new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
),
{ authorize },
);
const p = { subject: 'verified', profiles: ['seo'] };
await s.health(p);
await s.status(p, 'seo');
expect(await s.profiles(p)).toHaveLength(1);
await s.modelInfo(p, 'seo');
await s.modelOptions(p, 'seo');
await s.usage(p, 'seo');
await s.sessions(p, 'seo');
await s.crons(p, 'seo');
expect(authorize).toHaveBeenCalledTimes(8);
expect(authorize.mock.calls.every((c) => c[1] === 'runtime.read')).toBe(true);
});
@@ -1,126 +0,0 @@
import { HermesAdapter, HermesError, Json } from './hermes.adapter';
/** Context MUST be constructed from verified backend identity, never request bodies. */
export interface RuntimePrincipal {
subject: string;
profiles: readonly string[];
}
export type RuntimePermission =
| 'runtime.read'
| 'cron.pause'
| 'cron.resume'
| 'chat'
| 'control'
| 'event.dispatch';
export interface RuntimeAuthorizer {
authorize(
principal: RuntimePrincipal,
permission: RuntimePermission,
profile?: string,
): Promise<boolean>;
}
/** No controller or socket is registered: only the backend gatekeeper can call this seam. */
export class HermesIntegrationService {
constructor(
private readonly adapter: HermesAdapter,
private readonly policy: RuntimeAuthorizer,
private readonly resumeEnabled = false,
) {}
capabilities() {
return {
inventory: true,
cronPause: true,
cronResume: this.resumeEnabled,
chat: false,
control: false,
eventDispatch: false,
} as const;
}
private async check(
principal: RuntimePrincipal,
permission: RuntimePermission,
profile?: string,
): Promise<void> {
if (
!principal?.subject ||
!Array.isArray(principal.profiles) ||
(profile && !principal.profiles.includes(profile))
)
throw new HermesError('FORBIDDEN');
try {
if (
(await this.policy.authorize(principal, permission, profile)) !== true
)
throw new HermesError('FORBIDDEN');
} catch {
throw new HermesError('FORBIDDEN');
}
}
async health(p: RuntimePrincipal) {
await this.check(p, 'runtime.read');
return this.adapter.health();
}
async status(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.status(profile);
}
async profiles(p: RuntimePrincipal) {
await this.check(p, 'runtime.read');
return (await this.adapter.profiles()).filter(
(r) => typeof r.name === 'string' && p.profiles.includes(r.name),
);
}
async modelInfo(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.modelInfo(profile);
}
async modelOptions(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.modelOptions(profile);
}
async usage(p: RuntimePrincipal, profile: string, days = 30) {
await this.check(p, 'runtime.read', profile);
return this.adapter.usage(profile, days);
}
async sessions(p: RuntimePrincipal, profile: string, limit = 20, offset = 0) {
await this.check(p, 'runtime.read', profile);
return this.adapter.sessions(profile, limit, offset);
}
async crons(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.crons(profile);
}
async pauseCron(p: RuntimePrincipal, profile: string, id: string) {
await this.check(p, 'cron.pause', profile);
return this.adapter.pauseCron(profile, id);
}
async resumeCron(p: RuntimePrincipal, profile: string, id: string) {
await this.check(p, 'cron.resume', profile);
if (!this.resumeEnabled) throw new HermesError('FORBIDDEN');
return this.adapter.resumeCron(profile, id);
}
async chat(
p: RuntimePrincipal,
profile: string,
_text: string,
): Promise<never> {
await this.check(p, 'chat', profile);
throw new HermesError('UNSUPPORTED');
}
async control(
p: RuntimePrincipal,
profile: string,
_command: 'interrupt',
): Promise<never> {
await this.check(p, 'control', profile);
throw new HermesError('UNSUPPORTED');
}
/** Disabled independently of policy: no unreviewed event may become an agent prompt. */
async dispatchEvent(
p: RuntimePrincipal,
profile: string,
_event: Json,
): Promise<never> {
await this.check(p, 'event.dispatch', profile);
throw new HermesError('FORBIDDEN');
}
}
@@ -1,26 +0,0 @@
import { Test } from '@nestjs/testing';
import { HermesManagementModule } from './hermes-management.module';
import { HermesIntegrationService } from './hermes-integration.service';
it('requires explicit registration and denies by default without publishing controllers', async () => {
const module = await Test.createTestingModule({
imports: [
HermesManagementModule.register({
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
}),
],
}).compile();
const service = module.get(HermesIntegrationService);
await expect(
service.health({ subject: 'admin', profiles: [] }),
).rejects.toMatchObject({ code: 'FORBIDDEN' });
await module.close();
});
it('registers backend credential broker without acquiring credentials before policy authorization', async () => {
const credentials=jest.fn().mockResolvedValue({username:'backend',password:'test-only'});
const module=await Test.createTestingModule({imports:[HermesManagementModule.registerAuthenticated(credentials)]}).compile();
await expect(module.get(HermesIntegrationService).health({subject:'admin',profiles:[]})).rejects.toMatchObject({code:'FORBIDDEN'});
expect(credentials).not.toHaveBeenCalled();
await module.close();
});
@@ -1,36 +0,0 @@
import { DynamicModule, Module } from '@nestjs/common';
import { HermesSessionBroker } from './hermes-session-broker';
import { HermesAdapter, HermesConfig } from './hermes.adapter';
import {
HermesIntegrationService,
RuntimeAuthorizer,
} from './hermes-integration.service';
@Module({})
export class HermesManagementModule {
static registerAuthenticated(
credentials: () => Promise<{username:string;password:string}>,
policy: RuntimeAuthorizer = {authorize: async () => false},
): DynamicModule {
const broker = new HermesSessionBroker(credentials);
return this.register({origin:'http://canina-hermes-inventory:9119',token:()=>broker.token()},policy);
}
static register(
config: HermesConfig,
policy: RuntimeAuthorizer = { authorize: () => Promise.resolve(false) },
): DynamicModule {
return {
module: HermesManagementModule,
providers: [
{ provide: HermesAdapter, useFactory: () => new HermesAdapter(config) },
{
provide: HermesIntegrationService,
useFactory: (adapter: HermesAdapter) =>
new HermesIntegrationService(adapter, policy, false),
inject: [HermesAdapter],
},
],
exports: [HermesIntegrationService],
};
}
}
@@ -1,53 +0,0 @@
import { afterEach } from '@jest/globals';
import { HermesSessionBroker } from './hermes-session-broker';
const credentials = async () => ({username:'backend',password:'test-only'});
const response = () => new Response('{"ok":true}', {headers:{'set-cookie':'hermes_session_at=verified-test-token; Max-Age=60; Path=/; HttpOnly'}});
describe('server-only Hermes session broker',()=>{
afterEach(()=>{jest.useRealTimers();});
it('renews expired cached access without retaining the refresh cookie',async()=>{
jest.useFakeTimers();
const fetcher=jest.fn().mockImplementation(async()=>response());
const broker=new HermesSessionBroker(credentials,fetcher);
await broker.token();
await jest.advanceTimersByTimeAsync(51000);
await broker.token();
expect(fetcher).toHaveBeenCalledTimes(2);
});
it('bounds credential waits and releases the pending login after timeout',async()=>{
jest.useFakeTimers();
const load=jest.fn().mockImplementationOnce(()=>new Promise(()=>{})).mockImplementation(credentials);
const broker=new HermesSessionBroker(load,jest.fn().mockImplementation(async()=>response()));
const result=expect(broker.token()).rejects.toMatchObject({message:'Hermes unavailable'});
await jest.advanceTimersByTimeAsync(5001);await result;
expect(await broker.token()).toBe('verified-test-token');
});
it('rejects oversized response bodies and short cookie lifetimes',async()=>{
for(const res of [new Response('x'.repeat(4097)),new Response('{"ok":true}',{headers:{'set-cookie':'hermes_session_at=token; Max-Age=1; Path=/'}})]){
await expect(new HermesSessionBroker(credentials,jest.fn().mockResolvedValue(res)).token()).rejects.toMatchObject({message:'Hermes auth_required'});
}
});
it('coalesces login, caches only access token and uses installed password-login contract',async()=>{
const fetcher=jest.fn().mockImplementation(async()=>response());
const broker=new HermesSessionBroker(credentials,fetcher);
expect(await Promise.all([broker.token(),broker.token()])).toEqual(['verified-test-token','verified-test-token']);
expect(await broker.token()).toBe('verified-test-token');
expect(fetcher).toHaveBeenCalledTimes(1);
const [url,options]=fetcher.mock.calls[0];
expect(url).toBe('http://canina-hermes-inventory:9119/auth/password-login');
expect(JSON.parse(options.body)).toEqual({provider:'basic',username:'backend',password:'test-only'});
expect(options.redirect).toBe('error');
});
it('fails closed without echoing credentials, response bodies or provider errors',async()=>{
for(const result of [new Response('private secret',{status:401}),new Response('{"ok":true}'),new Response('{"ok":false}',{headers:{'set-cookie':'hermes_session_at=bad; Max-Age=60'}})]){
const broker=new HermesSessionBroker(credentials,jest.fn().mockResolvedValue(result));
await expect(broker.token()).rejects.toMatchObject({message:'Hermes auth_required'});
}
});
it('does not cache failures and permits a later successful login',async()=>{
const fetcher=jest.fn().mockRejectedValueOnce(new Error('sensitive upstream')).mockImplementationOnce(async()=>response());
const broker=new HermesSessionBroker(credentials,fetcher);
await expect(broker.token()).rejects.toMatchObject({message:'Hermes unavailable'});
expect(await broker.token()).toBe('verified-test-token');
});
});
@@ -1,36 +0,0 @@
import { HermesError } from './hermes.adapter';
export class HermesSessionBroker {
private cached: {token:string;until:number}|undefined;
private pending: Promise<string>|undefined;
constructor(private readonly credentials:()=>Promise<{username:string;password:string}>,private readonly fetcher:typeof fetch=fetch) {}
token():Promise<string>{
if(this.cached && this.cached.until>Date.now()) return Promise.resolve(this.cached.token);
if(this.pending) return this.pending;
this.pending=this.login().finally(()=>{this.pending=undefined;});
return this.pending;
}
private async login():Promise<string>{
const controller=new AbortController();
const timer=setTimeout(()=>controller.abort(),5000);
try{
const creds=await Promise.race([this.credentials(),new Promise<never>((_,reject)=>controller.signal.addEventListener('abort',()=>reject(new HermesError('UNAVAILABLE')),{once:true}))]);
if(!creds.username || !creds.password) throw new HermesError('AUTH_REQUIRED');
const response=await this.fetcher('http://canina-hermes-inventory:9119/auth/password-login',{method:'POST',redirect:'error',signal:controller.signal,headers:{'Content-Type':'application/json'},body:JSON.stringify({provider:'basic',...creds})});
if(!response.ok) throw new HermesError('AUTH_REQUIRED');
const reader=response.body?.getReader();
if(!reader) throw new HermesError('AUTH_REQUIRED');
const chunks:Uint8Array[]=[];let size=0;
try{for(;;){const {done,value}=await reader.read();if(done)break;size+=value.byteLength;if(size>4096)throw new HermesError('AUTH_REQUIRED');chunks.push(value);}}finally{await reader.cancel().catch(()=>undefined);}
const body=JSON.parse(Buffer.concat(chunks).toString('utf8')) as {ok?:unknown};
const cookies=response.headers.getSetCookie();
const cookie=cookies.find(c=>c.startsWith('hermes_session_at='));
const tokenMatch=cookie?.match(/^hermes_session_at=(?:"([A-Za-z0-9_.=-]+)"|([A-Za-z0-9_.=-]+));/);
const token=tokenMatch?.[1]??tokenMatch?.[2];
const age=Number(cookie?.match(/(?:^|;)\s*Max-Age=(\d+)/i)?.[1]);
if(body.ok!==true || !token || !Number.isSafeInteger(age) || age<30)throw new HermesError('AUTH_REQUIRED');
this.cached={token,until:Date.now()+Math.min(age-10,300)*1000};
return token;
}catch(error){if(error instanceof HermesError)throw error;throw new HermesError('UNAVAILABLE');}
finally{clearTimeout(timer);}
}
}
@@ -1,246 +0,0 @@
import { HermesAdapter, HermesError } from './hermes.adapter';
const health = {
ok: true,
version: '0.13',
commit: 'abc',
auth_required: true,
};
describe('installed Hermes health contract', () => {
it('uses pinned internal origin, bearer only server side and strips extra fields', async () => {
const fetcher = jest
.fn()
.mockResolvedValue(
new Response(
JSON.stringify({ ...health, token: 'never', home: '/secret' }),
),
);
const adapter = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('private'),
},
fetcher,
);
expect(await adapter.health()).toEqual(health);
expect(fetcher.mock.calls[0][0].toString()).toBe(
'http://canina-hermes:9119/api/health',
);
expect(fetcher.mock.calls[0][1].headers.Authorization).toBe(
'Bearer private',
);
expect(fetcher.mock.calls[0][1].redirect).toBe('error');
});
it('refuses a runtime reporting that authentication is disabled', async () => {
const adapter = new HermesAdapter({origin:'http://canina-hermes:9119',token:async()=> 'private'},
jest.fn().mockResolvedValue(new Response(JSON.stringify({...health,auth_required:false}))));
await expect(adapter.health()).rejects.toMatchObject({code:'AUTH_REQUIRED'});
});
it('fails closed for bad origin, auth errors, malformed contract and oversized bodies', async () => {
expect(
() =>
new HermesAdapter({
origin: 'https://evil.test',
token: () => Promise.resolve(''),
}),
).toThrow(HermesError);
for (const response of [
new Response('private', { status: 401 }),
new Response('{}'),
new Response('x'.repeat(262145)),
]) {
const a = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
jest.fn().mockResolvedValue(response),
);
await expect(a.health()).rejects.toBeInstanceOf(HermesError);
}
});
});
describe('bounded profile-scoped REST inventory', () => {
const create = (payload: unknown) => {
const fetcher = jest
.fn()
.mockResolvedValue(new Response(JSON.stringify(payload)));
return {
a: new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
),
fetcher,
};
};
it('projects status, profiles, models and usage without raw paths, prompts or credentials', async () => {
expect(
await create({
version: 'x',
gateway_running: false,
gateway_state: null,
overall: 'degraded',
active_agents: 0,
}).a.status('seo'),
).toEqual({
version: 'x',
gateway_running: false,
gateway_state: null,
overall: 'degraded',
active_agents: 0,
});
expect(
await create({
profiles: [
{
name: 'seo',
is_default: false,
gateway_running: false,
path: '/private',
description: 'token=secret',
},
],
}).a.profiles(),
).toEqual([{ name: 'seo', is_default: false, gateway_running: false }]);
expect(
await create({
model: 'm',
provider: 'p',
effective_context_length: 0,
api_key: 'secret',
}).a.modelInfo('seo'),
).toEqual({ model: 'm', provider: 'p', effective_context_length: 0 });
expect(
await create({
providers: [
{ slug: 'p', name: 'Provider', models: ['m'], api_key: 'secret' },
],
current: { api_key: 'secret' },
}).a.modelOptions('seo'),
).toEqual([{ slug: 'p', name: 'Provider', models: ['m'] }]);
expect(
await create({
period_days: 7,
totals: {
total_input: 0,
total_output: 2,
total_sessions: 1,
total_estimated_cost: 0,
},
tools: { secret: 1 },
}).a.usage('seo', 7),
).toEqual({
period_days: 7,
totals: {
total_input: 0,
total_output: 2,
total_sessions: 1,
total_estimated_cost: 0,
},
});
});
it('uses scoped list contract and rejects unbounded queries or profile escape', async () => {
const { a, fetcher } = create({
sessions: [
{
id: 's',
profile: 'seo',
is_active: false,
source: 'cron',
title: 'secret',
},
],
total: 1,
storage: {},
});
expect(await a.sessions('seo', 20, 0)).toEqual({
sessions: [{ id: 's', profile: 'seo', is_active: false, source: 'cron' }],
total: 1,
});
expect(fetcher.mock.calls[0][0].pathname).toBe('/api/sessions');
expect(fetcher.mock.calls[0][0].searchParams.get('full')).toBe('false');
await expect(a.sessions('../escape', 20, 0)).rejects.toThrow();
await expect(a.sessions('seo', 101, 0)).rejects.toThrow();
await expect(a.usage('seo', 366)).rejects.toThrow();
await expect(
create({
sessions: [],
total: 0,
storage: { seo: 'corrupt' },
}).a.sessions('seo'),
).rejects.toThrow();
await expect(
create({
sessions: [
{ id: 's', profile: 'dev', source: 'cli', is_active: false },
],
total: 1,
}).a.sessions('seo'),
).rejects.toThrow();
});
it('lists scoped cron array; pause/resume use exact POST routes without triggers', async () => {
expect(
await create([
{ id: 'j', profile: 'seo', enabled: false, prompt: 'secret' },
]).a.crons('seo'),
).toEqual([{ id: 'j', profile: 'seo', enabled: false }]);
const { a, fetcher } = create({ id: 'j', profile: 'seo', enabled: false });
expect(await a.pauseCron('seo', 'j')).toEqual({
id: 'j',
profile: 'seo',
enabled: false,
});
expect(fetcher.mock.calls[0][0].pathname).toBe('/api/cron/jobs/j/pause');
expect(fetcher.mock.calls[0][1].method).toBe('POST');
const resume = create({ id: 'j', profile: 'seo', enabled: true });
await resume.a.resumeCron('seo', 'j');
expect(resume.fetcher.mock.calls[0][0].pathname).toBe(
'/api/cron/jobs/j/resume',
);
await expect(a.pauseCron('seo', '../trigger')).rejects.toThrow();
});
});
describe('resource budgets and safe errors', () => {
it('does not leak upstream errors or tokens and limits credential waits', async () => {
jest.useFakeTimers();
const a = new HermesAdapter({
origin: 'http://canina-hermes:9119',
token: () => new Promise(() => {}),
});
const result = expect(a.health()).rejects.toMatchObject({
code: 'UNAVAILABLE',
message: 'Hermes unavailable',
});
await jest.advanceTimersByTimeAsync(5001);
await result;
jest.useRealTimers();
});
it('caps concurrency before upstream IO', async () => {
const resolvers: ((r: Response) => void)[] = [];
const fetcher = jest.fn(
() =>
new Promise<Response>((r) => {
resolvers.push(r);
}),
);
const a = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
);
const calls = Array.from({ length: 4 }, () => a.health());
const denied = expect(a.health()).rejects.toMatchObject({ code: 'LIMIT' });
await Promise.resolve();
await Promise.resolve();
resolvers.forEach((r) => r(new Response(JSON.stringify(health))));
await denied;
await Promise.all(calls);
});
});
@@ -1,342 +0,0 @@
export type Json =
| null
| boolean
| number
| string
| Json[]
| { [key: string]: Json };
export type Row = Record<string, Json>;
export type HermesErrorCode =
| 'CONFIGURATION'
| 'AUTH_REQUIRED'
| 'UNAVAILABLE'
| 'CONTRACT'
| 'LIMIT'
| 'FORBIDDEN'
| 'UNSUPPORTED';
export class HermesError extends Error {
constructor(readonly code: HermesErrorCode) {
super(`Hermes ${code.toLowerCase()}`);
}
}
export interface HermesConfig {
origin: string;
token: () => Promise<string>;
}
export interface Health {
ok: boolean;
version: string;
commit: string;
auth_required: boolean;
provenance?: Row;
}
function object(value: unknown): Record<string, unknown> {
if (!value || typeof value !== 'object' || Array.isArray(value))
throw new HermesError('CONTRACT');
return value as Record<string, unknown>;
}
function fields(
value: unknown,
schema: Record<string, 'string' | 'boolean' | 'number'>,
): Row {
const source = object(value);
const result: Row = {};
for (const [key, type] of Object.entries(schema)) {
if (
typeof source[key] !== type ||
(type === 'number' && !Number.isFinite(source[key]))
)
throw new HermesError('CONTRACT');
result[key] = source[key] as Json;
}
return result;
}
export class HermesAdapter {
private readonly origin: string;
private inflight = 0;
constructor(
private readonly config: HermesConfig,
private readonly fetcher: typeof fetch = fetch,
) {
if (
![
'http://canina-hermes:9119',
'http://canina-hermes-inventory:9119',
].includes(config.origin)
)
throw new HermesError('CONFIGURATION');
this.origin = config.origin;
}
private async request(
path: string,
profile?: string,
method = 'GET',
params: Record<string, string> = {},
): Promise<unknown> {
if (
profile !== undefined &&
!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(profile)
)
throw new HermesError('FORBIDDEN');
const url = new URL(path, this.origin);
if (profile) url.searchParams.set('profile', profile);
for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
if (this.inflight >= 4) throw new HermesError('LIMIT');
this.inflight++;
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 5000);
try {
const token = await Promise.race([
this.config.token(),
new Promise<never>((_, reject) =>
controller.signal.addEventListener(
'abort',
() => reject(new HermesError('UNAVAILABLE')),
{ once: true },
),
),
]);
if (!token || /[\r\n]/.test(token))
throw new HermesError('AUTH_REQUIRED');
const response = await this.fetcher(url, {
method,
headers: {
Authorization: `Bearer ${token}`,
Accept: 'application/json',
},
signal: controller.signal,
redirect: 'error',
});
if ([401, 403].includes(response.status))
throw new HermesError('AUTH_REQUIRED');
if (response.status === 404) throw new HermesError('UNSUPPORTED');
if (!response.ok) throw new HermesError('UNAVAILABLE');
if (Number(response.headers.get('content-length')) > 262144)
throw new HermesError('LIMIT');
const reader = response.body?.getReader();
if (!reader) throw new HermesError('CONTRACT');
let bytes = 0;
const chunks: Uint8Array[] = [];
try {
for (;;) {
const { done, value } = await reader.read();
if (done) break;
bytes += value.byteLength;
if (bytes > 262144) throw new HermesError('LIMIT');
chunks.push(value);
}
} finally {
await reader.cancel().catch(() => undefined);
}
const data: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'));
if (this.origin === 'http://canina-hermes-inventory:9119') {
const rows = Array.isArray(data) ? data : [data];
for (const row of rows) provenance(row, true);
}
return data;
} catch (error) {
if (error instanceof HermesError) throw error;
throw new HermesError('UNAVAILABLE');
} finally {
clearTimeout(timer);
this.inflight--;
}
}
async health(): Promise<Health> {
const raw = await this.request('/api/health');
const health = {
...fields(raw, {
ok: 'boolean',
version: 'string',
commit: 'string',
auth_required: 'boolean',
}),
...provenance(raw),
} as unknown as Health;
if (!health.auth_required) throw new HermesError('AUTH_REQUIRED');
return health;
}
async status(profile: string): Promise<Row> {
const raw = object(await this.request('/api/status', profile));
const row = fields(raw, {
version: 'string',
gateway_running: 'boolean',
overall: 'string',
active_agents: 'number',
});
if (raw.gateway_state !== null && typeof raw.gateway_state !== 'string')
throw new HermesError('CONTRACT');
return {
...row,
gateway_state: raw.gateway_state as Json,
...provenance(raw),
...(raw.provenance
? {
gateway_running: false,
active_agents: 0,
gateway_state: null,
overall: 'unknown',
liveGatewayState: 'unknown',
liveActiveAgents: null,
}
: {}),
};
}
async profiles(): Promise<Row[]> {
return list(object(await this.request('/api/profiles')).profiles).map(
(r) => ({
...fields(r, {
name: 'string',
is_default: 'boolean',
gateway_running: 'boolean',
}),
...provenance(r),
...(object(r).provenance
? { gateway_running: false, liveGatewayState: 'unknown' }
: {}),
}),
);
}
async modelInfo(profile: string): Promise<Row> {
const raw = await this.request('/api/model/info', profile);
return {
...fields(raw, {
model: 'string',
provider: 'string',
effective_context_length: 'number',
}),
...provenance(raw),
};
}
async modelOptions(profile: string): Promise<Row[]> {
return list(
object(await this.request('/api/model/options', profile)).providers,
).map((r) => {
const row = fields(r, { slug: 'string', name: 'string' });
const models = list(object(r).models);
if (models.some((m) => typeof m !== 'string'))
throw new HermesError('CONTRACT');
return { ...row, models: models as string[] };
});
}
async usage(profile: string, days = 30): Promise<Row> {
bound(days, 1, 365);
const raw = object(
await this.request('/api/analytics/usage', profile, 'GET', {
days: String(days),
}),
);
return {
...fields(raw, { period_days: 'number' }),
...provenance(raw),
totals: fields(raw.totals, {
total_input: 'number',
total_output: 'number',
total_sessions: 'number',
total_estimated_cost: 'number',
}),
};
}
async sessions(profile: string, limit = 20, offset = 0): Promise<Row> {
bound(limit, 1, 100);
bound(offset, 0, 10000);
const raw = object(
await this.request('/api/sessions', profile, 'GET', {
limit: String(limit),
offset: String(offset),
full: 'false',
order: 'recent',
}),
);
if (raw.storage && Object.keys(object(raw.storage)).length)
throw new HermesError('UNAVAILABLE');
const rows = list(raw.sessions).map((r) =>
scoped(r, profile, {
id: 'string',
profile: 'string',
source: 'string',
is_active: 'boolean',
}),
);
return {
...fields(raw, { total: 'number' }),
sessions: rows,
...provenance(raw),
};
}
async crons(profile: string): Promise<Row[]> {
return list(await this.request('/api/cron/jobs', profile)).map((r) =>
scoped(r, profile, {
id: 'string',
profile: 'string',
enabled: 'boolean',
}),
);
}
private async cron(
profile: string,
id: string,
action: 'pause' | 'resume',
): Promise<Row> {
if (!/^[a-zA-Z0-9_-]{1,128}$/.test(id)) throw new HermesError('FORBIDDEN');
return scoped(
await this.request(`/api/cron/jobs/${id}/${action}`, profile, 'POST'),
profile,
{ id: 'string', profile: 'string', enabled: 'boolean' },
);
}
pauseCron(profile: string, id: string): Promise<Row> {
return this.cron(profile, id, 'pause');
}
resumeCron(profile: string, id: string): Promise<Row> {
return this.cron(profile, id, 'resume');
}
}
function list(value: unknown): unknown[] {
if (!Array.isArray(value) || value.length > 1000)
throw new HermesError('CONTRACT');
return value;
}
function bound(value: number, min: number, max: number): void {
if (!Number.isInteger(value) || value < min || value > max)
throw new HermesError('LIMIT');
}
function scoped(
value: unknown,
profile: string,
schema: Record<string, 'string' | 'boolean' | 'number'>,
): Row {
const row = fields(value, schema);
if (row.profile !== profile) throw new HermesError('FORBIDDEN');
return { ...row, ...provenance(value) };
}
/** Snapshot provenance is mandatory on inventory origin; never synthesize a capture time. */
function provenance(value: unknown, required = false): Row {
const raw = object(value);
if (!raw.provenance && !required) return {};
const p = object(raw.provenance);
if (
p.source !== 'snapshot' ||
p.liveProcess !== 'unknown' ||
typeof p.capturedAt !== 'string' ||
!p.capturedAt.endsWith('Z') ||
!Number.isFinite(Date.parse(p.capturedAt)) ||
Date.parse(p.capturedAt) > Date.now() ||
typeof p.ageSeconds !== 'number' ||
!Number.isInteger(p.ageSeconds) ||
p.ageSeconds < 0 ||
!['fresh', 'stale'].includes(String(p.freshness))
)
throw new HermesError('CONTRACT');
return {
provenance: {
source: 'snapshot',
capturedAt: p.capturedAt,
ageSeconds: p.ageSeconds,
freshness: p.freshness as string,
liveProcess: 'unknown',
},
};
}
@@ -1,50 +0,0 @@
import { createServer } from 'node:http';
import type { AddressInfo } from 'node:net';
import { HermesAdapter } from './hermes.adapter';
it('exercises bounded HTTP transport against an isolated server', async () => {
const seen: string[] = [];
const server = createServer((req, res) => {
seen.push(`${req.method} ${req.url}`);
if (req.headers.authorization !== 'Bearer local-test') {
res.writeHead(401).end();
return;
}
res.setHeader('Content-Type', 'application/json');
res.end(
JSON.stringify({
ok: true,
version: 'test',
commit: 'test',
auth_required: true,
api_key: 'redacted',
}),
);
});
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
try {
const port = (server.address() as AddressInfo).port;
const transport: typeof fetch = (input, init) =>
fetch(
`http://127.0.0.1:${port}${new URL(input instanceof URL ? input.href : typeof input === 'string' ? input : input.url).pathname}`,
init,
);
const adapter = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('local-test'),
},
transport,
);
expect(await adapter.health()).toEqual({
ok: true,
version: 'test',
commit: 'test',
auth_required: true,
});
expect(seen).toEqual(['GET /api/health']);
} finally {
await new Promise<void>((resolve, reject) =>
server.close((e) => (e ? reject(e) : resolve())),
);
}
});
@@ -1,31 +0,0 @@
import { loadRuntimeGrants } from './runtime-read.module';
import { mkdtemp, writeFile, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
describe('reviewed runtime grants file', () => {
it('loads an exact reviewed file and fails closed for malformed grants', async () => {
const dir = await mkdtemp(join(tmpdir(), 'runtime-grants-'));
const file = join(dir, 'grants.json');
try {
await writeFile(file, JSON.stringify({ 'subject-1': ['default'] }));
expect(await loadRuntimeGrants(file, dir)).toEqual({
'subject-1': ['default'],
});
for (const invalid of [
null,
[],
{ 'subject-1': [] },
{ 'subject-1': ['default', 'default'] },
{ 'subject-1': ['../x'] },
{ 'subject-1': [3] },
{ 'subject-1': ['default'], extra: true },
]) {
await writeFile(file, JSON.stringify(invalid));
await expect(loadRuntimeGrants(file, dir)).rejects.toThrow();
}
await expect(loadRuntimeGrants('/etc/passwd')).rejects.toThrow();
} finally {
await rm(dir, { recursive: true });
}
});
});
@@ -1,83 +0,0 @@
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { Strategy, ExtractJwt } from 'passport-jwt';
import passport from 'passport';
import { sign } from 'jsonwebtoken';
import request from 'supertest';
import { RuntimeReadModule } from './runtime-read.module';
import { HermesIntegrationService } from './hermes-integration.service';
describe('runtime HTTP authentication and read contract', () => {
let app: INestApplication;
const health = jest.fn().mockResolvedValue({ ok: true, auth_required: true });
beforeAll(async () => {
passport.use(
'jwt',
new Strategy(
{
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
secretOrKey: 'test-only-http-key',
},
(payload, done) => done(null, { id: payload.sub, role: payload.role }),
),
);
const module = await Test.createTestingModule({
imports: [
PassportModule,
RuntimeReadModule.register({ 'admin-1': ['default'] }),
],
})
.overrideProvider(HermesIntegrationService)
.useValue({ health })
.compile();
app = module.createNestApplication();
await app.init();
});
afterAll(async () => {
await app.close();
passport.unuse('jwt');
});
it('rejects missing and forged credentials before upstream', async () => {
health.mockClear();
await request(app.getHttpServer())
.get('/admin/orchestration/runtime/health')
.expect(401);
await request(app.getHttpServer())
.get('/admin/orchestration/runtime/health')
.set(
'Authorization',
'Bearer ' + sign({ sub: 'admin-1', role: 'Admin' }, 'forged'),
)
.expect(401);
expect(health).not.toHaveBeenCalled();
});
it('accepts verified allowlisted admin but rejects signed ungranted subject', async () => {
await request(app.getHttpServer())
.get('/admin/orchestration/runtime/health')
.set(
'Authorization',
'Bearer ' + sign({ sub: 'other', role: 'Admin' }, 'test-only-http-key'),
)
.expect(403);
const r = await request(app.getHttpServer())
.get('/admin/orchestration/runtime/health')
.set(
'Authorization',
'Bearer ' +
sign({ sub: 'admin-1', role: 'Admin' }, 'test-only-http-key'),
)
.expect(200);
expect(r.body).toEqual({ ok: true, auth_required: true });
expect(r.headers['set-cookie']).toBeUndefined();
});
it('does not register mutation handlers', async () => {
await request(app.getHttpServer())
.post('/admin/orchestration/runtime/schedules')
.set(
'Authorization',
'Bearer ' +
sign({ sub: 'admin-1', role: 'Admin' }, 'test-only-http-key'),
)
.expect(404);
});
});
@@ -1,183 +0,0 @@
import {
Controller,
Get,
Req,
Query,
UseGuards,
Injectable,
ForbiddenException,
ServiceUnavailableException,
HttpException,
} from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import {
HermesIntegrationService,
RuntimePrincipal,
} from './hermes-integration.service';
import { HermesError } from './hermes.adapter';
export interface VerifiedRuntimeRequest {
user?: {
id?: string;
role?: string;
isApiKey?: boolean;
profiles?: string[];
};
}
@Injectable()
export class RuntimeReadAccess {
private readonly grants: Readonly<Record<string, readonly string[]>>;
constructor(grants: Readonly<Record<string, readonly string[]>>) {
if (
!grants ||
typeof grants !== 'object' ||
Array.isArray(grants) ||
Object.keys(grants).length > 1000
)
throw new Error('Invalid runtime access configuration');
const copy: Record<string, readonly string[]> = Object.create(null);
for (const [subject, profiles] of Object.entries(grants)) {
if (
!/^[a-zA-Z0-9][a-zA-Z0-9@._:-]{0,127}$/.test(subject) ||
['__proto__', 'constructor', 'prototype'].includes(subject) ||
!Array.isArray(profiles) ||
profiles.length === 0 ||
profiles.length > 100 ||
new Set(profiles).size !== profiles.length ||
profiles.some(
(p) =>
typeof p !== 'string' ||
!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(p),
)
)
throw new Error('Invalid runtime access configuration');
copy[subject] = Object.freeze([...profiles]);
}
this.grants = Object.freeze(copy);
}
principal(req: VerifiedRuntimeRequest): RuntimePrincipal {
const u = req.user;
if (
!u?.id ||
u.isApiKey ||
!['admin', 'superadmin'].includes(
(u.role ?? '').toLowerCase().replace(/[_-]/g, ''),
) ||
!Object.hasOwn(this.grants, u.id)
)
throw new ForbiddenException('Runtime access denied');
return { subject: u.id, profiles: this.grants[u.id] };
}
authorize(
p: RuntimePrincipal,
permission: string,
profile?: string,
): Promise<boolean> {
return Promise.resolve(
permission === 'runtime.read' &&
Object.hasOwn(this.grants, p.subject) &&
(!profile || this.grants[p.subject].includes(profile)),
);
}
}
@Controller('admin/orchestration/runtime')
@UseGuards(AuthGuard('jwt'))
export class RuntimeReadController {
constructor(
private readonly runtime: HermesIntegrationService,
private readonly access: RuntimeReadAccess,
) {}
private async read(
req: VerifiedRuntimeRequest,
call: (p: RuntimePrincipal) => Promise<unknown>,
) {
const p = this.access.principal(req);
try {
return await call(p);
} catch (e) {
if (e instanceof HermesError) {
if (e.code === 'FORBIDDEN')
throw new ForbiddenException('Runtime access denied');
if (e.code === 'LIMIT')
throw new HttpException('Runtime request limit', 429);
}
throw new ServiceUnavailableException('Runtime unavailable');
}
}
private profile(
q: Record<string, unknown>,
p: RuntimePrincipal,
extras: string[] = [],
): string {
if (
Object.keys(q).some((k) => !['profile', ...extras].includes(k)) ||
typeof q.profile !== 'string' ||
!p.profiles.includes(q.profile)
)
throw new HermesError('FORBIDDEN');
return q.profile;
}
private number(
q: Record<string, unknown>,
key: string,
fallback: number,
min: number,
max: number,
): number {
if (q[key] === undefined) return fallback;
if (typeof q[key] !== 'string' || !/^\d+$/.test(q[key]))
throw new HermesError('LIMIT');
const n = Number(q[key]);
if (!Number.isSafeInteger(n) || n < min || n > max)
throw new HermesError('LIMIT');
return n;
}
@Get('health') health(@Req() req: VerifiedRuntimeRequest) {
return this.read(req, (p) => this.runtime.health(p));
}
@Get('profiles') profiles(@Req() req: VerifiedRuntimeRequest) {
return this.read(req, (p) => this.runtime.profiles(p));
}
@Get('status') status(
@Req() req: VerifiedRuntimeRequest,
@Query() q: Record<string, unknown>,
) {
return this.read(req, (p) => this.runtime.status(p, this.profile(q, p)));
}
@Get('usage') usage(
@Req() req: VerifiedRuntimeRequest,
@Query() q: Record<string, unknown>,
) {
return this.read(req, (p) =>
this.runtime.usage(
p,
this.profile(q, p, ['days']),
this.number(q, 'days', 30, 1, 365),
),
);
}
@Get('sessions') sessions(
@Req() req: VerifiedRuntimeRequest,
@Query() q: Record<string, unknown>,
) {
return this.read(req, (p) =>
this.runtime.sessions(
p,
this.profile(q, p, ['limit', 'offset']),
this.number(q, 'limit', 20, 1, 100),
this.number(q, 'offset', 0, 0, 10000),
),
);
}
@Get('schedules') schedules(
@Req() req: VerifiedRuntimeRequest,
@Query() q: Record<string, unknown>,
) {
return this.read(req, (p) => this.runtime.crons(p, this.profile(q, p)));
}
@Get('model-info') modelInfo(
@Req() req: VerifiedRuntimeRequest,
@Query() q: Record<string, unknown>,
) {
return this.read(req, (p) => this.runtime.modelInfo(p, this.profile(q, p)));
}
}
@@ -1,88 +0,0 @@
import { DynamicModule, Module } from '@nestjs/common';
import { open, lstat } from 'node:fs/promises';
import { constants } from 'node:fs';
import { dirname, resolve } from 'node:path';
import { HermesManagementModule } from './hermes-management.module';
import {
RuntimeReadAccess,
RuntimeReadController,
} from './runtime-read.controller';
import { HermesError } from './hermes.adapter';
export async function runtimeSecret(path: string): Promise<string> {
if (!/^\/run\/secrets\/[a-zA-Z0-9_-]+$/.test(path))
throw new HermesError('CONFIGURATION');
try {
const file = await open(path, 'r');
try {
const stat = await file.stat();
if (!stat.isFile() || stat.size > 4096) throw new Error();
const value = (await file.readFile('utf8')).trim();
if (!value || /[\r\n]/.test(value)) throw new Error();
return value;
} finally {
await file.close();
}
} catch {
throw new HermesError('AUTH_REQUIRED');
}
}
/** Exact fixed mount roots only; startup fails closed, never browser/JWT grants. */
export async function loadRuntimeGrants(
path = '/run/secrets/hermes_runtime_grants',
reviewedRoot?: string,
): Promise<Readonly<Record<string, readonly string[]>>> {
const roots = reviewedRoot
? [resolve(reviewedRoot)]
: ['/run/secrets', '/etc/canina'];
if (!roots.includes(dirname(path)) || resolve(path) !== path)
throw new HermesError('CONFIGURATION');
try {
const stat = await lstat(path);
if (
!stat.isFile() ||
stat.isSymbolicLink() ||
stat.size > 65536 ||
stat.mode & 0o022
)
throw new Error();
const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
try {
const data: unknown = JSON.parse(await file.readFile('utf8'));
if (!data || typeof data !== 'object' || Array.isArray(data))
throw new Error();
new RuntimeReadAccess(data as Record<string, readonly string[]>);
return data as Record<string, readonly string[]>;
} finally {
await file.close();
}
} catch {
throw new HermesError('CONFIGURATION');
}
}
@Module({})
export class RuntimeReadModule {
static async registerFromFile(
path = '/run/secrets/hermes_runtime_grants',
): Promise<DynamicModule> {
return this.register(await loadRuntimeGrants(path));
}
static register(
grants: Readonly<Record<string, readonly string[]>>,
): DynamicModule {
const access = new RuntimeReadAccess(grants);
return {
module: RuntimeReadModule,
imports: [
HermesManagementModule.registerAuthenticated(
async () => ({
username: await runtimeSecret('/run/secrets/hermes_username'),
password: await runtimeSecret('/run/secrets/hermes_password'),
}),
access,
),
],
controllers: [RuntimeReadController],
providers: [{ provide: RuntimeReadAccess, useValue: access }],
};
}
}
@@ -1,16 +0,0 @@
import { runtimeReadRegistration } from './runtime-read.registration';
import { RuntimeReadModule } from './runtime-read.module';
describe('application runtime registration',()=>{
afterEach(()=>jest.restoreAllMocks());
it('registers denied routes without reading files when not explicitly enabled',async()=>{
const file=jest.spyOn(RuntimeReadModule,'registerFromFile');
const register=jest.spyOn(RuntimeReadModule,'register');
await runtimeReadRegistration({});
expect(file).not.toHaveBeenCalled();expect(register).toHaveBeenCalledWith({});
});
it('uses only the fixed reviewed grants mount when enabled',async()=>{
const file=jest.spyOn(RuntimeReadModule,'registerFromFile').mockResolvedValue({module:RuntimeReadModule});
await runtimeReadRegistration({CANINA_RUNTIME_READ_ENABLED:'true'});
expect(file).toHaveBeenCalledWith('/run/secrets/hermes_runtime_grants');
});
});
@@ -1,6 +0,0 @@
import { RuntimeReadModule } from './runtime-read.module';
export function runtimeReadRegistration(env:Record<string,string|undefined>=process.env) {
return env.CANINA_RUNTIME_READ_ENABLED === 'true'
? RuntimeReadModule.registerFromFile('/run/secrets/hermes_runtime_grants')
: RuntimeReadModule.register({});
}
@@ -1,75 +0,0 @@
import { Test } from '@nestjs/testing';
import {
RuntimeReadController,
RuntimeReadAccess,
} from './runtime-read.controller';
import { HermesIntegrationService } from './hermes-integration.service';
import { HermesError } from './hermes.adapter';
import {
ForbiddenException,
ServiceUnavailableException,
} from '@nestjs/common';
describe('runtime read boundary', () => {
const health = jest.fn();
const profiles = jest.fn();
const status = jest.fn();
const service = {
health,
profiles,
status,
} as unknown as HermesIntegrationService;
const access = new RuntimeReadAccess({ 'admin-1': ['default'] });
const controller = new RuntimeReadController(service, access);
beforeEach(() => jest.clearAllMocks());
it('denies unconfigured identity without IO', async () => {
await expect(
controller.health({ user: { id: 'other', role: 'Admin' } }),
).rejects.toBeInstanceOf(ForbiddenException);
expect(health).not.toHaveBeenCalled();
});
it('uses server scope not body or user supplied profiles', async () => {
status.mockResolvedValue({ overall: 'ok' });
await expect(
controller.status(
{ user: { id: 'admin-1', role: 'Admin', profiles: ['other'] } },
{ profile: 'other' },
),
).rejects.toBeInstanceOf(ForbiddenException);
expect(status).not.toHaveBeenCalled();
await controller.status(
{ user: { id: 'admin-1', role: 'Admin' } },
{ profile: 'default' },
);
expect(status).toHaveBeenCalledWith(
{ subject: 'admin-1', profiles: ['default'] },
'default',
);
});
it('rejects duplicate/missing/unknown query parameters before IO', async () => {
for (const q of [
{},
{ profile: ['default', 'other'] },
{ profile: 'default', token: 'leak' },
])
await expect(
controller.status({ user: { id: 'admin-1', role: 'Admin' } }, q),
).rejects.toBeInstanceOf(ForbiddenException);
expect(status).not.toHaveBeenCalled();
});
it('maps credential failure without leaking upstream errors', async () => {
health.mockRejectedValue(new HermesError('AUTH_REQUIRED'));
await expect(
controller.health({ user: { id: 'admin-1', role: 'Admin' } }),
).rejects.toThrow('Runtime unavailable');
});
it('rejects API keys and non-admins even when subject is configured', async () => {
for (const user of [
{ id: 'admin-1', role: 'User' },
{ id: 'admin-1', role: 'Admin', isApiKey: true },
])
await expect(controller.health({ user })).rejects.toBeInstanceOf(
ForbiddenException,
);
expect(health).not.toHaveBeenCalled();
});
});
@@ -1,68 +0,0 @@
import { HermesAdapter } from './hermes.adapter';
const provenance = {
source: 'snapshot',
capturedAt: '2020-01-01T00:00:00Z',
ageSeconds: 100,
freshness: 'stale',
liveProcess: 'unknown',
};
function adapter(data: unknown) {
return new HermesAdapter(
{
origin: 'http://canina-hermes-inventory:9119',
token: () => Promise.resolve('test'),
},
jest.fn(() =>
Promise.resolve(new Response(JSON.stringify(data), { status: 200 })),
) as typeof fetch,
);
}
describe('snapshot provenance boundary', () => {
it('rejects missing provenance from dedicated inventory origin', async () => {
await expect(
adapter({
ok: true,
version: '1',
commit: 'x',
auth_required: true,
}).health(),
).rejects.toMatchObject({ code: 'CONTRACT' });
});
it('cannot present copied gateway scalars as live telemetry', async () => {
const row = await adapter({
version: '1',
gateway_running: true,
active_agents: 12,
gateway_state: 'running',
overall: 'ok',
provenance,
}).status('default');
expect(row).toMatchObject({
gateway_running: false,
active_agents: 0,
gateway_state: null,
overall: 'unknown',
liveGatewayState: 'unknown',
liveActiveAgents: null,
provenance,
});
});
it('profile readiness cannot be inferred from copied PID state', async () => {
const rows = await adapter({
profiles: [
{
name: 'default',
is_default: true,
gateway_running: true,
provenance,
},
],
provenance,
}).profiles();
expect(rows[0]).toMatchObject({
gateway_running: false,
liveGatewayState: 'unknown',
provenance,
});
});
});
@@ -1,11 +0,0 @@
{
"extends": "../../tsconfig.json",
"compilerOptions": {
"rootDir": ".",
"outDir": "../../../.hermes-contract-build",
"incremental": false,
"strict": true
},
"include": ["./*.ts"],
"exclude": []
}
@@ -1,19 +0,0 @@
# Opt-in fragment ONLY: merge into the reviewed Stage backend service definition.
# Not a standalone compose file; does not enable the worker automatically.
# Host files/dirs must already exist, with reviewed ownership and modes.
x-prepare-worker-backend:
environment:
PREPARE_WORKER_ENABLED: "${PREPARE_WORKER_ENABLED:-false}"
secrets:
- source: prepare_worker_grants
target: prepare_worker_grants
mode: 0400
volumes:
- type: bind
source: ${PREPARE_WORKER_ARTIFACT_HOST_DIRECTORY:?review private artifact directory}
target: /var/lib/canina/prepare-artifacts
bind:
create_host_path: false
secrets:
prepare_worker_grants:
file: ${PREPARE_WORKER_GRANTS_FILE:?review mounted grants JSON file}
@@ -1,48 +0,0 @@
import { constants, openSync, closeSync, fstatSync, readSync } from 'fs';
import { WorkerTransportConfig, WorkerTransportModule } from './worker-transport.module';
export const PREPARE_WORKER_CONFIG_PATH = '/run/secrets/prepare_worker_grants';
export const PREPARE_WORKER_ARTIFACT_DIRECTORY = '/var/lib/canina/prepare-artifacts';
const MAX_BYTES = 16384;
const fail = () => { throw new Error('Prepare worker startup configuration rejected'); };
function exact(value: any, keys: string[]): boolean {
return value !== null && typeof value === 'object' && !Array.isArray(value) &&
Object.keys(value).length === keys.length && keys.every(k => Object.hasOwn(value, k));
}
/** Fixed-path, descriptor-pinned, bounded startup read; never logs file contents. */
export function loadPrepareWorkerConfig(): WorkerTransportConfig {
let dir: number | undefined, file: number | undefined;
try {
dir = openSync('/', constants.O_RDONLY | constants.O_DIRECTORY);
for (const part of ['run', 'secrets']) {
const next = openSync(`/proc/self/fd/${dir}/${part}`, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
closeSync(dir); dir = next;
if ((fstatSync(dir).mode & 0o022) !== 0) fail();
}
file = openSync(`/proc/self/fd/${dir}/prepare_worker_grants`, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
const stat = fstatSync(file);
if (!stat.isFile() || stat.nlink !== 1 || (stat.mode & 0o022) !== 0 || stat.size > MAX_BYTES ||
(stat.uid !== 0 && stat.uid !== process.getuid!())) fail();
const bytes = Buffer.alloc(MAX_BYTES + 1);
let length = 0, n: number;
do { n = readSync(file, bytes, length, bytes.length - length, length); length += n; }
while (n > 0 && length < bytes.length);
if (length > MAX_BYTES) fail();
const input = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, length)));
if (!exact(input, ['grants', 'workerIds', 'stageCiIds', 'artifactBaseUrl']) ||
!Array.isArray(input.grants) || input.grants.length < 1 || input.grants.length > 32 ||
!Array.isArray(input.workerIds) || !Array.isArray(input.stageCiIds) ||
input.workerIds.length < 1 || input.stageCiIds.length < 1 ||
input.workerIds.length + input.stageCiIds.length !== input.grants.length ||
typeof input.artifactBaseUrl !== 'string' || input.artifactBaseUrl.length > 2048 ||
input.grants.some((g: any) => !exact(g, ['id', 'role', 'credentialSha256']))) fail();
// Transport registration performs shared role, SHA256, ID, overlap and HTTPS validation.
const config: WorkerTransportConfig = { ...input, enabled: true, artifactDirectory: PREPARE_WORKER_ARTIFACT_DIRECTORY };
WorkerTransportModule.register(config); // Reuse the real transport's reviewed validation, no IO.
config.grants.forEach(Object.freeze);
Object.freeze(config.grants); Object.freeze(config.workerIds); Object.freeze(config.stageCiIds);
return Object.freeze(config);
} catch { return fail(); }
finally { if (file !== undefined) closeSync(file); if (dir !== undefined) closeSync(dir); }
}
@@ -1,21 +0,0 @@
# Prepare worker startup boundary
Parent integration API (AppModule remains untouched here):
```ts
import { registerPrepareWorker } from './orchestration-worker/worker-registration';
// In AppModule imports:
...registerPrepareWorker(),
```
Only literal `PREPARE_WORKER_ENABLED=true` registers the transport. Missing or other values register nothing (404 routes), do not read configuration, and do not instantiate Prisma. Enabled malformed/missing configuration throws synchronously before Nest starts, with one generic error and no secret logging.
The fixed mount `/run/secrets/prepare_worker_grants` contains JSON with exactly `grants`, `workerIds`, `stageCiIds`, `artifactBaseUrl`. Each grant contains exactly `id`, `role` (`WORKFLOW_WORKER` or `STAGE_CI`), `credentialSha256` (64 lowercase hexadecimal characters; never the bearer credential). Require at least one worker and CI, distinct role-bound IDs/digests, exact allowlist coverage, and at most 32 grants. No enabled flag, directory, token, user, or request-derived fields accepted in JSON.
`artifactBaseUrl` must be explicitly reviewed by the operator: canonical public-DNS HTTPS origin plus `/internal/prepare-worker/artifacts`, no credentials, IP, alternate port, query or fragment. Shared transport validation is authoritative. This loader does not fetch the URL or perform DNS resolution. Directory is always `/var/lib/canina/prepare-artifacts`.
Descriptor-relative Linux `/proc/self/fd` traversal refuses symlink directories/files, nonregular files, hardlinks, files over 16 KiB, group/world writable files/directories, and foreign-owned files (root/runtime UID only). Reads are bounded even on concurrent growth. Configuration is frozen recursively and transport takes its own frozen snapshot. Trusted operator owns mounted configuration; edits require restart and review.
`compose.prepare-worker.fragment.yml` is an extension fragment, not a deployable compose file. Parent must merge its `x-prepare-worker-backend` into the correct reviewed Stage backend service and merge `secrets`. Compose bind-backed secrets may ignore mode/UID declarations: provision actual host grants file as root/runtime-owned mode 0400 and artifact directory runtime-owned mode 0700 first. No mounts or live configuration are created by this change.
Tests deliberately use the fixed `/run/secrets` path. Run ONLY in a fresh disposable container with source and donor dependencies read-only, private dependency copy, and private `prisma generate`; never on a live service. Tests need a disposable Linux root filesystem and do not require DB credentials. Registration test uses a real Nest HTTP listener to prove disabled routes are absent. Existing DB-backed transport tracer remains separately gated by `WORKER_TRANSPORT_DB=1`.
@@ -1,84 +0,0 @@
import { Test } from '@nestjs/testing';
import { writeFileSync, chmodSync, symlinkSync, mkdirSync, rmSync } from 'fs';
import { execFileSync } from 'child_process';
import { registerPrepareWorker } from './worker-registration';
import { loadPrepareWorkerConfig } from './worker-config';
import { linkSync } from 'fs';
describe('reviewed prepare-worker startup registration', () => {
const path = '/run/secrets/prepare_worker_grants';
const valid = () => ({ grants: [{ id: 'worker', role: 'WORKFLOW_WORKER', credentialSha256: 'a'.repeat(64) }, { id: 'ci', role: 'STAGE_CI', credentialSha256: 'b'.repeat(64) }], workerIds: ['worker'], stageCiIds: ['ci'], artifactBaseUrl: 'https://stage.example.com/internal/prepare-worker/artifacts' });
it('loader itself rejects malformed SHA grants', () => {
mkdirSync('/run/secrets', { recursive: true });
const c = valid(); c.grants[0].credentialSha256 = 'secret-not-a-sha';
writeFileSync(path, JSON.stringify(c), { mode: 0o400 });
try { expect(() => loadPrepareWorkerConfig()).toThrow('Prepare worker startup configuration rejected'); }
finally { rmSync(path, { force: true }); }
});
it.each(['1', 'TRUE', 'yes', ' true', 'false', ''])('does not opt in for %s', value => {
expect(registerPrepareWorker({ PREPARE_WORKER_ENABLED: value })).toEqual([]);
});
it.each(['missing', 'symlink', 'directory', 'fifo', 'oversize', 'group-write', 'world-write', 'hardlink'])('fails startup on unsafe file: %s', kind => {
mkdirSync('/run/secrets', { recursive: true });
const other = '/run/secrets/test-other';
try {
if (kind === 'fifo') execFileSync('mkfifo', [path]);
else if (kind === 'directory') mkdirSync(path);
else if (kind === 'symlink') symlinkSync(other, path);
else if (kind !== 'missing') {
writeFileSync(path, kind === 'oversize' ? ' '.repeat(16385) : JSON.stringify(valid()), { mode: 0o400 });
if (kind === 'group-write') chmodSync(path, 0o420);
if (kind === 'world-write') chmodSync(path, 0o402);
if (kind === 'hardlink') linkSync(path, other);
}
expect(() => registerPrepareWorker({ PREPARE_WORKER_ENABLED: 'true' })).toThrow('Prepare worker startup configuration rejected');
} finally { rmSync(path, { recursive: true, force: true }); rmSync(other, { force: true }); }
});
it.each(['extra', 'raw-token', 'wrong-role', 'overlap', 'duplicate-sha', 'missing-grant', 'http', 'credentials', 'localhost', 'query', 'bad-json', 'null'])('rejects unreviewed JSON: %s without leaking contents or logging', kind => {
mkdirSync('/run/secrets', { recursive: true });
const c: any = valid();
if (kind === 'extra') c.artifactDirectory = '/user-selected';
if (kind === 'raw-token') c.grants[0].token = 'DO_NOT_LOG_THIS_SECRET';
if (kind === 'wrong-role') c.grants[0].role = 'Admin';
if (kind === 'overlap') c.stageCiIds = ['worker'];
if (kind === 'duplicate-sha') c.grants[1].credentialSha256 = c.grants[0].credentialSha256;
if (kind === 'missing-grant') c.workerIds.push('unbound');
if (kind === 'http') c.artifactBaseUrl = 'http://stage.example.com/internal/prepare-worker/artifacts';
if (kind === 'credentials') c.artifactBaseUrl = 'https://DO_NOT_LOG_THIS_SECRET@stage.example.com/internal/prepare-worker/artifacts';
if (kind === 'localhost') c.artifactBaseUrl = 'https://127.0.0.1/internal/prepare-worker/artifacts';
if (kind === 'query') c.artifactBaseUrl += '?secret=DO_NOT_LOG_THIS_SECRET';
writeFileSync(path, kind === 'bad-json' ? 'DO_NOT_LOG_THIS_SECRET' : kind === 'null' ? 'null' : JSON.stringify(c), { mode: 0o400 });
const logs = [jest.spyOn(console, 'log'), jest.spyOn(console, 'warn'), jest.spyOn(console, 'error')];
try {
expect(() => registerPrepareWorker({ PREPARE_WORKER_ENABLED: 'true' })).toThrow(/^Prepare worker startup configuration rejected$/);
logs.forEach(log => expect(log).not.toHaveBeenCalled());
} finally { logs.forEach(log => log.mockRestore()); rmSync(path, { force: true }); }
});
it('defaults to no module/no config IO and exposes no worker routes', async () => {
expect(registerPrepareWorker({})).toEqual([]);
expect(registerPrepareWorker({ PREPARE_WORKER_ENABLED: 'false' })).toEqual([]);
const module = await Test.createTestingModule({ imports: registerPrepareWorker({}) }).compile();
const app = module.createNestApplication();
await app.listen(0, '127.0.0.1');
try {
const response = await fetch((await app.getUrl()) + '/internal/prepare-worker/claim', { method: 'POST' });
expect(response.status).toBe(404);
} finally { await app.close(); }
});
it('loads immutable reviewed JSON into the real transport registration', async () => {
mkdirSync('/run/secrets', { recursive: true });
const file = '/run/secrets/prepare_worker_grants';
const config = { grants: [{ id: 'worker', role: 'WORKFLOW_WORKER', credentialSha256: 'a'.repeat(64) }, { id: 'ci', role: 'STAGE_CI', credentialSha256: 'b'.repeat(64) }], workerIds: ['worker'], stageCiIds: ['ci'], artifactBaseUrl: 'https://stage.example.com/internal/prepare-worker/artifacts' };
writeFileSync(file, JSON.stringify(config), { mode: 0o400 });
try {
const [registered] = registerPrepareWorker({ PREPARE_WORKER_ENABLED: 'true' });
expect(registered.module.name).toBe('WorkerTransportModule');
expect(registered.controllers?.length).toBe(1);
const snapshot = (registered.providers as any[]).find(p => p.useValue?.artifactDirectory)?.useValue;
expect(snapshot).toEqual({ ...config, enabled: true, artifactDirectory: '/var/lib/canina/prepare-artifacts' });
expect(Object.isFrozen(snapshot)).toBe(true);
expect(Object.isFrozen(snapshot.grants[0])).toBe(true);
} finally { rmSync(file, { force: true }); }
});
});
@@ -1,10 +0,0 @@
import { DynamicModule } from '@nestjs/common';
import { loadPrepareWorkerConfig } from './worker-config';
import { WorkerTransportModule } from './worker-transport.module';
/** AppModule imports: ...registerPrepareWorker(); disabled means no module or IO. */
export function registerPrepareWorker(env: NodeJS.ProcessEnv = process.env): DynamicModule[] {
if (env.PREPARE_WORKER_ENABLED !== 'true') return [];
try { return [WorkerTransportModule.register(loadPrepareWorkerConfig())]; }
catch { throw new Error('Prepare worker startup configuration rejected'); }
}
@@ -1,343 +0,0 @@
import {
BadRequestException,
Body,
CanActivate,
ConflictException,
Controller,
DynamicModule,
ForbiddenException,
Get,
Inject,
Injectable,
Module,
NotFoundException,
Param,
Post,
Req,
UnauthorizedException,
UseGuards,
UsePipes,
ValidationPipe,
} from "@nestjs/common";
import { IsString, IsUUID, Matches, MaxLength } from "class-validator";
import { createHash, timingSafeEqual } from "crypto";
import { mkdir, open, FileHandle } from "fs/promises";
import { constants } from "fs";
import { isAbsolute } from "path";
import { PrismaModule } from "../prisma/prisma.module";
import { PrismaService } from "../prisma/prisma.service";
import {
PREPARE_WORKFLOW_CONFIG,
PrepareWorkflowService,
WorkflowIdentity,
} from "../orchestration/prepare-workflow.service";
// This is reviewed static configuration, not a URL fetched by the transport.
function validArtifactBase(value: string): boolean {
try {
const u = new URL(value);
// DNS name only: reject all IP literals, localhost/private single-label names,
// noncanonical paths/escapes, credentials, query, fragment and alternate ports.
return u.protocol === "https:" && !u.username && !u.password && !u.port &&
/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(u.hostname) &&
u.hostname.includes(".") && !/^[0-9.]+$/.test(u.hostname) &&
!/(^|\.)(localhost|local|internal|lan|home)$/.test(u.hostname) &&
["/internal/prepare-worker/artifacts", "/api/internal/prepare-worker/artifacts"].includes(u.pathname) &&
value === u.origin + u.pathname;
} catch { return false; }
}
const CONFIG = Symbol("WORKER_TRANSPORT_CONFIG");
export interface WorkerTransportConfig {
enabled: boolean;
grants: {
id: string;
role: "WORKFLOW_WORKER" | "STAGE_CI";
credentialSha256: string;
}[];
workerIds: string[];
stageCiIds: string[];
artifactDirectory: string;
artifactBaseUrl: string;
}
class ClaimDto {
@IsUUID() taskId!: string;
}
class LeaseDto extends ClaimDto {
@IsUUID() runId!: string;
@IsUUID() leaseToken!: string;
}
class CompleteDto extends LeaseDto {
@IsString() @MaxLength(2048) report!: string;
}
class StageEvidenceDto extends ClaimDto {
@IsUUID() runId!: string;
@Matches(/^[a-f0-9]{40}$/) commitSha!: string;
@Matches(/^[a-f0-9]{64}$/) sha256!: string;
@Matches(/^[a-f0-9]{64}$/) evidenceSha256!: string;
@Matches(/^https:\/\/[^\s]+$/) @MaxLength(2000) uri!: string;
}
export function tracerReport(lease: {
taskId: string;
runId: string;
commitSha: string;
}) {
return JSON.stringify({
kind: "DETERMINISTIC_PREPARE_TRACER",
schemaVersion: 1,
taskId: lease.taskId,
runId: lease.runId,
commitSha: lease.commitSha,
environment: "staging",
llmPilot: false,
browserExecuted: false,
shellExecuted: false,
deploymentExecuted: false,
checks: ["lease-bound identity", "deterministic JSON serialization"],
actualCents: 0,
});
}
@Injectable()
class WorkerIdentityGuard implements CanActivate {
constructor(@Inject(CONFIG) private readonly config: WorkerTransportConfig) {}
canActivate(context: any) {
if (!this.config.enabled)
throw new ForbiddenException("Worker transport disabled");
const req = context.switchToHttp().getRequest();
const auth = req.headers.authorization;
if (typeof auth !== "string" || !/^Bearer [\x21-\x7e]{32,512}$/.test(auth))
throw new UnauthorizedException();
const digest = createHash("sha256").update(auth.slice(7)).digest();
const grant = this.config.grants.find((g) =>
timingSafeEqual(Buffer.from(g.credentialSha256, "hex"), digest),
);
if (!grant) throw new UnauthorizedException();
req.workerIdentity = { id: grant.id, role: grant.role };
return true;
}
}
@Injectable()
class WorkerTransportService {
constructor(
private readonly workflow: PrepareWorkflowService,
private readonly db: PrismaService,
@Inject(CONFIG) private readonly config: WorkerTransportConfig,
) {}
// Linux descriptor-relative traversal pins each directory across renames. Never
// realpath-check then reopen by name: that reintroduces a symlink race.
private async artifactDir(): Promise<FileHandle> {
let dir = await open("/", constants.O_RDONLY | constants.O_DIRECTORY);
try {
for (const part of this.config.artifactDirectory.split("/").filter(Boolean)) {
const path = `/proc/self/fd/${dir.fd}/${part}`;
try { await mkdir(path, { mode: 0o700 }); }
catch (e: any) { if (e.code !== "EEXIST") throw e; }
const next = await open(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
await dir.close();
dir = next;
}
const stat = await dir.stat();
if (stat.uid !== process.getuid!() || (stat.mode & 0o077) !== 0)
throw new Error("Private owned artifact directory required");
return dir;
} catch (e) { await dir.close(); throw e; }
}
private worker(a: WorkflowIdentity) {
if (a.role !== "WORKFLOW_WORKER" || !this.config.workerIds.includes(a.id))
throw new ForbiddenException("Worker allowlist required");
}
async claim(a: WorkflowIdentity, dto: ClaimDto) {
this.worker(a);
const t = await this.db.orchestrationTask.findUnique({
where: { id: dto.taskId },
});
// Explicit per-task pilot scope; never opportunistically consume arbitrary queued work.
if (!t || !["READY", "RUNNING"].includes(t.state)) return { lease: null };
if (t.budgetLimitCents !== 20)
throw new ForbiddenException("Pilot hard task cap is 20 cents");
return { lease: await this.workflow.claim(a, dto.taskId) };
}
heartbeat(a: WorkflowIdentity, dto: LeaseDto) {
this.worker(a);
return this.workflow.heartbeat(a, dto);
}
async complete(a: WorkflowIdentity, dto: CompleteDto) {
this.worker(a);
// Recheck stop/interrupt and fencing before artifact creation; core rechecks atomically at commit.
await this.workflow.heartbeat(a, dto);
const run = await this.db.orchestrationRun.findUniqueOrThrow({
where: { id: dto.runId },
});
const expected = tracerReport({ ...dto, commitSha: run.commitSha });
if (dto.report !== expected)
throw new BadRequestException(
"Only deterministic harmless tracer report accepted",
);
const sha256 = createHash("sha256").update(expected).digest("hex");
let dir: FileHandle | undefined, file: FileHandle | undefined;
try {
dir = await this.artifactDir();
file = await open(`/proc/self/fd/${dir.fd}/${sha256}.json`,
constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
await file.writeFile(expected, "utf8");
await file.sync();
} catch { throw new ConflictException("Artifact creation refused"); }
finally { await file?.close(); await dir?.close(); }
const result = await this.workflow.complete(a, {
...dto,
sha256,
uri: this.config.artifactBaseUrl + "/" + sha256,
actualCents: 0,
});
return {
state: result.state,
taskId: result.id,
runId: dto.runId,
sha256,
actualCents: 0,
};
}
async artifact(a: WorkflowIdentity, hash: string) {
if (!/^[a-f0-9]{64}$/.test(hash))
throw new BadRequestException("Invalid artifact hash");
const registered = await this.db.orchestrationArtifact.findFirst({
where: {
sha256: hash, kind: "QA", uri: this.config.artifactBaseUrl + "/" + hash,
run: { environment: "staging", status: "SUCCEEDED", task: {
operationMode: "PREPARE", budgetLimitCents: 20,
} },
},
});
if (!registered) throw new NotFoundException("Artifact not registered");
const run = await this.db.orchestrationRun.findUniqueOrThrow({ where: { id: registered.runId } });
const task = await this.db.orchestrationTask.findUniqueOrThrow({ where: { id: run.taskId } });
const outbox = await this.db.prepareWorkflowOutbox.findUnique({ where: { taskId: run.taskId } });
if (!outbox || outbox.status !== "DONE" || outbox.runId !== run.id ||
(a.role === "WORKFLOW_WORKER" && outbox.leaseOwner !== a.id))
throw new NotFoundException("Artifact not registered");
const metadata = task.metadata as any;
if (metadata?.workflowScope !== "STAGE_PREPARE" || metadata?.commitSha !== run.commitSha)
throw new NotFoundException("Artifact not registered");
let bytes: string;
let dir: FileHandle | undefined, file: FileHandle | undefined;
try {
dir = await this.artifactDir();
file = await open(`/proc/self/fd/${dir.fd}/${hash}.json`,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
const stat = await file.stat();
if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.getuid!() ||
(stat.mode & 0o077) !== 0 || stat.size > 2048)
throw new Error("Unsafe artifact file");
// Fixed-size descriptor read: concurrent growth cannot allocate unbounded memory.
const buffer = Buffer.alloc(2049);
const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
if (bytesRead > 2048) throw new Error("Oversized artifact");
bytes = buffer.subarray(0, bytesRead).toString("utf8");
} catch {
throw new NotFoundException("Artifact unavailable");
} finally { await file?.close(); await dir?.close(); }
if (createHash("sha256").update(bytes).digest("hex") !== hash)
throw new ConflictException("Artifact integrity mismatch");
if (bytes !== tracerReport({ taskId: run.taskId, runId: run.id, commitSha: run.commitSha }))
throw new ConflictException("Artifact binding mismatch");
return JSON.parse(bytes);
}
stage(a: WorkflowIdentity, dto: StageEvidenceDto) {
return this.workflow.stageEvidence(a, dto);
}
}
@Controller("internal/prepare-worker")
@UseGuards(WorkerIdentityGuard)
@UsePipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
)
class WorkerTransportController {
constructor(private readonly service: WorkerTransportService) {}
@Post("claim") claim(@Req() req: any, @Body() dto: ClaimDto) {
return this.service.claim(req.workerIdentity, dto);
}
@Post("heartbeat") heartbeat(@Req() req: any, @Body() dto: LeaseDto) {
return this.service.heartbeat(req.workerIdentity, dto);
}
@Post("complete") complete(@Req() req: any, @Body() dto: CompleteDto) {
return this.service.complete(req.workerIdentity, dto);
}
@Post("stage-evidence") stage(
@Req() req: any,
@Body() dto: StageEvidenceDto,
) {
return this.service.stage(req.workerIdentity, dto);
}
@Get("artifacts/:hash") artifact(@Req() req: any, @Param("hash") hash: string) {
return this.service.artifact(req.workerIdentity, hash);
}
}
@Module({})
export class WorkerTransportModule {
static register(config: WorkerTransportConfig): DynamicModule {
if (typeof config.enabled !== "boolean" || !Array.isArray(config.grants) ||
!Array.isArray(config.workerIds) || !Array.isArray(config.stageCiIds))
throw new Error("Explicit boolean enable and credential allowlists required");
const allIds = [...config.workerIds, ...config.stageCiIds];
if (allIds.some(id => typeof id !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(id)) ||
new Set(allIds).size !== allIds.length)
throw new Error("Invalid or overlapping worker/CI allowlists");
const ids = new Set<string>(),
digests = new Set<string>();
if (
!isAbsolute(config.artifactDirectory) || config.artifactDirectory === "/" ||
config.artifactDirectory.split("/").some(p => p === "." || p === "..") ||
!validArtifactBase(config.artifactBaseUrl)
)
throw new Error(
"Absolute artifact directory and fixed HTTPS artifact base required",
);
for (const g of config.grants) {
const allowed =
g.role === "WORKFLOW_WORKER"
? config.workerIds
: g.role === "STAGE_CI"
? config.stageCiIds
: [];
if (
!/^[a-zA-Z0-9_-]{1,100}$/.test(g.id) ||
!allowed.includes(g.id) ||
!/^[a-f0-9]{64}$/.test(g.credentialSha256) ||
ids.has(g.id) ||
digests.has(g.credentialSha256) ||
(config.workerIds.includes(g.id) && config.stageCiIds.includes(g.id))
)
throw new Error("Invalid or overlapping worker/CI credential grants");
ids.add(g.id);
digests.add(g.credentialSha256);
}
const snapshot = JSON.parse(JSON.stringify(config)) as WorkerTransportConfig;
snapshot.grants.forEach(Object.freeze);
Object.freeze(snapshot.grants);
Object.freeze(snapshot.workerIds);
Object.freeze(snapshot.stageCiIds);
Object.freeze(snapshot);
return {
module: WorkerTransportModule,
imports: [PrismaModule],
controllers: [WorkerTransportController],
providers: [
PrepareWorkflowService,
WorkerIdentityGuard,
WorkerTransportService,
{ provide: CONFIG, useValue: snapshot },
{
provide: PREPARE_WORKFLOW_CONFIG,
useValue: Object.freeze({
workerIds: snapshot.workerIds,
stageCiIds: snapshot.stageCiIds,
}),
},
],
exports: [PrepareWorkflowService],
};
}
}
@@ -1,438 +0,0 @@
import { Test } from "@nestjs/testing";
import { INestApplication } from "@nestjs/common";
import { PrismaClient } from "@prisma/client";
import { PrismaService } from "../prisma/prisma.service";
import { PrepareWorkflowService } from "../orchestration/prepare-workflow.service";
import { WorkerTransportModule, tracerReport } from "./worker-transport.module";
import { createHash, randomUUID } from "crypto";
import { mkdtemp, readFile, rm, writeFile, symlink, link, rename } from "fs/promises";
import { tmpdir } from "os";
import { join } from "path";
import { execFile } from "child_process";
import { promisify } from "util";
const enabled = process.env.WORKER_TRANSPORT_DB === "1";
(enabled ? describe : describe.skip)(
"isolated PostgreSQL HTTP executor tracer",
() => {
const db = new PrismaClient();
const token = "test-only-worker-secret-".repeat(3);
const ciToken = "test-only-ci-secret-".repeat(3);
const digest = (s: string) => createHash("sha256").update(s).digest("hex");
let app: INestApplication,
workflow: PrepareWorkflowService,
base: string,
directory: string;
let pilot: any;
beforeAll(async () => {
directory = await mkdtemp(join(tmpdir(), "worker-artifacts-"));
const mod = await Test.createTestingModule({
imports: [
WorkerTransportModule.register({
enabled: true,
grants: [
{
id: "pilot",
role: "WORKFLOW_WORKER",
credentialSha256: digest(token),
},
{ id: "ci", role: "STAGE_CI", credentialSha256: digest(ciToken) },
{ id: "other", role: "WORKFLOW_WORKER", credentialSha256: digest("other-worker-secret-".repeat(3)) },
],
workerIds: ["pilot", "other"],
stageCiIds: ["ci"],
artifactDirectory: directory,
artifactBaseUrl:
"https://isolated.invalid/internal/prepare-worker/artifacts",
}),
],
})
.overrideProvider(PrismaService)
.useValue(db)
.compile();
workflow = mod.get(PrepareWorkflowService);
app = mod.createNestApplication();
await app.listen(0, "127.0.0.1");
base = await app.getUrl();
pilot = {
runOnce: async (options: any) => {
const program =
'import {runOnce} from "../infra/hermes-worker/pilot.mjs"; console.log(JSON.stringify(await runOnce(JSON.parse(process.env.TEST_PILOT_OPTIONS))));';
const result = await promisify(execFile)(
process.execPath,
["--input-type=module", "-e", program],
{
env: {
...process.env,
TEST_PILOT_OPTIONS: JSON.stringify(options),
},
timeout: 15000,
},
);
return JSON.parse(result.stdout);
},
};
});
afterAll(async () => {
await app?.close();
await db.$disconnect();
if (directory) await rm(directory, { recursive: true, force: true });
});
const owner = { id: "author", role: "Admin" },
reviewer = { id: "reviewer", role: "SUPER_ADMIN" };
async function proposal(queue = true, budget = 20) {
let t = await workflow.create(
{
key: randomUUID(),
title: "deterministic tracer",
department: "TEST",
operationMode: "PREPARE",
budgetLimitCents: budget,
metadata: {
commitSha: "a".repeat(40),
scope: "Harmless tracer only",
acceptanceCriteria: ["writes deterministic JSON; no release"],
},
},
owner,
);
if (queue) {
t = await workflow.transition(
t.id,
{
toState: "GATE1_PENDING",
expectedVersion: t.version,
idempotencyKey: randomUUID(),
},
owner,
);
t = await workflow.decide(
t.id,
1,
{
decision: "APPROVED",
expiresAt: new Date(Date.now() + 60000).toISOString(),
expectedVersion: t.version,
idempotencyKey: randomUUID(),
},
reviewer,
);
t = await workflow.transition(
t.id,
{
toState: "READY",
expectedVersion: t.version,
idempotencyKey: randomUUID(),
},
owner,
);
}
return t;
}
async function post(route: string, body: any = {}, secret = token) {
const r = await fetch(base + "/internal/prepare-worker/" + route, {
method: "POST",
headers: {
authorization: "Bearer " + secret,
"content-type": "application/json",
},
body: JSON.stringify(body),
});
return { status: r.status, body: await r.json() };
}
it("rejects overlapping worker and CI grants and accepts no credentials when disabled", async () => {
expect(() =>
WorkerTransportModule.register({
enabled: true,
grants: [
{
id: "both",
role: "WORKFLOW_WORKER",
credentialSha256: digest(token),
},
],
workerIds: ["both"],
stageCiIds: ["both"],
artifactDirectory: directory,
artifactBaseUrl: "https://isolated.invalid/internal/prepare-worker/artifacts",
}),
).toThrow(/overlapping/);
const mod = await Test.createTestingModule({
imports: [
WorkerTransportModule.register({
enabled: false,
grants: [],
workerIds: [],
stageCiIds: [],
artifactDirectory: directory,
artifactBaseUrl: "https://isolated.invalid/internal/prepare-worker/artifacts",
}),
],
})
.overrideProvider(PrismaService)
.useValue(db)
.compile();
const disabled = mod.createNestApplication();
await disabled.listen(0, "127.0.0.1");
try {
const r = await fetch(
(await disabled.getUrl()) + "/internal/prepare-worker/claim",
{
method: "POST",
headers: {
authorization: "Bearer " + token,
"content-type": "application/json",
},
body: JSON.stringify({ taskId: randomUUID() }),
},
);
expect(r.status).toBe(403);
} finally {
await disabled.close();
}
});
it("rejects unsafe artifact bases and freezes validated configuration", () => {
const config = { enabled: true, grants: [], workerIds: [], stageCiIds: [], artifactDirectory: directory,
artifactBaseUrl: "https://isolated.invalid/internal/prepare-worker/artifacts" };
for (const artifactBaseUrl of ["https://user:pass@isolated.invalid/internal/prepare-worker/artifacts", "https://127.0.0.1/internal/prepare-worker/artifacts", "https://10.1.2.3/internal/prepare-worker/artifacts", "https://localhost/internal/prepare-worker/artifacts", "https://isolated.invalid/arbitrary", "https://isolated.invalid/x/../internal/prepare-worker/artifacts", "https://[::1]/internal/prepare-worker/artifacts"]) {
expect(() => WorkerTransportModule.register({ ...config, artifactBaseUrl })).toThrow();
}
const registered = WorkerTransportModule.register(config);
const snapshot = (registered.providers as any[]).find(p => p.useValue?.artifactBaseUrl)?.useValue;
expect(Object.isFrozen(snapshot)).toBe(true);
expect(Object.isFrozen(snapshot.workerIds)).toBe(true);
expect(Object.isFrozen(snapshot.grants)).toBe(true);
const workflowConfig = (registered.providers as any[]).find(p => p.provide === "PREPARE_WORKFLOW_CONFIG").useValue;
expect(Object.isFrozen(workflowConfig)).toBe(true);
expect(() => WorkerTransportModule.register({ ...config, enabled: "true" as any })).toThrow();
});
it("denies untrusted identities and body impersonation; dispatches nothing before Gate1", async () => {
const t = await proposal(false);
expect((await post("claim", {}, "wrong")).status).toBe(401);
expect((await post("claim", { taskId: t.id }, ciToken)).status).toBe(403);
expect(
(await post("claim", { taskId: t.id, actorId: "pilot" })).status,
).toBe(400);
expect((await post("claim", { taskId: t.id })).body).toEqual({
lease: null,
});
expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe(
0,
);
});
it("races claims, fences expired leases and reserves unknown cost against the 20 cent cap", async () => {
const t = await proposal();
const claims = await Promise.all([
post("claim", { taskId: t.id }),
post("claim", { taskId: t.id }),
]);
const leases = claims.map((r) => r.body.lease).filter(Boolean);
expect(leases).toHaveLength(1);
const lease = leases[0],
binding = {
taskId: t.id,
runId: lease.runId,
leaseToken: lease.leaseToken,
};
expect(
(await post("heartbeat", { ...binding, leaseToken: randomUUID() }))
.status,
).toBe(403);
expect(
(
await post("complete", {
...binding,
report: "arbitrary shell or prompt",
})
).status,
).toBe(400);
expect(
(await post("complete", { ...binding, report: "{}", actualCents: 21 }))
.status,
).toBe(400);
await db.prepareWorkflowOutbox.update({
where: { taskId: t.id },
data: { leaseUntil: new Date(Date.now() - 1000) },
});
expect((await post("heartbeat", binding)).status).toBe(403);
expect(
(await post("complete", { ...binding, report: "{}" })).status,
).toBe(403);
expect((await post("claim", { taskId: t.id })).status).toBe(403);
expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe(
1,
);
expect(
(
await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
})
)._sum.amountCents,
).toBe(20);
const larger = await proposal(true, 40);
expect((await post("claim", { taskId: larger.id })).status).toBe(403);
});
it("rechecks kill switch and task interrupt on heartbeat and completion; separates CI authority", async () => {
const t = await proposal(),
lease = (await post("claim", { taskId: t.id })).body.lease;
const binding = {
taskId: t.id,
runId: lease.runId,
leaseToken: lease.leaseToken,
};
await db.orchestrationKillSwitch.upsert({
where: { scope: "GLOBAL" },
create: {
scope: "GLOBAL",
level: "STOP_AGENTS",
active: true,
reason: "isolated test",
actorId: "test",
},
update: { level: "STOP_AGENTS", active: true },
});
try {
expect((await post("heartbeat", binding)).status).toBe(403);
expect(
(await post("complete", { ...binding, report: "{}" })).status,
).toBe(403);
expect((await post("claim", { taskId: t.id })).status).toBe(403);
} finally {
await db.orchestrationKillSwitch.deleteMany();
}
await db.orchestrationTask.update({
where: { id: t.id },
data: { state: "CANCELLED" },
});
expect((await post("heartbeat", binding)).status).toBe(403);
expect(
(await post("complete", { ...binding, report: "{}" })).status,
).toBe(403);
expect(
await db.orchestrationArtifact.count({ where: { runId: lease.runId } }),
).toBe(0);
const evidence = {
taskId: t.id,
runId: lease.runId,
commitSha: "a".repeat(40),
sha256: "b".repeat(64),
evidenceSha256: "c".repeat(64),
uri: "https://isolated.invalid/not-real-ci",
};
expect((await post("stage-evidence", evidence)).status).toBe(403);
expect((await post("stage-evidence", evidence, ciToken)).status).toBe(
403,
);
});
it("never follows or overwrites preexisting artifact links on completion", async () => {
const t = await proposal();
const lease = (await post("claim", { taskId: t.id })).body.lease;
const report = tracerReport(lease), hash = digest(report);
const target = join(directory, "sentinel");
await writeFile(target, "do not overwrite");
const file = join(directory, hash + ".json");
await symlink(target, file);
const result = await post("complete", { taskId: t.id, runId: lease.runId, leaseToken: lease.leaseToken, report });
expect(await readFile(target, "utf8")).toBe("do not overwrite");
expect(result.status).toBe(409);
expect(await db.orchestrationArtifact.count({ where: { runId: lease.runId } })).toBe(0);
await rm(file);
await link(target, file);
expect((await post("complete", { taskId: t.id, runId: lease.runId, leaseToken: lease.leaseToken, report })).status).toBe(409);
expect(await readFile(target, "utf8")).toBe("do not overwrite");
});
it("runs actual HTTP deterministic executor to VERIFYING with retrievable content-addressed artifact", async () => {
const t = await proposal();
const result = await pilot.runOnce({
baseUrl: base,
credential: token,
taskId: t.id,
allowLoopbackHttp: true,
});
expect(result.state).toBe("VERIFYING");
const row = await db.orchestrationTask.findUniqueOrThrow({
where: { id: t.id },
});
expect(row.state).toBe("VERIFYING");
const artifact = await db.orchestrationArtifact.findFirstOrThrow({
where: { run: { taskId: t.id } },
});
const bytes = await readFile(join(directory, artifact.sha256 + ".json"));
expect(digest(bytes.toString())).toBe(artifact.sha256);
expect(JSON.parse(bytes.toString())).toMatchObject({
kind: "DETERMINISTIC_PREPARE_TRACER",
commitSha: "a".repeat(40),
environment: "staging",
llmPilot: false,
});
const get = await fetch(
base + "/internal/prepare-worker/artifacts/" + artifact.sha256,
{ headers: { authorization: "Bearer " + token } },
);
expect(get.status).toBe(200);
expect(await get.text()).toBe(bytes.toString());
const artifactGet = (secret: string) => fetch(base + "/internal/prepare-worker/artifacts/" + artifact.sha256,
{ headers: { authorization: "Bearer " + secret } });
expect((await artifactGet("other-worker-secret-".repeat(3))).status).toBe(404);
expect((await artifactGet(ciToken)).status).toBe(200);
const foreignHash = digest("{}");
await writeFile(join(directory, foreignHash + ".json"), "{}");
await db.orchestrationArtifact.create({ data: { runId: artifact.runId, kind: "QA", sha256: foreignHash, uri: "https://foreign.invalid/" + foreignHash } });
expect((await fetch(base + "/internal/prepare-worker/artifacts/" + foreignHash, { headers: { authorization: "Bearer " + token } })).status).toBe(404);
const moved = directory + "-moved";
await rename(directory, moved);
try {
await symlink(moved, directory);
expect((await artifactGet(token)).status).toBe(404);
} finally { await rm(directory, { force: true }); await rename(moved, directory); }
const file = join(directory, artifact.sha256 + ".json"), saved = file + ".saved";
await rename(file, saved);
try {
await symlink(saved, file);
expect((await artifactGet(token)).status).toBe(404);
await rm(file);
await link(saved, file);
expect((await artifactGet(token)).status).toBe(404);
await rm(file);
} finally { await rm(file, { force: true }); await rename(saved, file); }
const cost = await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
});
expect(cost._sum.amountCents).toBe(0);
expect(
await db.orchestrationAttestation.findFirst({
where: { run: { taskId: t.id }, kind: "STAGE" },
}),
).toBeNull();
const evidence = {
taskId: t.id,
state: row.state,
sha256: artifact.sha256,
artifact: JSON.parse(bytes.toString()),
httpGet: get.status,
costCents: cost._sum.amountCents,
uriExternalReachability: "NOT_TESTED_ISOLATED_FIXTURE_HOST",
};
console.log("TRACER_EVIDENCE", JSON.stringify(evidence));
if (process.env.TRACER_EVIDENCE_PATH)
await writeFile(
process.env.TRACER_EVIDENCE_PATH,
JSON.stringify(evidence, null, 2),
);
await writeFile(
join(directory, artifact.sha256 + ".json"),
'{"tampered":true}',
);
expect(
(
await fetch(
base + "/internal/prepare-worker/artifacts/" + artifact.sha256,
{ headers: { authorization: "Bearer " + token } },
)
).status,
).toBe(409);
});
},
);
@@ -1,43 +0,0 @@
# Bounded Stage PREPARE workflow foundation
This slice is NOT a runtime executor, deployment mechanism, or full v4 completion. It enables authenticated proposal/Gate1/queue APIs and provides internal worker/CI service methods. Default worker/CI identity allowlists are empty: no browser or production execution route exists.
## Panel HTTP contract
All routes require existing JWT authentication with `Admin` or `SUPER_ADMIN`. Actor is exclusively `req.user.id ?? req.user.sub`, role exclusively `req.user.role`. Top-level unknown mutation fields return 400; client actor/profile fields are never trusted.
Base `/admin/orchestration`:
- `GET /tasks`: task array.
- `GET /tasks/:id`: task object.
- `GET /overview`: existing inventory items plus capabilities `{mutations:true, prepare:true, release:false, gate2Decisions:false, chat:false, runtime:false}`, reason `bounded_stage_prepare_only`.
- `POST /tasks`: existing CreateOrchestrationTaskDto `{key,title,department,operationMode:"PREPARE",budgetLimitCents,metadata:{commitSha,scope,acceptanceCriteria}}`; commitSha is required lowercase 40hex; scope is a non-blank string of at most 2000 characters; acceptanceCriteria is 1..20 non-blank strings of at most 500 characters each; budget is integer 20..10000 cents. Returns 201 projected task, state DRAFT/version1. Validated scope and acceptance criteria are persisted exactly and remain unchanged by workflow transitions. The internal `workflowScope:"STAGE_PREPARE"`, environment and createdBy are server-owned; input profile/actor/other arbitrary keys are discarded. Key max120, title max255, department max50. Proposal key is unique; sequential or concurrent duplicate keys return 409, without updating the original task or appending another proposal event. Fetch/reconcile the existing task rather than retry blindly.
- `PUT /tasks/:id/transition`: `{toState:"GATE1_PENDING"|"READY",expectedVersion,idempotencyKey,reason?}`. Only DRAFT->GATE1_PENDING and GATE1_APPROVED->READY. Owner or SUPER_ADMIN. Returns 200 projected task. READY atomically creates dispatch outbox. Requires unexpired Gate1.
- `POST /tasks/:id/gates/1/decide`: existing GateDecisionDto `{decision:"APPROVED"|"REJECTED",expectedVersion,idempotencyKey,expiresAt,notes?}`. SUPER_ADMIN independent from proposer. Future expiry <=24h. Returns 201 **projected task**, not decision object.
- Gate2 decision, budget writes/reconcile, command routes (including release), chat and kill-switch HTTP mutations remain 403. Runtime resource reads remain 503.
Task projection keeps existing scalar fields and safe nested runs/artifacts, decisions, events and ledger. Adds only `metadata:{scope,acceptanceCriteria,environment:"staging",commitSha}` for bounded proposals, otherwise `{}`. Never includes createdBy, workflowScope, payloads, URI, signatures, tokens or lease credentials. Pre-fix rows with the legacy scope sentinel remain readable/operable but have no recovered acceptance criteria: do not represent those as complete immutable scope review evidence.
`availableActions:string[]` is state/identity-derived: DRAFT owner -> `SUBMIT_GATE1`; GATE1_PENDING independent SUPER_ADMIN -> `APPROVE_GATE1`,`REJECT_GATE1`; GATE1_APPROVED owner/SUPER_ADMIN -> `QUEUE_PREPARE`; all worker/verification/Gate2 and legacy states -> `[]`. Actions indicate workflow eligibility, not a guarantee: current kill switch, approval expiry and concurrent versions are rechecked transactionally on mutation. Panel must not infer actions from state or send actor identity.
Common errors: 400 invalid DTO/binding; 403 wrong scope/identity/independence/kill/budget/expiry; 409 duplicate proposal key, stale version or idempotency payload mismatch. Transition/decision replay returns current persisted task and does not duplicate side effects.
## Internal service contracts (NOT browser endpoints)
`PrepareWorkflowService` is exported by OrchestrationModule. Trusted backend composition must override `PREPARE_WORKFLOW_CONFIG` with explicit `workerIds` and `stageCiIds`, default both empty. Do not populate from request bodies or user-selected runtime profiles. Worker identities require role WORKFLOW_WORKER AND ID allowlist; Stage identities require STAGE_CI AND separate ID allowlist. Credential/session provisioning and transport remain the integrating runtime owner's responsibility.
- `claim(identity, taskId?) -> null | {taskId,runId,attempt,leaseToken,leaseUntil,commitSha,environment:"staging",maxCostCents:20}`. Transactional task row lock with SKIP LOCKED, immutable run binding, 30s lease, max3 attempts. Each attempt reserves **a fixed hard upper bound of 20 cents**, not an estimated or measured departmental cost. Unknown cost on expired attempts remains reserved conservatively.
- `heartbeat(identity,{taskId,runId,leaseToken}) -> {leaseUntil}`. Same owner/token, unexpired active lease required.
- `complete(identity,{taskId,runId,leaseToken,sha256,uri,actualCents}) -> task`. QA success ingestion only; lowercase sha256, HTTPS URI, actual cost integer0..20 from trusted worker. Atomically records immutable QA artifact/attestation, SUCCEEDED run, reservation reconciliation, DONE outbox and VERIFYING task. Expired/stale/foreign token cannot finish. Not replayable after success; caller must read persisted task/run after response loss.
- `stageEvidence(identity,{taskId,runId,sha256,commitSha,evidenceSha256,uri}) -> task`. Independently allowlisted Stage CI identity, successful exact staging commit/run, registered QA subject, independent QA signer. Atomically records Stage artifact/attestation and reaches GATE2_PENDING. No release or Gate2 approval. Does not perform or claim deployment itself. Caller supplies actual trusted CI evidence, not browser assertions.
## Verification and explicit gaps
Real isolated PostgreSQL16, no published ports/no live volumes. Added migrations applied with ON_ERROR_STOP. TDD RED logs cover missing workflow behavior, heartbeat/QA behavior and HTTP enablement. Full backend regression excluding existing legacy release-containing orchestration.integration.spec: 106 suites /851 tests including seven real-DB workflow cases, build exit0. No RELEASE_AUTHORIZE service operation executed.
DB regressions: concurrent claim winner, queue race/replay mismatch, hard budget rollback, stale lease fencing, max3 attempts, conservative expired costs, kill switch, self approval, trusted IDs, QA reconciliation and Stage evidence to Gate2 pending. Test fixture artifact URIs/hashes are not real deployment evidence.
Remaining: actual authenticated runtime worker transport/executor and pinned CI evidence transport; shared department/company budget model and locking (NOT implemented or represented by fake totals); retry backoff/dead-letter UX/cancellation; hard total execution wall-time; durable request replay of completion/evidence; kill-switch concurrent insertion/version locking; migration rehearsal with full legacy schema; real Stage CI artifact/deployment verification. No push/deploy/live DB/runtime edits. Production release remains denied at HTTP boundary; unsafe legacy core release method is deliberately untouched and must never be called by this slice.
## Contract repair verification
Actual frontend inspection confirmed proposal submission sent human scope and acceptanceCriteria but omitted required commitSha. Frontend repair is separately assigned; no frontend file changed here. New proposals now require all three fields. Internal Stage restriction uses a separate server-owned workflowScope marker rather than overwriting user scope. No metadata update route exists in this bounded workflow.
TDD RED→GREEN against isolated PostgreSQL16 reproduced dropped scope/criteria, nine invalid metadata acceptances (including array-to-string commit coercion), and duplicate-key P2002 leakage. Final database suite: 24 cases, including authenticated HTTP create/list/detail persistence, 400 validation, and 409 duplicate responses. Full allowed backend regression: 106 suites / 868 tests passed; legacy orchestration.integration.spec.ts excluded to avoid executing RELEASE_AUTHORIZE. Build exit0. Scoped lint remains failing on inherited require-await/no-unnecessary-type-assertion errors (13 errors); no lint suppression or config change applied. Disposable DB only; no live edits/push/deploy.
@@ -1,90 +0,0 @@
import { Type } from 'class-transformer';
import {
IsEnum,
IsHash,
IsIn,
IsInt,
IsISO8601,
IsNotEmpty,
IsOptional,
IsString,
Max,
Min,
} from 'class-validator';
import { OperationMode, WorkflowState } from '../orchestration.domain';
export class CreateOrchestrationTaskDto {
@IsString() @IsNotEmpty() key!: string;
@IsString() @IsNotEmpty() title!: string;
@IsString() @IsNotEmpty() department!: string;
@IsEnum(OperationMode) operationMode!: OperationMode;
@Type(() => Number) @IsInt() @Min(0) budgetLimitCents!: number;
@IsOptional() metadata?: Record<string, unknown>;
}
export class TransitionTaskDto {
@IsEnum(WorkflowState) toState!: WorkflowState;
@Type(() => Number) @IsInt() @Min(1) expectedVersion!: number;
@IsString() @IsNotEmpty() idempotencyKey!: string;
@IsOptional() @IsString() reason?: string;
}
export class GateDecisionDto {
@IsIn(['APPROVED', 'REJECTED']) decision!: 'APPROVED' | 'REJECTED';
@Type(() => Number) @IsInt() @Min(1) expectedVersion!: number;
@IsString() @IsNotEmpty() idempotencyKey!: string;
@IsISO8601() expiresAt!: string;
@IsOptional() @IsString() notes?: string;
@IsOptional() @IsString() runId?: string;
@IsOptional() @IsHash('sha256') artifactHash?: string;
@IsOptional() @IsString() commitSha?: string;
@IsOptional() @IsString() environment?: string;
}
export class RecordBudgetDto {
@Type(() => Number) @IsInt() @Min(1) amountCents!: number;
@IsString() @IsNotEmpty() idempotencyKey!: string;
@IsString() @IsNotEmpty() kind!: string;
@IsOptional() metadata?: Record<string, unknown>;
}
export class SetKillSwitchDto {
@IsIn([
'FREEZE_NEW_WORK',
'STOP_AGENTS',
'DISABLE_MUTATIONS',
'EMERGENCY_HALT',
])
level!: string;
@IsString() @IsNotEmpty() reason!: string;
}
export class ReconcileBudgetDto {
@IsString() @IsNotEmpty() reservationId!: string;
@Type(() => Number) @IsInt() @Min(0) actualCents!: number;
@IsString() @IsNotEmpty() idempotencyKey!: string;
}
export class OrchestrationCommandDto {
@Type(() => Number) @IsInt() @Min(1) expectedVersion!: number;
@IsString() @IsNotEmpty() idempotencyKey!: string;
@IsOptional() @IsString() commitSha?: string;
@IsOptional()
@IsIn(['development', 'staging', 'production'])
environment?: string;
@IsOptional() @IsString() runId?: string;
@IsOptional() @IsString() approvalId?: string;
@IsOptional() @IsString() dependsOnTaskId?: string;
@IsOptional() @IsIn(['SUCCEEDED', 'FAILED']) status?: string;
@IsOptional()
@IsIn([
'TRANSIENT',
'RATE_LIMITED',
'DEPENDENCY',
'VALIDATION',
'POLICY',
'PERMANENT',
])
retryClass?: string;
@IsOptional() @IsHash('sha256') sha256?: string;
@IsOptional() @IsHash('sha256') artifactHash?: string;
@IsOptional() @IsHash('sha256') subjectHash?: string;
@IsOptional() @IsString() kind?: string;
@IsOptional() @IsString() uri?: string;
@IsOptional() predicate?: Record<string, unknown>;
@IsOptional() @IsString() signature?: string;
}
@@ -1,45 +0,0 @@
import { ForbiddenException } from '@nestjs/common';
import { KillSwitchService } from './kill-switch.service';
describe('KillSwitchService', () => {
const prisma = { orchestrationKillSwitch: { findUnique: jest.fn() } };
const service = new KillSwitchService(prisma as never);
beforeEach(() => jest.resetAllMocks());
it.each([
['FREEZE_NEW_WORK', 'CREATE_TASK'],
['STOP_AGENTS', 'RUN_AGENT'],
['DISABLE_MUTATIONS', 'MUTATE_PRODUCTION'],
['EMERGENCY_HALT', 'OBSERVE'],
])('blocks %s at its policy boundary', async (level, action) => {
prisma.orchestrationKillSwitch.findUnique.mockResolvedValue({
scope: 'GLOBAL',
level,
active: true,
});
await expect(service.assertAllowed(action as never)).rejects.toThrow(
ForbiddenException,
);
});
it('freezes new claims while allowing an already running agent to finish', async () => {
prisma.orchestrationKillSwitch.findUnique.mockResolvedValue({scope:'GLOBAL',level:'FREEZE_NEW_WORK',active:true});
await expect(service.assertAllowed('CLAIM_TASK' as never)).rejects.toThrow(ForbiddenException);
await expect(service.assertAllowed('RUN_AGENT')).resolves.toBeUndefined();
});
it('fails closed when an active persisted kill level is unknown', async () => {
prisma.orchestrationKillSwitch.findUnique.mockResolvedValue({scope:'GLOBAL',level:'CORRUPT_LEVEL',active:true});
await expect(service.assertAllowed('RUN_AGENT')).rejects.toThrow(ForbiddenException);
});
it('allows observation while production mutations are disabled', async () => {
prisma.orchestrationKillSwitch.findUnique.mockResolvedValue({
scope: 'GLOBAL',
level: 'DISABLE_MUTATIONS',
active: true,
});
await expect(service.assertAllowed('OBSERVE')).resolves.toBeUndefined();
});
});
@@ -1,36 +0,0 @@
import { ForbiddenException, Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { KillSwitchLevel } from './orchestration.domain';
export type GuardedAction =
| 'CREATE_TASK'
| 'CLAIM_TASK'
| 'RUN_AGENT'
| 'MUTATE_PRODUCTION'
| 'OBSERVE';
@Injectable()
export class KillSwitchService {
constructor(private readonly prisma: PrismaService) {}
async assertAllowed(action: GuardedAction): Promise<void> {
const state = await (this.prisma as any).orchestrationKillSwitch.findUnique(
{ where: { scope: 'GLOBAL' } },
);
if (!state?.active) return;
const blocked: Record<KillSwitchLevel, GuardedAction[]> = {
FREEZE_NEW_WORK: ['CREATE_TASK', 'CLAIM_TASK'],
STOP_AGENTS: ['CREATE_TASK', 'CLAIM_TASK', 'RUN_AGENT'],
DISABLE_MUTATIONS: ['CREATE_TASK', 'CLAIM_TASK', 'RUN_AGENT', 'MUTATE_PRODUCTION'],
EMERGENCY_HALT: [
'CREATE_TASK',
'CLAIM_TASK',
'RUN_AGENT',
'MUTATE_PRODUCTION',
'OBSERVE',
],
};
if (!Object.values(KillSwitchLevel).includes(state.level) ||
blocked[state.level as KillSwitchLevel].includes(action))
throw new ForbiddenException(
`Orchestration kill switch ${state.level} blocks ${action}`,
);
}
}
@@ -1,18 +0,0 @@
import { readFileSync } from 'node:fs';
import { join } from 'node:path';
describe('orchestration migration safety', () => {
it('is additive and never mutates legacy governance tables', () => {
const sql = readFileSync(
join(
process.cwd(),
'prisma/migrations/20261022000000_add_orchestration_v4_core/migration.sql',
),
'utf8',
);
expect(sql).not.toMatch(/^\s*(DROP|TRUNCATE|DELETE|UPDATE)\b/im);
expect(sql).not.toMatch(
/ALTER TABLE "(approval_requests|department_tasks|audit_logs)"/i,
);
expect(sql.match(/CREATE TABLE "orchestration_/g)).toHaveLength(9);
});
});
@@ -1,68 +0,0 @@
import { BadRequestException } from '@nestjs/common';
import { ModelTierPolicyService } from './model-tier-policy.service';
describe('ModelTierPolicyService', () => {
const policy = new ModelTierPolicyService();
it.each([
[
{
complexity: 0,
risk: 0,
operationMode: 'OBSERVE',
remainingBudgetCents: 1,
},
'L0',
],
[
{
complexity: 2,
risk: 1,
operationMode: 'PREPARE',
remainingBudgetCents: 100,
},
'L1',
],
[
{
complexity: 5,
risk: 4,
operationMode: 'PREPARE',
remainingBudgetCents: 500,
},
'L2',
],
[
{
complexity: 7,
risk: 7,
operationMode: 'PREPARE',
remainingBudgetCents: 1500,
},
'L3',
],
[
{
complexity: 9,
risk: 9,
operationMode: 'MUTATE_PRODUCTION',
remainingBudgetCents: 5000,
},
'L4',
],
])('selects a deterministic tier for policy inputs', (input, expected) => {
expect(policy.select(input as never)).toBe(expected);
expect(policy.select(input as never)).toBe(expected);
});
it('fails closed when the selected tier exceeds the remaining hard budget', () => {
expect(() =>
policy.select({
complexity: 9,
risk: 9,
operationMode: 'MUTATE_PRODUCTION',
remainingBudgetCents: 100,
}),
).toThrow(BadRequestException);
});
});
@@ -1,40 +0,0 @@
import { BadRequestException, Injectable } from '@nestjs/common';
import { OperationMode } from './orchestration.domain';
export type ModelTier = 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
@Injectable()
export class ModelTierPolicyService {
select(input: {
complexity: number;
risk: number;
operationMode: OperationMode | string;
remainingBudgetCents: number;
}): ModelTier {
const score =
Math.max(input.complexity, input.risk) +
(String(input.operationMode) === String(OperationMode.MUTATE_PRODUCTION)
? 1
: 0);
const tier: ModelTier =
score <= 1
? 'L0'
: score <= 3
? 'L1'
: score <= 5
? 'L2'
: score <= 8
? 'L3'
: 'L4';
const floor: Record<ModelTier, number> = {
L0: 1,
L1: 25,
L2: 100,
L3: 500,
L4: 2000,
};
if (input.remainingBudgetCents < floor[tier])
throw new BadRequestException(
`Hard budget cannot fund selected model tier ${tier}`,
);
return tier;
}
}
@@ -1,157 +0,0 @@
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { OrchestrationController } from './orchestration.controller';
import { OrchestrationService } from './orchestration.service';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { RolesGuard } from '../common/guards/roles.guard';
describe('integration read boundary', () => {
let app: INestApplication;
const task = {
id: 't1',
key: 'k',
title: 'Review',
department: 'SEO',
state: 'GATE2_APPROVED',
version: 1,
operationMode: 'PREPARE',
budgetLimitCents: 0,
metadata: { token: 'secret' },
runs: [
{
id: 'r',
status: 'VERIFIED',
commitSha: 'abc',
environment: 'stage',
artifacts: [
{
id: 'a',
sha256: 'f'.repeat(64),
sizeBytes: 1n,
uri: 'secret-uri',
metadata: { token: 'secret' },
},
],
},
],
events: [
{
id: 'e',
eventType: 'CREATED',
sequence: 1,
payload: { token: 'secret' },
},
],
};
const service = {
findAll: jest.fn(() => Promise.resolve([task])),
findOne: jest.fn(() => Promise.resolve(task)),
createTask: jest.fn(),
transition: jest.fn(),
decideGate: jest.fn(),
recordBudget: jest.fn(),
setKillSwitch: jest.fn(),
command: jest.fn(),
reconcileBudget: jest.fn(),
};
beforeAll(async () => {
const m = await Test.createTestingModule({
controllers: [OrchestrationController],
providers: [
{ provide: OrchestrationService, useValue: service },
RolesGuard,
],
})
.overrideGuard(JwtAuthGuard)
.useValue({
canActivate(c: any) {
const req = c.switchToHttp().getRequest();
if (!req.headers.authorization) return false;
req.user = { id: 'verified-user', role: req.headers.authorization };
return true;
},
})
.compile();
app = m.createNestApplication();
await app.init();
});
afterAll(async () => app.close());
it('denies every mutation before legacy core is invoked', async () => {
for (const [method, path] of [
['post', 'tasks'],
['put', 'tasks/t1/transition'],
['post', 'tasks/t1/gates/2/decide'],
['post', 'tasks/t1/budget'],
['post', 'tasks/t1/commands/RUN_CREATE'],
['post', 'tasks/t1/budget/reconcile'],
['put', 'kill-switch'],
['post', 'chat/messages'],
] as const) {
await request(app.getHttpServer())
[method]('/admin/orchestration/' + path)
.set('Authorization', 'Admin')
.send({})
.expect(path === 'tasks' || path.endsWith('/transition') ? 400 : 403);
}
for (const name of [
'createTask',
'transition',
'decideGate',
'recordBudget',
'setKillSwitch',
'command',
'reconcileBudget',
] as const)
expect(service[name]).not.toHaveBeenCalled();
});
it('projects list and detail with no actions, arbitrary secrets or BigInt transport failures', async () => {
for (const path of ['tasks', 'tasks/t1']) {
const r = await request(app.getHttpServer())
.get('/admin/orchestration/' + path)
.set('Authorization', 'Admin')
.expect(200);
const t = Array.isArray(r.body) ? r.body[0] : r.body;
expect(t.availableActions).toEqual([]);
expect(t.budgetLimitCents).toBe(0);
expect(JSON.stringify(t)).not.toMatch(/secret|sizeBytes|payload|token/);
}
});
it('returns actual inventory overview and explicit unavailable runtime resources', async () => {
const r = await request(app.getHttpServer())
.get('/admin/orchestration/overview')
.set('Authorization', 'Admin')
.expect(200);
expect(r.body.items).toEqual([
expect.objectContaining({ id: 'tasks', count: 1 }),
]);
expect(r.body.capabilities).toMatchObject({
mutations: false,
chat: false,
runtime: false,
});
for (const path of ['agents', 'schedules', 'model-policy'])
await request(app.getHttpServer())
.get('/admin/orchestration/' + path)
.set('Authorization', 'Admin')
.expect(503);
const releases = await request(app.getHttpServer())
.get('/admin/orchestration/releases')
.set('Authorization', 'Admin')
.expect(200);
expect(releases.body.items[0]).toMatchObject({
id: 'r',
commitSha: 'abc',
environment: 'stage',
});
});
it('protects read surfaces from anonymous and customer access', async () => {
await request(app.getHttpServer())
.get('/admin/orchestration/overview')
.expect(403);
await request(app.getHttpServer())
.get('/admin/orchestration/tasks')
.set('Authorization', 'CUSTOMER')
.expect(403);
});
});
@@ -1,230 +0,0 @@
import {
Controller,
Body,
Req,
Optional,
ValidationPipe,
Get,
Param,
Post,
Put,
UseGuards,
ForbiddenException,
ServiceUnavailableException,
} from '@nestjs/common';
import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { RolesGuard } from '../common/guards/roles.guard';
import { Roles } from '../common/decorators/roles.decorator';
import { OrchestrationService } from './orchestration.service';
import {
PrepareWorkflowService,
WorkflowIdentity,
} from './prepare-workflow.service';
import {
CreateOrchestrationTaskDto,
TransitionTaskDto,
GateDecisionDto,
} from './dto/orchestration.dto';
const workflowValidation = new ValidationPipe({
transform: true,
whitelist: true,
forbidNonWhitelisted: true,
});
// Explicit response allowlists: never serialize arbitrary JSON, signatures, URIs or BigInt.
function pick(row: any, keys: string[]) {
return Object.fromEntries(
keys.filter((k) => row[k] !== undefined).map((k) => [k, row[k]]),
);
}
function project(row: any) {
return {
...pick(row, [
'id',
'key',
'title',
'department',
'state',
'version',
'operationMode',
'budgetLimitCents',
]),
availableActions: [],
runs: (row.runs ?? []).map((run: any) => ({
...pick(run, ['id', 'commitSha', 'environment', 'status']),
artifacts: (run.artifacts ?? []).map((a: any) =>
pick(a, ['id', 'kind', 'sha256']),
),
})),
decisions: (row.decisions ?? []).map((d: any) =>
pick(d, [
'id',
'gate',
'decision',
'expiresAt',
'runId',
'artifactHash',
'commitSha',
'environment',
'createdAt',
]),
),
events: (row.events ?? []).map((e: any) =>
pick(e, [
'id',
'eventType',
'fromState',
'toState',
'sequence',
'createdAt',
]),
),
budgetLedger: (row.budgetLedger ?? []).map((b: any) =>
pick(b, ['id', 'amountCents', 'kind', 'createdAt']),
),
};
}
@ApiTags('Admin - Orchestration v4')
@ApiBearerAuth()
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('Admin', 'SUPER_ADMIN')
@Controller('admin/orchestration')
export class OrchestrationController {
constructor(
private readonly service: OrchestrationService,
@Optional() private readonly workflow?: PrepareWorkflowService,
) {}
private actor(req: any): WorkflowIdentity {
const id = req?.user?.id ?? req?.user?.sub;
if (
typeof id !== 'string' ||
!id ||
!['Admin', 'SUPER_ADMIN'].includes(req?.user?.role)
)
throw new ForbiddenException('Authenticated workflow identity required');
return { id, role: req.user.role };
}
private safe(row: any, req: any) {
const view = project(row);
if (!this.workflow) return view;
const w = this.workflow.project(row, this.actor(req));
return {
...view,
metadata: w.metadata,
availableActions: w.availableActions,
};
}
@Get('tasks') async all(@Req() req: any) {
return (await this.service.findAll()).map((row: any) =>
this.safe(row, req),
);
}
@Get('tasks/:id') async one(@Param('id') id: string, @Req() req: any) {
return this.safe(await this.service.findOne(id), req);
}
@Get('overview') async overview() {
const tasks = await this.service.findAll();
return {
items: [
{ id: 'tasks', title: 'Persisted task inventory', count: tasks.length },
],
measuredAt: new Date().toISOString(),
capabilities: {
mutations: !!this.workflow,
prepare: !!this.workflow,
release: false,
gate2Decisions: false,
chat: false,
runtime: false,
},
reason: this.workflow
? 'bounded_stage_prepare_only'
: 'security_hardening_pending',
};
}
@Get('releases') async releases() {
const tasks = await this.service.findAll();
const details = await Promise.all(
tasks.map((t: any) => this.service.findOne(t.id)),
);
return {
items: details.flatMap((t: any) =>
(t.runs ?? []).map((run: any) =>
pick(run, ['id', 'status', 'commitSha', 'environment']),
),
),
measuredAt: new Date().toISOString(),
};
}
@Get('agents') agents() {
throw new ServiceUnavailableException(
'Hermes runtime unavailable: trusted identity and runtime authentication not configured',
);
}
@Get('schedules') schedules() {
throw new ServiceUnavailableException(
'Hermes schedules unavailable; runtime remains disabled',
);
}
@Get('model-policy') models() {
throw new ServiceUnavailableException(
'No persisted model policy read contract available',
);
}
// Only the separate bounded PREPARE service is exposed; legacy commands remain denied.
@Post('tasks') async create(
@Body(workflowValidation) dto: CreateOrchestrationTaskDto,
@Req() req: any,
) {
if (!this.workflow) return this.deny();
return this.safe(await this.workflow.create(dto, this.actor(req)), req);
}
@Put('tasks/:id/transition') async transition(
@Param('id') id: string,
@Body(workflowValidation) dto: TransitionTaskDto,
@Req() req: any,
) {
if (!this.workflow) return this.deny();
return this.safe(
await this.workflow.transition(id, dto, this.actor(req)),
req,
);
}
@Post('tasks/:id/gates/:gate/decide') async decide(
@Param('id') id: string,
@Param('gate') gate: string,
@Body() body: unknown,
@Req() req: any,
) {
if (!this.workflow || gate !== '1') return this.deny();
const dto = await workflowValidation.transform(body, {
type: 'body',
metatype: GateDecisionDto,
});
return this.safe(
await this.workflow.decide(id, 1, dto, this.actor(req)),
req,
);
}
@Post('tasks/:id/budget') budget() {
return this.deny();
}
@Put('kill-switch') kill() {
return this.deny();
}
@Post('chat/messages') chat() {
return this.deny();
}
@Post('tasks/:id/commands/:command') command() {
return this.deny();
}
@Post('tasks/:id/budget/reconcile') reconcile() {
return this.deny();
}
private deny(): never {
throw new ForbiddenException(
'Orchestration mutations and chat disabled pending hardened core and trusted runtime integration',
);
}
}
@@ -1,47 +0,0 @@
import {
BadRequestException,
ConflictException,
ForbiddenException,
} from '@nestjs/common';
import {
assertTransition,
nextStateForGateDecision,
OperationMode,
WorkflowState,
} from './orchestration.domain';
describe('orchestration domain', () => {
it('allows only declared workflow transitions', () => {
expect(() =>
assertTransition(WorkflowState.DRAFT, WorkflowState.GATE1_PENDING),
).not.toThrow();
expect(() =>
assertTransition(WorkflowState.DRAFT, WorkflowState.RUNNING),
).toThrow(BadRequestException);
});
it('keeps gate 1 as execution authorization rather than release authorization', () => {
expect(nextStateForGateDecision(1, 'APPROVED')).toBe(
WorkflowState.GATE1_APPROVED,
);
expect(nextStateForGateDecision(2, 'APPROVED')).toBe(
WorkflowState.GATE2_APPROVED,
);
});
it('rejects an unsupported gate decision', () => {
expect(() => nextStateForGateDecision(1, 'PENDING' as never)).toThrow(
BadRequestException,
);
});
it.each([WorkflowState.GATE1_PENDING, WorkflowState.GATE2_PENDING])('does not revive an expired proposal into %s', (state) => {
expect(() => assertTransition(WorkflowState.EXPIRED,state)).toThrow(BadRequestException);
});
it('classifies production mutation separately from observe and prepare', () => {
expect(OperationMode.OBSERVE).toBe('OBSERVE');
expect(OperationMode.PREPARE).toBe('PREPARE');
expect(OperationMode.MUTATE_PRODUCTION).toBe('MUTATE_PRODUCTION');
});
});
@@ -1,106 +0,0 @@
import { BadRequestException } from '@nestjs/common';
export enum WorkflowState {
DRAFT = 'DRAFT',
GATE1_PENDING = 'GATE1_PENDING',
GATE1_APPROVED = 'GATE1_APPROVED',
READY = 'READY',
CLAIMED = 'CLAIMED',
RUNNING = 'RUNNING',
VERIFYING = 'VERIFYING',
GATE2_PENDING = 'GATE2_PENDING',
GATE2_APPROVED = 'GATE2_APPROVED',
RELEASING = 'RELEASING',
PRODUCTION_VERIFYING = 'PRODUCTION_VERIFYING',
LIVE_VERIFIED = 'LIVE_VERIFIED',
MEASURING = 'MEASURING',
CLOSED = 'CLOSED',
REJECTED = 'REJECTED',
BLOCKED = 'BLOCKED',
CANCELLED = 'CANCELLED',
FAILED = 'FAILED',
EXPIRED = 'EXPIRED',
}
export enum OperationMode {
OBSERVE = 'OBSERVE',
PREPARE = 'PREPARE',
MUTATE_PRODUCTION = 'MUTATE_PRODUCTION',
}
export enum RetryClass {
TRANSIENT = 'TRANSIENT',
RATE_LIMITED = 'RATE_LIMITED',
DEPENDENCY = 'DEPENDENCY',
VALIDATION = 'VALIDATION',
POLICY = 'POLICY',
PERMANENT = 'PERMANENT',
}
export enum KillSwitchLevel {
FREEZE_NEW_WORK = 'FREEZE_NEW_WORK',
STOP_AGENTS = 'STOP_AGENTS',
DISABLE_MUTATIONS = 'DISABLE_MUTATIONS',
EMERGENCY_HALT = 'EMERGENCY_HALT',
}
const transitions: Record<WorkflowState, WorkflowState[]> = {
DRAFT: [WorkflowState.GATE1_PENDING, WorkflowState.CANCELLED],
GATE1_PENDING: [
WorkflowState.GATE1_APPROVED,
WorkflowState.REJECTED,
WorkflowState.EXPIRED,
],
GATE1_APPROVED: [WorkflowState.READY, WorkflowState.CANCELLED],
READY: [
WorkflowState.CLAIMED,
WorkflowState.BLOCKED,
WorkflowState.CANCELLED,
],
CLAIMED: [
WorkflowState.RUNNING,
WorkflowState.READY,
WorkflowState.CANCELLED,
],
RUNNING: [
WorkflowState.VERIFYING,
WorkflowState.FAILED,
WorkflowState.BLOCKED,
],
VERIFYING: [
WorkflowState.GATE2_PENDING,
WorkflowState.FAILED,
WorkflowState.RUNNING,
],
GATE2_PENDING: [
WorkflowState.GATE2_APPROVED,
WorkflowState.REJECTED,
WorkflowState.EXPIRED,
],
GATE2_APPROVED: [WorkflowState.RELEASING, WorkflowState.CANCELLED],
RELEASING: [WorkflowState.PRODUCTION_VERIFYING, WorkflowState.FAILED],
PRODUCTION_VERIFYING: [WorkflowState.LIVE_VERIFIED, WorkflowState.FAILED],
LIVE_VERIFIED: [WorkflowState.MEASURING, WorkflowState.CLOSED],
MEASURING: [WorkflowState.CLOSED, WorkflowState.FAILED],
CLOSED: [],
REJECTED: [],
BLOCKED: [WorkflowState.READY, WorkflowState.CANCELLED],
CANCELLED: [],
FAILED: [WorkflowState.READY, WorkflowState.CANCELLED],
EXPIRED: [WorkflowState.CANCELLED],
};
export function assertTransition(from: WorkflowState, to: WorkflowState): void {
if (!transitions[from]?.includes(to))
throw new BadRequestException(
`Invalid orchestration transition ${from} -> ${to}`,
);
}
export function nextStateForGateDecision(
gate: 1 | 2,
decision: 'APPROVED' | 'REJECTED',
): WorkflowState {
if (!(['APPROVED', 'REJECTED'] as string[]).includes(decision))
throw new BadRequestException('Decision must be APPROVED or REJECTED');
return decision === 'REJECTED'
? WorkflowState.REJECTED
: gate === 1
? WorkflowState.GATE1_APPROVED
: WorkflowState.GATE2_APPROVED;
}
@@ -1,577 +0,0 @@
import { OrchestrationController } from './orchestration.controller';
import { DepartmentTasksController } from '../admin/department-tasks.controller';
import { ApprovalsController } from '../admin/approvals.controller';
import { PrismaClient } from '@prisma/client';
import { OrchestrationService } from './orchestration.service';
import { KillSwitchService } from './kill-switch.service';
import { WorkflowState, OperationMode } from './orchestration.domain';
const enabled = process.env.ORCHESTRATION_INTEGRATION === '1';
(enabled ? describe : describe.skip)(
'v4 disposable PostgreSQL invariants',
() => {
const db = new PrismaClient();
const service = new OrchestrationService(
db as never,
new KillSwitchService(db as never),
);
let n = 0;
async function task(state = 'DRAFT', budget = 100) {
return db.orchestrationTask.create({
data: {
key: `test-${Date.now()}-${n++}`,
title: 'test',
department: 'TEST',
operationMode: 'PREPARE',
state,
budgetLimitCents: budget,
},
});
}
afterAll(async () => db.$disconnect());
it('release rejects PREPARE operation class even with gate approval', async()=>{
const t=await task('GATE2_APPROVED');
await expect(service.command(t.id,'RELEASE_AUTHORIZE',{expectedVersion:1,idempotencyKey:`mode-${t.id}`},'ci')).rejects.toThrow(/operation mode/i);
});
it('append-only ledger rejects direct rewrites in PostgreSQL', async () => {
const t = await task();
const r = await service.recordBudget(
t.id,
{
amountCents: 50,
kind: 'RESERVE',
idempotencyKey: `immutable-${t.id}`,
},
'a',
);
await expect(
db.orchestrationBudgetLedger.update({
where: { id: r.id },
data: { amountCents: 0 },
}),
).rejects.toThrow(/append.only/i);
await expect(
db.orchestrationBudgetLedger.delete({ where: { id: r.id } }),
).rejects.toThrow(/append.only/i);
});
it('generic transitions cannot fake run lifecycle or production verification', async () => {
for (const [from, to] of [
['CLAIMED', 'RUNNING'],
['RUNNING', 'VERIFYING'],
['FAILED', 'READY'],
['PRODUCTION_VERIFYING', 'LIVE_VERIFIED'],
]) {
const t = await task(from);
await expect(
service.transition(
t.id,
{
expectedVersion: 1,
idempotencyKey: `fake-${t.id}`,
toState: to as WorkflowState,
},
'agent',
),
).rejects.toThrow(/dedicated/i);
}
});
it('exposes command and reconcile HTTP handlers', () => {
const c = new OrchestrationController(service);
expect(typeof c.command).toBe('function');
expect(typeof c.reconcile).toBe('function');
});
it('highest kill level blocks reads and reconciliation', async () => {
const t = await task();
const r = await service.recordBudget(
t.id,
{
kind: 'RESERVE',
amountCents: 10,
idempotencyKey: `stop-res-${t.id}`,
},
'a',
);
await service.setKillSwitch(
['EMERGENCY', 'HALT'].join('_'),
'test',
'ceo',
);
try {
await expect(service.findOne(t.id)).rejects.toThrow(/kill switch/i);
await expect(
service.reconcileBudget(
t.id,
{
reservationId: r.id,
actualCents: 0,
idempotencyKey: `stop-recon-${t.id}`,
},
'a',
),
).rejects.toThrow(/kill switch/i);
} finally {
await db.orchestrationKillSwitch.deleteMany();
}
});
it('legacy arbitrary status and approval endpoints fail closed', async () => {
await expect(
new DepartmentTasksController(db as never).create({
title: 'bypass',
status: 'DONE',
}),
).rejects.toThrow(/v4/i);
await expect(
new DepartmentTasksController(db as never).updateStatus('none', {
status: 'DONE',
}),
).rejects.toThrow(/v4/i);
await expect(
new ApprovalsController(db as never).decide('none', {
decision: 'APPROVED',
} as any),
).rejects.toThrow(/v4/i);
});
it('release consumes only matching fresh production Gate2 via dedicated command', async () => {
const t = await task('GATE2_PENDING');
const hash = 'f'.repeat(64),
commitSha = 'a'.repeat(40);
const r = await db.orchestrationRun.create({
data: {
taskId: t.id,
status: 'SUCCEEDED',
commitSha,
environment: 'production',
idempotencyKey: `rel-run-${t.id}`,
},
});
await db.orchestrationArtifact.create({
data: {
runId: r.id,
kind: 'BUILD',
uri: 'https://ci.example/build',
sha256: hash,
},
});
await db.orchestrationAttestation.create({
data: {
runId: r.id,
kind: 'TEST',
subjectHash: hash,
signer: 'ci',
predicate: { passed: true },
},
});
const decision = await service.decideGate(
t.id,
2,
{
decision: 'APPROVED',
expectedVersion: 1,
idempotencyKey: `rel-approve-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
runId: r.id,
artifactHash: hash,
commitSha,
environment: 'production',
},
'ceo',
);
const dto = {
expectedVersion: 2,
idempotencyKey: `rel-${t.id}`,
approvalId: decision.id,
runId: r.id,
artifactHash: hash,
commitSha,
environment: 'production',
};
await expect(
(service as any).command(
t.id,
'RELEASE_AUTHORIZE',
{ ...dto, artifactHash: '0'.repeat(64) },
'ci',
),
).rejects.toThrow(/binding/i);
const result = await (service as any).command(
t.id,
'RELEASE_AUTHORIZE',
dto,
'ci',
);
expect(result.authorized).toBe(true);
expect(
(await db.orchestrationTask.findUniqueOrThrow({ where: { id: t.id } }))
.state,
).toBe('RELEASING');
await expect(
(service as any).command(
t.id,
'RELEASE_AUTHORIZE',
{ ...dto, expectedVersion: 3, idempotencyKey: `rel-again-${t.id}` },
'ci',
),
).rejects.toThrow();
});
it('gate decision replay rejects changed immutable expiry and actor', async () => {
const t = await task('GATE1_PENDING');
const dto = {
decision: 'APPROVED' as const,
expectedVersion: 1,
idempotencyKey: `bind-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
};
await service.decideGate(t.id, 1, dto, 'ceo');
await expect(
service.decideGate(
t.id,
1,
{ ...dto, expiresAt: new Date(Date.now() + 120000).toISOString() },
'ceo',
),
).rejects.toThrow(/Idempotency/i);
await expect(service.decideGate(t.id, 1, dto, 'other')).rejects.toThrow(
/Idempotency/i,
);
});
it('dependencies block admission and reject cycles', async () => {
const a = await task();
const b = await task();
await (service as any).command(
a.id,
'DEPENDENCY_ADD',
{
expectedVersion: 1,
idempotencyKey: `dep-a-${a.id}`,
dependsOnTaskId: b.id,
},
'actor',
);
await expect(
(service as any).command(
b.id,
'DEPENDENCY_ADD',
{
expectedVersion: 1,
idempotencyKey: `dep-b-${b.id}`,
dependsOnTaskId: a.id,
},
'actor',
),
).rejects.toThrow(/cycle/i);
await db.orchestrationTask.update({
where: { id: a.id },
data: { state: 'GATE1_PENDING' },
});
await service.decideGate(
a.id,
1,
{
decision: 'APPROVED',
expectedVersion: 2,
idempotencyKey: `dep-approval-${a.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
},
'ceo',
);
await expect(
service.transition(
a.id,
{
toState: WorkflowState.READY,
expectedVersion: 3,
idempotencyKey: `dep-ready-${a.id}`,
},
'agent',
),
).rejects.toThrow(/dependency/i);
});
it('registers artifact and attestation for owned run, blocks unregistered subjects', async () => {
const t = await task('CLAIMED');
const base = {
expectedVersion: 1,
idempotencyKey: `life-${t.id}`,
commitSha: 'c'.repeat(40),
environment: 'staging',
};
const r = await (service as any).command(
t.id,
'RUN_CREATE',
base,
'agent',
);
const hash = 'd'.repeat(64);
const a = await (service as any).command(
t.id,
'ARTIFACT_ADD',
{
expectedVersion: 2,
idempotencyKey: `art-${t.id}`,
runId: r.id,
sha256: hash,
kind: 'BUILD',
uri: 'https://ci.example/artifact',
},
'agent',
);
expect(a.sha256).toBe(hash);
await expect(
(service as any).command(
t.id,
'ATTESTATION_ADD',
{
expectedVersion: 3,
idempotencyKey: `bad-att-${t.id}`,
runId: r.id,
subjectHash: 'e'.repeat(64),
kind: 'TEST',
predicate: { passed: true },
},
'ci',
),
).rejects.toThrow(/artifact/i);
const att = await (service as any).command(
t.id,
'ATTESTATION_ADD',
{
expectedVersion: 3,
idempotencyKey: `att-${t.id}`,
runId: r.id,
subjectHash: hash,
kind: 'TEST',
predicate: { passed: true },
},
'ci',
);
expect(att.signer).toBe('ci');
});
it('creates immutable versioned runs with bounded transient retries', async () => {
const t = await task('CLAIMED');
const dto = {
expectedVersion: 1,
idempotencyKey: `run-${t.id}`,
commitSha: 'a'.repeat(40),
environment: 'staging',
};
const r = await (service as any).command(
t.id,
'RUN_CREATE',
dto,
'agent',
);
expect(r.attempt).toBe(1);
expect(
await (service as any).command(t.id, 'RUN_CREATE', dto, 'agent'),
).toEqual(r);
await expect(
(service as any).command(
t.id,
'RUN_CREATE',
{ ...dto, commitSha: 'b'.repeat(40) },
'agent',
),
).rejects.toThrow(/Idempotency/i);
await (service as any).command(
t.id,
'RUN_FINISH',
{
expectedVersion: 2,
idempotencyKey: `finish-${t.id}`,
runId: r.id,
status: 'FAILED',
retryClass: 'POLICY',
},
'agent',
);
await expect(
(service as any).command(
t.id,
'RUN_CREATE',
{ ...dto, expectedVersion: 3, idempotencyKey: `retry-${t.id}` },
'agent',
),
).rejects.toThrow(/retry/i);
});
it('selects tier at admission using backend risk and budget', async () => {
const t = await task('GATE1_PENDING', 1000);
await service.decideGate(
t.id,
1,
{
decision: 'APPROVED',
expectedVersion: 1,
idempotencyKey: `approve-tier-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
},
'ceo',
);
await service.transition(
t.id,
{
toState: WorkflowState.READY,
expectedVersion: 2,
idempotencyKey: `admit-tier-${t.id}`,
},
'agent',
);
expect(
(await db.orchestrationTask.findUniqueOrThrow({ where: { id: t.id } }))
.modelTier,
).toBe('L0');
});
it('STOP_AGENTS prevents claims and running transitions', async () => {
await service.setKillSwitch('STOP_AGENTS', 'test', 'ceo');
try {
const t = await task('READY');
await expect(
service.transition(
t.id,
{
toState: WorkflowState.CLAIMED,
expectedVersion: 1,
idempotencyKey: `kill-${t.id}`,
},
'agent',
),
).rejects.toThrow(/kill switch/i);
} finally {
await db.orchestrationKillSwitch.deleteMany();
}
});
it('Gate1 admission consumes only unexpired approval', async () => {
const t = await task('GATE1_PENDING');
await service.decideGate(
t.id,
1,
{
decision: 'APPROVED',
expectedVersion: 1,
idempotencyKey: `approve-${t.id}`,
expiresAt: new Date(Date.now() + 100).toISOString(),
},
'ceo',
);
await new Promise((r) => setTimeout(r, 150));
await expect(
service.transition(
t.id,
{
toState: WorkflowState.READY,
expectedVersion: 2,
idempotencyKey: `admit-${t.id}`,
},
'agent',
),
).rejects.toThrow(/expired/i);
});
it('versioned transition replay returns original result and rejects changed payload', async () => {
const t = await task();
const dto = {
toState: WorkflowState.GATE1_PENDING,
expectedVersion: 1,
idempotencyKey: `tr-${t.id}`,
};
const first = await service.transition(t.id, dto, 'actor');
expect(await service.transition(t.id, dto, 'actor')).toEqual(first);
await expect(
service.transition(t.id, { ...dto, reason: 'different' }, 'actor'),
).rejects.toThrow(/Idempotency/i);
});
it('reconciles a reservation exactly once without erasing spent cost', async () => {
const t = await task();
const r = await service.recordBudget(
t.id,
{ amountCents: 80, kind: 'RESERVE', idempotencyKey: `res-${t.id}` },
'agent',
);
const dto = {
reservationId: r.id,
actualCents: 35,
idempotencyKey: `reconcile-${t.id}`,
};
await (service as any).reconcileBudget(t.id, dto, 'agent');
await (service as any).reconcileBudget(t.id, dto, 'agent');
await expect(
(service as any).reconcileBudget(
t.id,
{ ...dto, idempotencyKey: `second-${t.id}` },
'agent',
),
).rejects.toThrow(/reconciled/i);
expect(
(
await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
})
)._sum.amountCents,
).toBe(35);
await expect(
service.recordBudget(
t.id,
{
amountCents: 66,
kind: 'RESERVE',
idempotencyKey: `too-much-${t.id}`,
},
'agent',
),
).rejects.toThrow(/budget/i);
});
it('concurrent budget reservations never exceed hard cap and replay is harmless', async () => {
const t = await task();
const result = await Promise.allSettled(
Array.from({ length: 8 }, (_, i) =>
service.recordBudget(
t.id,
{
amountCents: 30,
kind: 'RESERVE',
idempotencyKey: `reserve-${t.id}-${i}`,
},
'agent',
),
),
);
expect(result.filter((x) => x.status === 'fulfilled')).toHaveLength(3);
const sum = await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
});
expect(sum._sum.amountCents).toBe(90);
const first = await db.orchestrationBudgetLedger.findFirstOrThrow({
where: { taskId: t.id },
});
await service.recordBudget(
t.id,
{
amountCents: 30,
kind: 'RESERVE',
idempotencyKey: first.idempotencyKey,
},
'agent',
);
expect(
await db.orchestrationBudgetLedger.count({ where: { taskId: t.id } }),
).toBe(3);
});
it('generic transition cannot approve gate 1', async () => {
const t = await task('GATE1_PENDING');
await expect(
service.transition(
t.id,
{
toState: WorkflowState.GATE1_APPROVED,
expectedVersion: 1,
idempotencyKey: `gate-bypass-${n}`,
},
'ceo',
),
).rejects.toThrow(/gate/i);
expect(
(await db.orchestrationTask.findUniqueOrThrow({ where: { id: t.id } }))
.state,
).toBe('GATE1_PENDING');
});
},
);
@@ -1,31 +0,0 @@
import {
PrepareWorkflowService,
PREPARE_WORKFLOW_CONFIG,
} from './prepare-workflow.service';
import { Module } from '@nestjs/common';
import { PrismaModule } from '../prisma/prisma.module';
import { KillSwitchService } from './kill-switch.service';
import { ModelTierPolicyService } from './model-tier-policy.service';
import { OrchestrationController } from './orchestration.controller';
import { OrchestrationService } from './orchestration.service';
@Module({
imports: [PrismaModule],
controllers: [OrchestrationController],
providers: [
OrchestrationService,
KillSwitchService,
ModelTierPolicyService,
PrepareWorkflowService,
{
provide: PREPARE_WORKFLOW_CONFIG,
useValue: { workerIds: [], stageCiIds: [] },
},
],
exports: [
OrchestrationService,
KillSwitchService,
ModelTierPolicyService,
PrepareWorkflowService,
],
})
export class OrchestrationModule {}
@@ -1,260 +0,0 @@
import {
BadRequestException,
ConflictException,
ForbiddenException,
} from '@nestjs/common';
import { OrchestrationService } from './orchestration.service';
function mockPrisma() {
const tx: any = {
$queryRaw: jest.fn().mockResolvedValue([]),
orchestrationTask: {
findUnique: jest.fn(),
create: jest.fn(),
updateMany: jest.fn(),
},
orchestrationRun: { findUnique: jest.fn(), create: jest.fn() },
orchestrationArtifact: { findFirst: jest.fn(), create: jest.fn() },
orchestrationAttestation: { create: jest.fn() },
orchestrationApprovalDecision: { findUnique: jest.fn(), create: jest.fn() },
orchestrationEvent: { findUnique: jest.fn(), create: jest.fn() },
orchestrationBudgetLedger: {
findUnique: jest.fn(),
aggregate: jest.fn(),
create: jest.fn(),
},
orchestrationKillSwitch: { findUnique: jest.fn(), upsert: jest.fn() },
};
tx.$transaction = jest.fn((cb: any) => Promise.resolve(cb(tx)));
return tx;
}
describe('OrchestrationService', () => {
let prisma: any;
let service: OrchestrationService;
beforeEach(() => {
prisma = mockPrisma();
service = new OrchestrationService(prisma, {
assertAllowed: jest.fn(),
} as never);
});
it('rejects an unknown kill level before overwriting persisted protection', async () => {
await expect(service.setKillSwitch('INVALID_LEVEL','test','admin')).rejects.toThrow(BadRequestException);
expect(prisma.orchestrationKillSwitch.upsert).not.toHaveBeenCalled();
});
it('creates a task and append-only event transactionally', async () => {
prisma.orchestrationTask.create.mockResolvedValue({
id: 'task-1',
state: 'DRAFT',
version: 1,
});
const result = await service.createTask(
{
key: 'seo-1',
title: 'SEO',
department: 'SEO',
operationMode: 'PREPARE' as never,
budgetLimitCents: 1000,
},
'actor-1',
);
expect(prisma.$transaction).toHaveBeenCalledTimes(1);
expect(prisma.orchestrationTask.create).toHaveBeenCalledWith({
data: expect.objectContaining({ state: 'DRAFT', version: 1 }),
});
expect(prisma.orchestrationEvent.create).toHaveBeenCalledWith({
data: expect.objectContaining({ eventType: 'TASK_CREATED', sequence: 1 }),
});
expect(result.id).toBe('task-1');
});
it('uses compare-and-swap versioning for transitions', async () => {
prisma.orchestrationTask.findUnique.mockResolvedValue({
id: 'task-1',
state: 'DRAFT',
version: 3,
});
prisma.orchestrationTask.updateMany.mockResolvedValue({ count: 0 });
await expect(
service.transition(
'task-1',
{
toState: 'GATE1_PENDING' as never,
expectedVersion: 3,
idempotencyKey: 'i-1',
},
'actor',
),
).rejects.toThrow(ConflictException);
});
it('makes gate decisions immutable and idempotent', async () => {
const expiresAt = new Date(Date.now() + 10000).toISOString();
prisma.orchestrationApprovalDecision.findUnique.mockResolvedValue({
id: 'd1',
decision: 'APPROVED',
gate: 1,
taskId: 'task-1',
});
prisma.orchestrationEvent.findUnique.mockResolvedValue({
payload: {
fingerprint: JSON.stringify({
taskId: 'task-1',
gate: 1,
dto: {
decision: 'APPROVED',
expectedVersion: 2,
idempotencyKey: 'gate-1',
expiresAt,
},
actorId: 'ceo',
}),
},
});
await expect(
service.decideGate(
'task-1',
1,
{
decision: 'APPROVED',
expectedVersion: 2,
idempotencyKey: 'gate-1',
expiresAt,
},
'ceo',
),
).resolves.toMatchObject({ id: 'd1' });
expect(prisma.orchestrationApprovalDecision.create).not.toHaveBeenCalled();
});
it('rejects an expired approval', async () => {
await expect(
service.decideGate(
'task-1',
1,
{
decision: 'APPROVED',
expectedVersion: 2,
idempotencyKey: 'gate-expired',
expiresAt: new Date(0).toISOString(),
},
'ceo',
),
).rejects.toThrow(BadRequestException);
});
it('binds gate 2 approval to run, artifact hash, commit and environment', async () => {
prisma.orchestrationApprovalDecision.findUnique.mockResolvedValue(null);
prisma.orchestrationTask.findUnique.mockResolvedValue({
id: 'task-1',
state: 'GATE2_PENDING',
version: 7,
});
prisma.orchestrationRun.findUnique.mockResolvedValue({
id: 'run-1',
taskId: 'task-1',
commitSha: 'abc123',
environment: 'staging',
status: 'SUCCEEDED',
});
prisma.orchestrationArtifact.findFirst.mockResolvedValue({
id: 'artifact-1',
runId: 'run-1',
sha256: 'f'.repeat(64),
});
prisma.orchestrationTask.updateMany.mockResolvedValue({ count: 1 });
prisma.orchestrationApprovalDecision.create.mockResolvedValue({
id: 'decision-2',
gate: 2,
});
await service.decideGate(
'task-1',
2,
{
decision: 'APPROVED',
expectedVersion: 7,
idempotencyKey: 'gate-2',
expiresAt: new Date(Date.now() + 10000).toISOString(),
runId: 'run-1',
artifactHash: 'f'.repeat(64),
commitSha: 'abc123',
environment: 'staging',
},
'ceo',
);
expect(prisma.orchestrationApprovalDecision.create).toHaveBeenCalledWith({
data: expect.objectContaining({
runId: 'run-1',
artifactHash: 'f'.repeat(64),
commitSha: 'abc123',
environment: 'staging',
}),
});
});
it.each(['RUNNING', 'FAILED', 'CANCELLED'])('refuses Gate 2 approval for an unfinished or unsuccessful %s run', async (status) => {
prisma.orchestrationTask.findUnique.mockResolvedValue({id:'task-1',state:'GATE2_PENDING',version:7});
prisma.orchestrationRun.findUnique.mockResolvedValue({id:'run-1',taskId:'task-1',commitSha:'abc123',environment:'staging',status});
prisma.orchestrationArtifact.findFirst.mockResolvedValue({id:'artifact-1'});
prisma.orchestrationTask.updateMany.mockResolvedValue({count:1});
await expect(service.decideGate('task-1',2,{
decision:'APPROVED',expectedVersion:7,idempotencyKey:'failed-run',
expiresAt:new Date(Date.now()+10000).toISOString(),runId:'run-1',
artifactHash:'f'.repeat(64),commitSha:'abc123',environment:'staging',
},'ceo')).rejects.toThrow(/successful run/i);
expect(prisma.orchestrationApprovalDecision.create).not.toHaveBeenCalled();
expect(prisma.orchestrationTask.updateMany).not.toHaveBeenCalled();
});
it('refuses gate 2 when binding does not match the immutable run', async () => {
prisma.orchestrationApprovalDecision.findUnique.mockResolvedValue(null);
prisma.orchestrationTask.findUnique.mockResolvedValue({
id: 'task-1',
state: 'GATE2_PENDING',
version: 7,
});
prisma.orchestrationRun.findUnique.mockResolvedValue({
id: 'run-1',
taskId: 'task-1',
commitSha: 'real',
environment: 'staging',
});
await expect(
service.decideGate(
'task-1',
2,
{
decision: 'APPROVED',
expectedVersion: 7,
idempotencyKey: 'gate-bad',
expiresAt: new Date(Date.now() + 10000).toISOString(),
runId: 'run-1',
artifactHash: 'f'.repeat(64),
commitSha: 'wrong',
environment: 'staging',
},
'ceo',
),
).rejects.toThrow(ForbiddenException);
});
it('enforces hard task budget atomically', async () => {
prisma.orchestrationTask.findUnique.mockResolvedValue({
id: 'task-1',
budgetLimitCents: 1000,
});
prisma.orchestrationBudgetLedger.aggregate.mockResolvedValue({
_sum: { amountCents: 900 },
});
await expect(
service.recordBudget(
'task-1',
{ amountCents: 101, idempotencyKey: 'cost-1', kind: 'SPEND' },
'agent',
),
).rejects.toThrow(ForbiddenException);
expect(prisma.orchestrationBudgetLedger.create).not.toHaveBeenCalled();
});
});
@@ -1,665 +0,0 @@
import {
BadRequestException,
ConflictException,
ForbiddenException,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import {
CreateOrchestrationTaskDto,
GateDecisionDto,
RecordBudgetDto,
TransitionTaskDto,
} from './dto/orchestration.dto';
import {
KillSwitchLevel,
assertTransition,
nextStateForGateDecision,
OperationMode,
WorkflowState,
} from './orchestration.domain';
import { ModelTierPolicyService } from './model-tier-policy.service';
import { KillSwitchService } from './kill-switch.service';
@Injectable()
export class OrchestrationService {
constructor(
private readonly prisma: PrismaService,
private readonly killSwitch: KillSwitchService,
) {}
async createTask(dto: CreateOrchestrationTaskDto, actorId: string) {
await this.killSwitch.assertAllowed('CREATE_TASK');
return await (this.prisma as any).$transaction(async (tx: any) => {
const task = await tx.orchestrationTask.create({
data: {
key: dto.key,
title: dto.title,
department: dto.department,
operationMode: dto.operationMode,
budgetLimitCents: dto.budgetLimitCents,
metadata: dto.metadata ?? {},
state: WorkflowState.DRAFT,
version: 1,
},
});
await tx.orchestrationEvent.create({
data: {
taskId: task.id,
eventType: 'TASK_CREATED',
fromState: null,
toState: WorkflowState.DRAFT,
sequence: 1,
actorId,
payload: { key: dto.key },
},
});
return task;
});
}
async transition(id: string, dto: TransitionTaskDto, actorId: string) {
if (
[
WorkflowState.GATE1_APPROVED,
WorkflowState.GATE2_APPROVED,
WorkflowState.RELEASING,
WorkflowState.RUNNING,
WorkflowState.VERIFYING,
WorkflowState.PRODUCTION_VERIFYING,
WorkflowState.LIVE_VERIFIED,
WorkflowState.MEASURING,
WorkflowState.CLOSED,
].includes(dto.toState)
)
throw new ForbiddenException(
'Gate approvals and release require dedicated commands',
);
return await (this.prisma as any).$transaction(async (tx: any) => {
await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${id}::uuid FOR UPDATE`;
const fingerprint = JSON.stringify({ id, dto, actorId });
const replay = await tx.orchestrationEvent.findUnique({
where: { idempotencyKey: dto.idempotencyKey },
});
if (replay) {
if (replay.payload.fingerprint !== fingerprint)
throw new ConflictException('Idempotency payload mismatch');
return replay.payload.result;
}
const existing = await tx.orchestrationTask.findUnique({ where: { id } });
if (!existing)
throw new NotFoundException(`Orchestration task ${id} not found`);
if (existing.state === WorkflowState.FAILED)
throw new ForbiddenException('Retries require dedicated run command');
assertTransition(existing.state, dto.toState);
await this.killSwitch.assertAllowed(
[
WorkflowState.READY,
WorkflowState.CLAIMED,
WorkflowState.RUNNING,
WorkflowState.VERIFYING,
WorkflowState.GATE2_PENDING,
].includes(dto.toState)
? 'RUN_AGENT'
: 'OBSERVE',
);
if ([WorkflowState.READY, WorkflowState.CLAIMED].includes(dto.toState))
await this.killSwitch.assertAllowed('CLAIM_TASK');
let selectedTier = existing.modelTier;
if (dto.toState === WorkflowState.READY) {
const dependencies = await tx.orchestrationDependency.findMany({
where: { taskId: id },
include: { dependsOnTask: true },
});
if (dependencies.some((d: any) => d.dependsOnTask.state !== 'CLOSED'))
throw new ForbiddenException('Unresolved dependency');
const costs = await tx.orchestrationBudgetLedger.aggregate({
where: { taskId: id },
_sum: { amountCents: true },
});
selectedTier = new ModelTierPolicyService().select({
complexity: Number(existing.metadata?.complexity ?? 0),
risk: Number(existing.metadata?.risk ?? 0),
operationMode: existing.operationMode,
remainingBudgetCents:
existing.budgetLimitCents - (costs._sum.amountCents ?? 0),
});
const approval = await tx.orchestrationApprovalDecision.findFirst({
where: { taskId: id, gate: 1, decision: 'APPROVED' },
orderBy: { createdAt: 'desc' },
});
if (!approval || approval.expiresAt <= new Date())
throw new ForbiddenException('Gate 1 approval missing or expired');
}
if (
existing.operationMode === OperationMode.MUTATE_PRODUCTION &&
dto.toState === WorkflowState.RELEASING
)
await this.killSwitch.assertAllowed('MUTATE_PRODUCTION');
const changed = await tx.orchestrationTask.updateMany({
where: { id, version: dto.expectedVersion, state: existing.state },
data: {
state: dto.toState,
modelTier: selectedTier,
version: { increment: 1 },
},
});
if (changed.count !== 1)
throw new ConflictException(
'Task version or state changed; reload before retrying',
);
await tx.orchestrationEvent.create({
data: {
taskId: id,
eventType: 'STATE_TRANSITION',
fromState: existing.state,
toState: dto.toState,
sequence: dto.expectedVersion + 1,
actorId,
idempotencyKey: dto.idempotencyKey,
payload: {
fingerprint,
result: JSON.parse(
JSON.stringify({
...existing,
state: dto.toState,
modelTier: selectedTier,
version: dto.expectedVersion + 1,
}),
),
},
},
});
return JSON.parse(
JSON.stringify({
...existing,
state: dto.toState,
modelTier: selectedTier,
version: dto.expectedVersion + 1,
}),
);
});
}
async decideGate(
taskId: string,
gate: 1 | 2,
dto: GateDecisionDto,
actorId: string,
) {
if (![1, 2].includes(gate)) throw new BadRequestException('Invalid gate');
return await (this.prisma as any).$transaction(async (tx: any) => {
await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${taskId}::uuid FOR UPDATE`;
const fingerprint = JSON.stringify({ taskId, gate, dto, actorId });
const prior = await tx.orchestrationApprovalDecision.findUnique({
where: { idempotencyKey: dto.idempotencyKey },
});
if (prior) {
const event = await tx.orchestrationEvent.findUnique({
where: { idempotencyKey: `event:${dto.idempotencyKey}` },
});
if (event?.payload?.fingerprint !== fingerprint)
throw new ConflictException('Idempotency payload mismatch');
return prior;
}
if (
!Number.isFinite(Date.parse(dto.expiresAt)) ||
new Date(dto.expiresAt) <= new Date()
)
throw new BadRequestException('Approval decision has expired');
await this.killSwitch.assertAllowed('OBSERVE');
const task = await tx.orchestrationTask.findUnique({
where: { id: taskId },
});
if (!task)
throw new NotFoundException(`Orchestration task ${taskId} not found`);
const expected =
gate === 1 ? WorkflowState.GATE1_PENDING : WorkflowState.GATE2_PENDING;
if (task.state !== expected)
throw new ConflictException(`Gate ${gate} requires ${expected}`);
if (gate === 2 && dto.decision === 'APPROVED') {
if (
!dto.runId ||
!dto.artifactHash ||
!dto.commitSha ||
!dto.environment
)
throw new BadRequestException(
'Gate 2 requires runId, artifactHash, commitSha and environment',
);
const run = await tx.orchestrationRun.findUnique({
where: { id: dto.runId },
});
if (
!run ||
run.taskId !== taskId ||
run.commitSha !== dto.commitSha ||
run.environment !== dto.environment
)
throw new ForbiddenException(
'Gate 2 binding does not match immutable run',
);
if (run.status !== 'SUCCEEDED')
throw new ForbiddenException('Gate 2 requires a successful run');
const artifact = await tx.orchestrationArtifact.findFirst({
where: { runId: dto.runId, sha256: dto.artifactHash },
});
if (!artifact)
throw new ForbiddenException(
'Gate 2 artifact hash is not registered for run',
);
}
const next = nextStateForGateDecision(gate, dto.decision);
const changed = await tx.orchestrationTask.updateMany({
where: { id: taskId, version: dto.expectedVersion, state: expected },
data: { state: next, version: { increment: 1 } },
});
if (changed.count !== 1)
throw new ConflictException(
'Task version or state changed; approval not applied',
);
const decision = await tx.orchestrationApprovalDecision.create({
data: {
taskId,
gate,
decision: dto.decision,
actorId,
notes: dto.notes,
expiresAt: new Date(dto.expiresAt),
idempotencyKey: dto.idempotencyKey,
runId: dto.runId,
artifactHash: dto.artifactHash,
commitSha: dto.commitSha,
environment: dto.environment,
},
});
await tx.orchestrationEvent.create({
data: {
taskId,
eventType: `GATE${gate}_${dto.decision}`,
fromState: expected,
toState: next,
sequence: dto.expectedVersion + 1,
actorId,
idempotencyKey: `event:${dto.idempotencyKey}`,
payload: { decisionId: decision.id, fingerprint },
},
});
return decision;
});
}
async recordBudget(taskId: string, dto: RecordBudgetDto, actorId: string) {
if (
!Number.isSafeInteger(dto.amountCents) ||
dto.amountCents < 1 ||
!['RESERVE', 'SPEND'].includes(dto.kind)
)
throw new BadRequestException(
'Use RESERVE or SPEND with positive integer cents',
);
return await (this.prisma as any).$transaction(async (tx: any) => {
await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${taskId}::uuid FOR UPDATE`;
const prior = await tx.orchestrationBudgetLedger.findUnique({
where: { idempotencyKey: dto.idempotencyKey },
});
if (prior) {
if (
prior.taskId !== taskId ||
prior.kind !== dto.kind ||
prior.amountCents !== dto.amountCents ||
prior.actorId !== actorId ||
JSON.stringify(prior.metadata) !== JSON.stringify(dto.metadata ?? {})
)
throw new ConflictException('Idempotency payload mismatch');
return prior;
}
await this.killSwitch.assertAllowed('RUN_AGENT');
const task = await tx.orchestrationTask.findUnique({
where: { id: taskId },
});
if (!task)
throw new NotFoundException(`Orchestration task ${taskId} not found`);
const sum = await tx.orchestrationBudgetLedger.aggregate({
where: { taskId },
_sum: { amountCents: true },
});
if ((sum._sum.amountCents ?? 0) + dto.amountCents > task.budgetLimitCents)
throw new ForbiddenException('Hard task budget exceeded');
return tx.orchestrationBudgetLedger.create({
data: {
taskId,
amountCents: dto.amountCents,
kind: dto.kind,
idempotencyKey: dto.idempotencyKey,
actorId,
metadata: dto.metadata ?? {},
},
});
});
}
async command(taskId: string, command: string, dto: any, actorId: string) {
return await (this.prisma as any).$transaction(async (tx: any) => {
await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${taskId}::uuid FOR UPDATE`;
const fingerprint = JSON.stringify({ taskId, command, dto, actorId });
const replay = await tx.orchestrationEvent.findUnique({
where: { idempotencyKey: dto.idempotencyKey },
});
if (replay) {
if (replay.payload.fingerprint !== fingerprint)
throw new ConflictException('Idempotency payload mismatch');
return replay.payload.result;
}
const task = await tx.orchestrationTask.findUnique({
where: { id: taskId },
});
if (!task) throw new NotFoundException('Task not found');
if (task.version !== dto.expectedVersion)
throw new ConflictException('Stale task version');
await this.killSwitch.assertAllowed('RUN_AGENT');
let result: any;
let state = task.state;
if (command === 'RUN_CREATE') {
if (
!/^[a-f0-9]{40,64}$/.test(dto.commitSha) ||
!['development', 'staging', 'production'].includes(dto.environment)
)
throw new BadRequestException('Invalid immutable run binding');
const last = await tx.orchestrationRun.findFirst({
where: { taskId },
orderBy: { attempt: 'desc' },
});
if (
last &&
(last.status !== 'FAILED' ||
!['TRANSIENT', 'RATE_LIMITED', 'DEPENDENCY'].includes(
last.retryClass,
) ||
last.attempt >= 3)
)
throw new ForbiddenException('Retry denied or exhausted');
if (!last && task.state !== 'CLAIMED')
throw new ConflictException('Run requires CLAIMED task');
result = await tx.orchestrationRun.create({
data: {
taskId,
attempt: (last?.attempt ?? 0) + 1,
status: 'RUNNING',
commitSha: dto.commitSha,
environment: dto.environment,
idempotencyKey: dto.idempotencyKey,
startedAt: new Date(),
},
});
state = 'RUNNING';
} else if (command === 'RUN_FINISH') {
const run = await tx.orchestrationRun.findUnique({
where: { id: dto.runId },
});
if (
!run ||
run.taskId !== taskId ||
run.status !== 'RUNNING' ||
task.state !== 'RUNNING'
)
throw new ConflictException('Active run required');
if (
!['SUCCEEDED', 'FAILED'].includes(dto.status) ||
(dto.status === 'FAILED' &&
![
'TRANSIENT',
'RATE_LIMITED',
'DEPENDENCY',
'VALIDATION',
'POLICY',
'PERMANENT',
].includes(dto.retryClass))
)
throw new BadRequestException('Invalid outcome taxonomy');
result = await tx.orchestrationRun.update({
where: { id: run.id },
data: {
status: dto.status,
retryClass: dto.status === 'FAILED' ? dto.retryClass : null,
finishedAt: new Date(),
},
});
state = dto.status === 'FAILED' ? 'FAILED' : 'VERIFYING';
} else if (command === 'ARTIFACT_ADD' || command === 'ATTESTATION_ADD') {
const run = await tx.orchestrationRun.findUnique({
where: { id: dto.runId },
});
if (
!run ||
run.taskId !== taskId ||
!['RUNNING', 'VERIFYING'].includes(task.state)
)
throw new ConflictException('Owned active run required');
const hash = command === 'ARTIFACT_ADD' ? dto.sha256 : dto.subjectHash;
if (!/^[a-f0-9]{64}$/.test(hash) || !dto.kind)
throw new BadRequestException('Invalid artifact hash or kind');
if (command === 'ARTIFACT_ADD') {
if (!/^https:\/\//.test(dto.uri))
throw new BadRequestException('Artifact URI must be HTTPS');
result = await tx.orchestrationArtifact.create({
data: { runId: run.id, kind: dto.kind, sha256: hash, uri: dto.uri },
});
} else {
if (
!(await tx.orchestrationArtifact.findFirst({
where: { runId: run.id, sha256: hash },
}))
)
throw new ForbiddenException(
'Attestation subject is not a registered artifact',
);
result = await tx.orchestrationAttestation.create({
data: {
runId: run.id,
kind: dto.kind,
subjectHash: hash,
predicate: dto.predicate ?? {},
signer: actorId,
signature: dto.signature,
},
});
}
} else if (command === 'DEPENDENCY_ADD') {
if (task.state !== 'DRAFT')
throw new ConflictException(
'Dependencies are frozen after submission',
);
await tx.$executeRaw`LOCK TABLE orchestration_dependencies IN EXCLUSIVE MODE`;
const cycles =
await tx.$queryRaw`WITH RECURSIVE chain(id) AS (SELECT ${dto.dependsOnTaskId}::uuid UNION SELECT d.depends_on_task_id FROM orchestration_dependencies d JOIN chain c ON d.task_id=c.id) SELECT id FROM chain WHERE id=${taskId}::uuid`;
if (cycles.length) throw new ForbiddenException('Dependency cycle');
result = await tx.orchestrationDependency.create({
data: { taskId, dependsOnTaskId: dto.dependsOnTaskId },
});
} else if (command === 'RELEASE_AUTHORIZE') {
await this.killSwitch.assertAllowed('MUTATE_PRODUCTION');
if (task.state !== 'GATE2_APPROVED')
throw new ConflictException(
'Gate 2 approval required; already consumed or invalid state',
);
const approval = await tx.orchestrationApprovalDecision.findUnique({
where: { id: dto.approvalId },
});
if (
!approval ||
approval.taskId !== taskId ||
approval.gate !== 2 ||
approval.decision !== 'APPROVED' ||
approval.expiresAt <= new Date()
)
throw new ForbiddenException('Gate 2 missing or expired');
for (const key of ['runId', 'artifactHash', 'commitSha', 'environment'])
if (approval[key] !== dto[key])
throw new ForbiddenException('Release binding mismatch');
const run = await tx.orchestrationRun.findUnique({
where: { id: dto.runId },
});
if (
!run ||
run.taskId !== taskId ||
run.status !== 'SUCCEEDED' ||
run.commitSha !== dto.commitSha ||
run.environment !== dto.environment
)
throw new ForbiddenException('Run binding mismatch');
if (
!(await tx.orchestrationArtifact.findFirst({
where: { runId: run.id, sha256: dto.artifactHash },
})) ||
!(await tx.orchestrationAttestation.findFirst({
where: {
runId: run.id,
subjectHash: dto.artifactHash,
kind: 'TEST',
},
}))
)
throw new ForbiddenException('Artifact evidence missing');
result = {
authorized: true,
approvalId: approval.id,
runId: run.id,
artifactHash: dto.artifactHash,
commitSha: dto.commitSha,
environment: dto.environment,
execution: 'CI_CD_ONLY',
};
state = 'RELEASING';
} else throw new BadRequestException('Unknown command');
await tx.orchestrationTask.update({
where: { id: taskId },
data: { state, version: { increment: 1 } },
});
const serialized = JSON.parse(JSON.stringify(result));
await tx.orchestrationEvent.create({
data: {
taskId,
eventType: command,
fromState: task.state,
toState: state,
sequence: task.version + 1,
actorId,
idempotencyKey: dto.idempotencyKey,
payload: { fingerprint, result: serialized },
},
});
return serialized;
});
}
async reconcileBudget(
taskId: string,
dto: { reservationId: string; actualCents: number; idempotencyKey: string },
actorId: string,
) {
await this.killSwitch.assertAllowed('OBSERVE');
if (!Number.isSafeInteger(dto.actualCents) || dto.actualCents < 0)
throw new BadRequestException('Invalid actual cost');
return await (this.prisma as any).$transaction(async (tx: any) => {
await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${taskId}::uuid FOR UPDATE`;
const prior = await tx.orchestrationBudgetLedger.findUnique({
where: { idempotencyKey: dto.idempotencyKey },
});
if (prior) {
if (
prior.taskId !== taskId ||
prior.actorId !== actorId ||
prior.metadata.reservationId !== dto.reservationId ||
prior.metadata.actualCents !== dto.actualCents
)
throw new ConflictException('Idempotency payload mismatch');
return prior;
}
const reservation = await tx.orchestrationBudgetLedger.findUnique({
where: { id: dto.reservationId },
});
if (
!reservation ||
reservation.taskId !== taskId ||
reservation.kind !== 'RESERVE'
)
throw new BadRequestException('Reservation not found');
if (
await tx.orchestrationBudgetLedger.findFirst({
where: {
taskId,
kind: 'RECONCILE',
metadata: { path: ['reservationId'], equals: dto.reservationId },
},
})
)
throw new ConflictException('Reservation already reconciled');
const task = await tx.orchestrationTask.findUnique({
where: { id: taskId },
});
const total = await tx.orchestrationBudgetLedger.aggregate({
where: { taskId },
_sum: { amountCents: true },
});
const delta = dto.actualCents - reservation.amountCents;
if (total._sum.amountCents + delta > task.budgetLimitCents)
throw new ForbiddenException('Hard task budget exceeded');
return tx.orchestrationBudgetLedger.create({
data: {
taskId,
kind: 'RECONCILE',
amountCents: delta,
idempotencyKey: dto.idempotencyKey,
actorId,
metadata: {
reservationId: dto.reservationId,
actualCents: dto.actualCents,
},
},
});
});
}
async findAll() {
await this.killSwitch.assertAllowed('OBSERVE');
return (this.prisma as any).orchestrationTask.findMany({
orderBy: { createdAt: 'desc' },
});
}
async findOne(id: string) {
await this.killSwitch.assertAllowed('OBSERVE');
const task = await (this.prisma as any).orchestrationTask.findUnique({
where: { id },
include: {
runs: { include: { artifacts: true, attestations: true } },
dependencies: true,
decisions: true,
events: { orderBy: { sequence: 'asc' } },
budgetLedger: true,
},
});
if (!task)
throw new NotFoundException(`Orchestration task ${id} not found`);
return task;
}
async setKillSwitch(level: string, reason: string, actorId: string) {
if (!Object.values(KillSwitchLevel).includes(level as KillSwitchLevel))
throw new BadRequestException('Invalid kill switch level');
return await (this.prisma as any).$transaction(async (tx: any) => {
const value = await tx.orchestrationKillSwitch.upsert({
where: { scope: 'GLOBAL' },
create: { scope: 'GLOBAL', level, active: true, reason, actorId },
update: {
level,
active: true,
reason,
actorId,
version: { increment: 1 },
},
});
await tx.orchestrationEvent.create({
data: {
eventType: 'KILL_SWITCH_CHANGED',
sequence: value.version ?? 1,
actorId,
payload: { scope: 'GLOBAL', level, reason },
},
});
return value;
});
}
}
@@ -1,137 +0,0 @@
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { OrchestrationController } from './orchestration.controller';
import { OrchestrationService } from './orchestration.service';
import { PrepareWorkflowService } from './prepare-workflow.service';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { RolesGuard } from '../common/guards/roles.guard';
describe('bounded workflow HTTP contracts', () => {
let app: INestApplication;
const t = {
id: 't',
key: 'k',
state: 'DRAFT',
version: 1,
metadata: {
scope: 'STAGE_PREPARE',
environment: 'staging',
commitSha: 'a'.repeat(40),
token: 'secret',
},
};
const workflow = {
create: jest.fn(async () => t),
transition: jest.fn(async () => t),
decide: jest.fn(async () => t),
project: jest.fn((row: any) => ({
...row,
metadata: {
scope: 'STAGE_PREPARE',
environment: 'staging',
commitSha: 'a'.repeat(40),
},
availableActions: ['SUBMIT_GATE1'],
})),
};
const core = {
findAll: async () => [t],
findOne: async () => t,
command: jest.fn(),
};
beforeAll(async () => {
const m = await Test.createTestingModule({
controllers: [OrchestrationController],
providers: [
{ provide: OrchestrationService, useValue: core },
{ provide: PrepareWorkflowService, useValue: workflow },
RolesGuard,
],
})
.overrideGuard(JwtAuthGuard)
.useValue({
canActivate(c: any) {
const req = c.switchToHttp().getRequest();
if (!req.headers.authorization) return false;
req.user = {
sub: 'verified-subject',
role: req.headers.authorization,
};
return true;
},
})
.compile();
app = m.createNestApplication();
await app.init();
});
afterAll(async () => {
await app.close();
});
it('accepts existing proposal DTO, derives actor from JWT sub and returns projected task', async () => {
const dto = {
key: 'k',
title: 'T',
department: 'ENGINEERING',
operationMode: 'PREPARE',
budgetLimitCents: 20,
metadata: {
commitSha: 'a'.repeat(40),
scope: 'Staging audit only',
acceptanceCriteria: ['QA passes'],
},
};
const r = await request(app.getHttpServer())
.post('/admin/orchestration/tasks')
.set('Authorization', 'Admin')
.send(dto)
.expect(201);
expect(workflow.create).toHaveBeenCalledWith(dto, {
id: 'verified-subject',
role: 'Admin',
});
expect(r.body.availableActions).toEqual(['SUBMIT_GATE1']);
expect(JSON.stringify(r.body)).not.toMatch(/token|secret/);
await request(app.getHttpServer())
.post('/admin/orchestration/tasks')
.set('Authorization', 'Admin')
.send({ ...dto, actorId: 'browser' })
.expect(400);
});
it('routes fixed transition/gate contracts and rejects invalid gates plus release without invoking core', async () => {
await request(app.getHttpServer())
.put('/admin/orchestration/tasks/t/transition')
.set('Authorization', 'Admin')
.send({
toState: 'GATE1_PENDING',
expectedVersion: 1,
idempotencyKey: 'submit',
})
.expect(200);
await request(app.getHttpServer())
.post('/admin/orchestration/tasks/t/gates/1/decide')
.set('Authorization', 'SUPER_ADMIN')
.send({
decision: 'APPROVED',
expectedVersion: 2,
idempotencyKey: 'approval',
expiresAt: new Date(Date.now() + 60000).toISOString(),
})
.expect(201);
expect(workflow.decide).toHaveBeenCalledWith('t', 1, expect.any(Object), {
id: 'verified-subject',
role: 'SUPER_ADMIN',
});
await request(app.getHttpServer())
.post('/admin/orchestration/tasks/t/gates/2/decide')
.set('Authorization', 'SUPER_ADMIN')
.send({})
.expect(403);
await request(app.getHttpServer())
.post('/admin/orchestration/tasks/t/commands/RELEASE_AUTHORIZE')
.set('Authorization', 'SUPER_ADMIN')
.send({})
.expect(403);
expect(core.command).not.toHaveBeenCalled();
});
});
@@ -1,559 +0,0 @@
import {
Injectable,
Inject,
ForbiddenException,
BadRequestException,
ConflictException,
NotFoundException,
} from '@nestjs/common';
import { randomUUID } from 'crypto';
import { PrismaService } from '../prisma/prisma.service';
export const PREPARE_WORKFLOW_CONFIG = 'PREPARE_WORKFLOW_CONFIG';
export interface WorkflowIdentity {
id: string;
role: string;
}
export interface WorkflowConfig {
workerIds: string[];
stageCiIds: string[];
}
/** Bounded Stage preparation only. No release executor, production scope or browser worker identities. */
@Injectable()
export class PrepareWorkflowService {
constructor(
@Inject(PrismaService) private readonly db: any,
@Inject(PREPARE_WORKFLOW_CONFIG) private readonly config: WorkflowConfig,
) {}
private identity(a: WorkflowIdentity, roles: string[]) {
if (
!a?.id ||
typeof a.id !== 'string' ||
a.id.length > 100 ||
!roles.includes(a.role)
)
throw new ForbiddenException('Authenticated workflow identity required');
}
private worker(a: WorkflowIdentity) {
this.identity(a, ['WORKFLOW_WORKER']);
if (!this.config.workerIds.includes(a.id))
throw new ForbiddenException('Worker identity not provisioned');
}
private async allowed(tx: any, claiming = false) {
const rows =
await tx.$queryRaw`SELECT level, active FROM orchestration_kill_switches WHERE scope = 'GLOBAL' FOR SHARE`;
if (rows[0]?.active && !(rows[0].level === 'FREEZE_NEW_WORK' && !claiming))
throw new ForbiddenException('Kill switch blocks workflow');
}
private async task(tx: any, id: string) {
await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${id}::uuid FOR UPDATE`;
const t = await tx.orchestrationTask.findUnique({ where: { id } });
if (!t) throw new NotFoundException('Task not found');
if (
t.operationMode !== 'PREPARE' ||
(t.metadata?.workflowScope ?? t.metadata?.scope) !== 'STAGE_PREPARE'
)
throw new ForbiddenException('Not a bounded Stage proposal');
return t;
}
private async event(
tx: any,
t: any,
state: string,
a: WorkflowIdentity,
key: string,
type: string,
fingerprint: string,
) {
const result = await tx.orchestrationTask.update({
where: { id: t.id },
data: { state, version: { increment: 1 } },
});
await tx.orchestrationEvent.create({
data: {
taskId: t.id,
sequence: result.version,
actorId: a.id,
eventType: type,
fromState: t.state,
toState: state,
idempotencyKey: key,
payload: { fingerprint },
},
});
return result;
}
private async replay(tx: any, key: string, fingerprint: string) {
const e = await tx.orchestrationEvent.findUnique({
where: { idempotencyKey: key },
});
if (e && e.payload?.fingerprint !== fingerprint)
throw new ConflictException('Idempotency payload mismatch');
return e;
}
private version(t: any, dto: any) {
if (
!Number.isSafeInteger(dto.expectedVersion) ||
dto.expectedVersion !== t.version
)
throw new ConflictException('Stale task version');
if (
typeof dto.idempotencyKey !== 'string' ||
!dto.idempotencyKey.length ||
dto.idempotencyKey.length > 120
)
throw new BadRequestException('Invalid idempotency key');
}
async create(dto: any, a: WorkflowIdentity) {
this.identity(a, ['Admin', 'SUPER_ADMIN']);
const metadata = dto?.metadata;
const boundedText = (value: unknown, max: number) =>
typeof value === 'string' &&
value.trim().length > 0 &&
value.length <= max;
if (
!metadata ||
typeof metadata !== 'object' ||
Array.isArray(metadata) ||
typeof metadata.commitSha !== 'string' ||
!boundedText(metadata.scope, 2000) ||
!Array.isArray(metadata.acceptanceCriteria) ||
metadata.acceptanceCriteria.length < 1 ||
metadata.acceptanceCriteria.length > 20 ||
!metadata.acceptanceCriteria.every((criterion: unknown) =>
boundedText(criterion, 500),
)
)
throw new BadRequestException(
'PREPARE requires commitSha, scope 1..2000 characters and 1..20 acceptance criteria of 1..500 characters',
);
if (
dto.operationMode !== 'PREPARE' ||
!/^[a-f0-9]{40}$/.test(dto.metadata?.commitSha ?? '') ||
!Number.isSafeInteger(dto.budgetLimitCents) ||
dto.budgetLimitCents < 20 ||
dto.budgetLimitCents > 10000
)
throw new BadRequestException(
'PREPARE requires immutable 40hex commit and budget 20..10000 cents',
);
if (
!dto.key ||
dto.key.length > 120 ||
!dto.title ||
dto.title.length > 255 ||
!dto.department ||
dto.department.length > 50
)
throw new BadRequestException('Invalid proposal fields');
return this.db
.$transaction(async (tx: any) => {
await this.allowed(tx, true);
const t = await tx.orchestrationTask.create({
data: {
key: dto.key,
title: dto.title,
department: dto.department,
operationMode: 'PREPARE',
budgetLimitCents: dto.budgetLimitCents,
metadata: {
workflowScope: 'STAGE_PREPARE',
scope: dto.metadata.scope,
acceptanceCriteria: [...dto.metadata.acceptanceCriteria],
environment: 'staging',
commitSha: dto.metadata.commitSha,
createdBy: a.id,
},
state: 'DRAFT',
},
});
await tx.orchestrationEvent.create({
data: {
taskId: t.id,
sequence: 1,
eventType: 'PREPARE_PROPOSED',
actorId: a.id,
toState: 'DRAFT',
},
});
return t;
})
.catch((error: any) => {
if (
error?.code === 'P2002' &&
Array.isArray(error.meta?.target) &&
error.meta.target.includes('key')
)
throw new ConflictException(
'Proposal key already exists; fetch and reconcile the existing task',
);
throw error;
});
}
async transition(id: string, dto: any, a: WorkflowIdentity) {
this.identity(a, ['Admin', 'SUPER_ADMIN']);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx, true);
const t = await this.task(tx, id);
const fingerprint = JSON.stringify({ id, dto, a });
if (await this.replay(tx, dto.idempotencyKey, fingerprint)) return t;
this.version(t, dto);
if (t.metadata.createdBy !== a.id && a.role !== 'SUPER_ADMIN')
throw new ForbiddenException('Proposal owner required');
if (
!(
(t.state === 'DRAFT' && dto.toState === 'GATE1_PENDING') ||
(t.state === 'GATE1_APPROVED' && dto.toState === 'READY')
)
)
throw new ForbiddenException(
'Only submission and approved queueing are available',
);
if (dto.toState === 'READY') {
const approval = await tx.orchestrationApprovalDecision.findFirst({
where: { taskId: id, gate: 1, decision: 'APPROVED' },
orderBy: { createdAt: 'desc' },
});
if (!approval || approval.expiresAt <= new Date())
throw new ForbiddenException('Gate1 expired');
await tx.prepareWorkflowOutbox.create({ data: { taskId: id } });
}
return this.event(
tx,
t,
dto.toState,
a,
dto.idempotencyKey,
'PREPARE_TRANSITION',
fingerprint,
);
});
}
async decide(id: string, gate: number, dto: any, a: WorkflowIdentity) {
this.identity(a, ['SUPER_ADMIN']);
if (gate !== 1)
throw new ForbiddenException(
'Gate2 decisions and release remain disabled',
);
if (
!['APPROVED', 'REJECTED'].includes(dto.decision) ||
!Number.isFinite(Date.parse(dto.expiresAt)) ||
Date.parse(dto.expiresAt) <= Date.now() ||
Date.parse(dto.expiresAt) > Date.now() + 86400000
)
throw new BadRequestException(
'Decision requires future expiry within 24 hours',
);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx);
const t = await this.task(tx, id);
const fingerprint = JSON.stringify({ id, gate, dto, a });
if (await this.replay(tx, dto.idempotencyKey, fingerprint)) return t;
this.version(t, dto);
if (t.metadata.createdBy === a.id)
throw new ForbiddenException('Independent reviewer required');
if (t.state !== 'GATE1_PENDING')
throw new ConflictException('Gate1 pending required');
await tx.orchestrationApprovalDecision.create({
data: {
taskId: id,
gate: 1,
decision: dto.decision,
actorId: a.id,
expiresAt: new Date(dto.expiresAt),
idempotencyKey: `decision:${dto.idempotencyKey}`,
},
});
return this.event(
tx,
t,
dto.decision === 'APPROVED' ? 'GATE1_APPROVED' : 'REJECTED',
a,
dto.idempotencyKey,
'PREPARE_GATE1',
fingerprint,
);
});
}
async claim(a: WorkflowIdentity, id?: string): Promise<any> {
this.worker(a);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx, true);
// Lock order is task then outbox for every worker operation. SKIP LOCKED permits competing workers.
const rows: any[] = id
? await tx.$queryRaw`SELECT t.id FROM orchestration_tasks t JOIN prepare_workflow_outbox o ON o.task_id=t.id WHERE t.id=${id}::uuid AND o.status='PENDING' AND (o.lease_until IS NULL OR o.lease_until < now()) ORDER BY o.created_at FOR UPDATE OF t SKIP LOCKED LIMIT 1`
: await tx.$queryRaw`SELECT t.id FROM orchestration_tasks t JOIN prepare_workflow_outbox o ON o.task_id=t.id WHERE o.status='PENDING' AND (o.lease_until IS NULL OR o.lease_until < now()) ORDER BY o.created_at FOR UPDATE OF t SKIP LOCKED LIMIT 1`;
if (!rows.length) return null;
const t = await this.task(tx, rows[0].id);
const o = await tx.prepareWorkflowOutbox.findUnique({
where: { taskId: t.id },
});
const approval = await tx.orchestrationApprovalDecision.findFirst({
where: { taskId: t.id, gate: 1, decision: 'APPROVED' },
orderBy: { createdAt: 'desc' },
});
if (!approval || approval.expiresAt <= new Date())
throw new ForbiddenException('Gate1 expired');
if (o.attempts >= 3) throw new ForbiddenException('Attempts exhausted');
const costs = await tx.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
});
if ((costs._sum.amountCents ?? 0) + 20 > t.budgetLimitCents)
throw new ForbiddenException('Hard task budget exceeded');
if (o.runId)
await tx.orchestrationRun.update({
where: { id: o.runId },
data: {
status: 'FAILED',
retryClass: 'TRANSIENT',
finishedAt: new Date(),
},
});
const token = randomUUID(),
attempt = o.attempts + 1;
const run = await tx.orchestrationRun.create({
data: {
taskId: t.id,
attempt,
status: 'RUNNING',
environment: 'staging',
commitSha: t.metadata.commitSha,
idempotencyKey: `prepare-run:${o.id}:${attempt}`,
startedAt: new Date(),
},
});
const reservation = await tx.orchestrationBudgetLedger.create({
data: {
taskId: t.id,
amountCents: 20,
kind: 'RESERVE',
actorId: a.id,
idempotencyKey: `prepare-reserve:${run.id}`,
},
});
const leaseUntil = new Date(Date.now() + 30000);
await tx.prepareWorkflowOutbox.update({
where: { id: o.id },
data: {
attempts: attempt,
leaseOwner: a.id,
leaseToken: token,
leaseUntil,
heartbeatAt: new Date(),
runId: run.id,
reservationId: reservation.id,
},
});
await this.event(
tx,
t,
'RUNNING',
a,
`prepare-claim:${run.id}`,
'PREPARE_CLAIMED',
token,
);
return {
taskId: t.id,
runId: run.id,
attempt,
leaseToken: token,
leaseUntil,
commitSha: run.commitSha,
environment: 'staging',
maxCostCents: 20,
};
});
}
private async lease(tx: any, a: WorkflowIdentity, dto: any) {
const t = await this.task(tx, dto.taskId);
const o = await tx.prepareWorkflowOutbox.findUnique({
where: { taskId: t.id },
});
if (
!o ||
o.status !== 'PENDING' ||
o.leaseOwner !== a.id ||
o.leaseToken !== dto.leaseToken ||
o.runId !== dto.runId ||
!o.leaseUntil ||
o.leaseUntil <= new Date() ||
t.state !== 'RUNNING'
)
throw new ForbiddenException('Active owned lease required');
return { t, o };
}
async heartbeat(a: WorkflowIdentity, dto: any) {
this.worker(a);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx);
const { o } = await this.lease(tx, a, dto);
return tx.prepareWorkflowOutbox.update({
where: { id: o.id },
data: {
heartbeatAt: new Date(),
leaseUntil: new Date(Date.now() + 30000),
},
select: { leaseUntil: true },
});
});
}
async complete(a: WorkflowIdentity, dto: any) {
this.worker(a);
if (
!/^[a-f0-9]{64}$/.test(dto.sha256 ?? '') ||
!/^https:\/\//.test(dto.uri ?? '') ||
!Number.isSafeInteger(dto.actualCents) ||
dto.actualCents < 0 ||
dto.actualCents > 20
)
throw new BadRequestException(
'QA hash, HTTPS URI and cost 0..20 required',
);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx);
const { t, o } = await this.lease(tx, a, dto);
await tx.orchestrationArtifact.create({
data: { runId: o.runId, kind: 'QA', sha256: dto.sha256, uri: dto.uri },
});
await tx.orchestrationAttestation.create({
data: {
runId: o.runId,
kind: 'QA',
subjectHash: dto.sha256,
signer: a.id,
predicate: { passed: true, scope: 'STAGE_PREPARE' },
},
});
await tx.orchestrationRun.update({
where: { id: o.runId },
data: { status: 'SUCCEEDED', finishedAt: new Date() },
});
await tx.orchestrationBudgetLedger.create({
data: {
taskId: t.id,
kind: 'RECONCILE',
amountCents: dto.actualCents - 20,
actorId: a.id,
idempotencyKey: `prepare-cost:${o.runId}`,
metadata: {
reservationId: o.reservationId,
actualCents: dto.actualCents,
},
},
});
await tx.prepareWorkflowOutbox.update({
where: { id: o.id },
data: { status: 'DONE', leaseToken: null, leaseUntil: null },
});
return this.event(
tx,
t,
'VERIFYING',
a,
`prepare-qa:${o.runId}`,
'PREPARE_QA_SUCCEEDED',
dto.sha256,
);
});
}
async stageEvidence(a: WorkflowIdentity, dto: any) {
this.identity(a, ['STAGE_CI']);
if (!this.config.stageCiIds.includes(a.id))
throw new ForbiddenException('Stage CI identity not provisioned');
if (
!/^[a-f0-9]{64}$/.test(dto.evidenceSha256 ?? '') ||
!/^https:\/\//.test(dto.uri ?? '')
)
throw new BadRequestException(
'Stage evidence hash and HTTPS URI required',
);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx);
const t = await this.task(tx, dto.taskId);
const run = await tx.orchestrationRun.findUnique({
where: { id: dto.runId },
});
if (
t.state !== 'VERIFYING' ||
!run ||
run.taskId !== t.id ||
run.environment !== 'staging' ||
run.status !== 'SUCCEEDED' ||
run.commitSha !== dto.commitSha ||
t.metadata.commitSha !== dto.commitSha
)
throw new ForbiddenException(
'Immutable successful Stage run binding required',
);
const qa = await tx.orchestrationAttestation.findFirst({
where: { runId: run.id, kind: 'QA', subjectHash: dto.sha256 },
});
if (!qa || qa.signer === a.id)
throw new ForbiddenException('Independent QA evidence required');
await tx.orchestrationArtifact.create({
data: {
runId: run.id,
kind: 'STAGE_EVIDENCE',
sha256: dto.evidenceSha256,
uri: dto.uri,
},
});
await tx.orchestrationAttestation.create({
data: {
runId: run.id,
kind: 'STAGE',
subjectHash: dto.sha256,
signer: a.id,
predicate: {
evidenceSha256: dto.evidenceSha256,
commitSha: dto.commitSha,
environment: 'staging',
},
},
});
return this.event(
tx,
t,
'GATE2_PENDING',
a,
`prepare-stage:${run.id}`,
'STAGE_EVIDENCE_RECORDED',
dto.evidenceSha256,
);
});
}
project(t: any, a: WorkflowIdentity) {
const safe =
t.operationMode === 'PREPARE' &&
(t.metadata?.workflowScope ?? t.metadata?.scope) === 'STAGE_PREPARE';
const owner =
a?.id && (t.metadata?.createdBy === a.id || a.role === 'SUPER_ADMIN');
const actions: string[] = [];
if (safe && owner && t.state === 'DRAFT') actions.push('SUBMIT_GATE1');
if (safe && owner && t.state === 'GATE1_APPROVED')
actions.push('QUEUE_PREPARE');
if (
safe &&
a?.role === 'SUPER_ADMIN' &&
t.metadata?.createdBy !== a.id &&
t.state === 'GATE1_PENDING'
)
actions.push('APPROVE_GATE1', 'REJECT_GATE1');
return {
...t,
metadata: safe
? {
scope: t.metadata.scope,
...(t.metadata.workflowScope === 'STAGE_PREPARE'
? { acceptanceCriteria: t.metadata.acceptanceCriteria }
: {}),
environment: 'staging',
commitSha: t.metadata.commitSha,
}
: {},
availableActions: actions,
};
}
}
@@ -1,513 +0,0 @@
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { OrchestrationController } from './orchestration.controller';
import { OrchestrationService } from './orchestration.service';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { RolesGuard } from '../common/guards/roles.guard';
import { PrismaClient } from '@prisma/client';
import { PrepareWorkflowService } from './prepare-workflow.service';
import { OperationMode, WorkflowState } from './orchestration.domain';
const enabled = process.env.WORKFLOW_DB === '1';
(enabled ? describe : describe.skip)('isolated prepare workflow', () => {
const db = new PrismaClient();
const admin = { id: 'proposer', role: 'Admin' };
const reviewer = { id: 'reviewer', role: 'SUPER_ADMIN' };
const worker = { id: 'worker-1', role: 'WORKFLOW_WORKER' };
const ci = { id: 'isolated-ci', role: 'STAGE_CI' };
const service = new PrepareWorkflowService(db as never, {
workerIds: ['worker-1', 'worker-2'],
stageCiIds: ['isolated-ci'],
});
let seq = 0;
const dto = () => ({
key: `wf-${Date.now()}-${seq++}`,
title: 'Bounded isolated QA tracer',
department: 'ENGINEERING',
operationMode: OperationMode.PREPARE,
budgetLimitCents: 20,
metadata: {
commitSha: 'a'.repeat(40),
token: 'must-not-persist',
scope: 'Staging schema audit only',
acceptanceCriteria: ['Report all schema failures'],
actorId: 'spoof',
},
});
async function ready() {
let t = await service.create(dto(), admin);
t = await service.transition(
t.id,
{
toState: WorkflowState.GATE1_PENDING,
expectedVersion: t.version,
idempotencyKey: `submit-${t.id}`,
},
admin,
);
t = await service.decide(
t.id,
1,
{
decision: 'APPROVED',
expectedVersion: t.version,
idempotencyKey: `approve-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
},
reviewer,
);
return service.transition(
t.id,
{
toState: WorkflowState.READY,
expectedVersion: t.version,
idempotencyKey: `ready-${t.id}`,
},
admin,
);
}
afterAll(async () => {
await db.$disconnect();
});
it('persists and projects immutable bounded proposal scope without arbitrary metadata', async () => {
const input = dto();
const t = await service.create(input, admin);
expect(t.metadata).toMatchObject({
workflowScope: 'STAGE_PREPARE',
scope: input.metadata.scope,
acceptanceCriteria: input.metadata.acceptanceCriteria,
commitSha: input.metadata.commitSha,
});
expect(t.metadata).not.toHaveProperty('token');
expect(t.metadata).not.toHaveProperty('actorId');
const submitted = await service.transition(
t.id,
{
toState: 'GATE1_PENDING',
expectedVersion: t.version,
idempotencyKey: `immutable-${t.id}`,
},
admin,
);
expect(submitted.metadata).toEqual(t.metadata);
expect(service.project(submitted, reviewer).metadata).toEqual({
scope: input.metadata.scope,
acceptanceCriteria: input.metadata.acceptanceCriteria,
environment: 'staging',
commitSha: input.metadata.commitSha,
});
});
it.each([
null,
[],
{},
{ commitSha: 'a'.repeat(40), scope: '', acceptanceCriteria: ['ok'] },
{
commitSha: 'a'.repeat(40),
scope: ' '.repeat(10),
acceptanceCriteria: ['ok'],
},
{
commitSha: 'a'.repeat(40),
scope: 'x'.repeat(2001),
acceptanceCriteria: ['ok'],
},
{ commitSha: 'a'.repeat(40), scope: 'ok', acceptanceCriteria: [] },
{
commitSha: 'a'.repeat(40),
scope: 'ok',
acceptanceCriteria: Array(21).fill('ok'),
},
{
commitSha: 'a'.repeat(40),
scope: 'ok',
acceptanceCriteria: ['x'.repeat(501)],
},
{ commitSha: 'a'.repeat(40), scope: 'ok', acceptanceCriteria: [' '] },
{ commitSha: 'a'.repeat(40), scope: 'ok', acceptanceCriteria: [123] },
{ commitSha: ['a'.repeat(40)], scope: 'ok', acceptanceCriteria: ['ok'] },
{ scope: 'ok', acceptanceCriteria: ['ok'] },
])(
'rejects unsafe or unbounded metadata %# without persisting',
async (metadata) => {
const input = { ...dto(), metadata };
await expect(service.create(input, admin)).rejects.toMatchObject({
status: 400,
});
expect(
await db.orchestrationTask.count({ where: { key: input.key } }),
).toBe(0);
},
);
it('accepts exact metadata bounds', async () => {
const metadata = {
commitSha: 'a'.repeat(40),
scope: 'x'.repeat(2000),
acceptanceCriteria: Array(20).fill('x'.repeat(500)),
};
expect(
(await service.create({ ...dto(), metadata }, admin)).metadata,
).toMatchObject(metadata);
});
it('normalizes racing duplicate proposal keys to conflict without duplicate events', async () => {
const input = dto();
const results = await Promise.allSettled([
service.create(input, admin),
service.create({ ...input, title: 'Different intent' }, reviewer),
]);
expect(results.filter((r) => r.status === 'fulfilled')).toHaveLength(1);
const rejected = results.find(
(r) => r.status === 'rejected',
) as PromiseRejectedResult;
expect(rejected.reason).toMatchObject({ status: 409 });
const persisted = await db.orchestrationTask.findUniqueOrThrow({
where: { key: input.key },
});
expect(
await db.orchestrationEvent.count({ where: { taskId: persisted.id } }),
).toBe(1);
await expect(service.create(input, admin)).rejects.toMatchObject({
status: 409,
});
});
it('enforces create and read contracts over HTTP with real PostgreSQL persistence', async () => {
const module = await Test.createTestingModule({
controllers: [OrchestrationController],
providers: [
{ provide: PrepareWorkflowService, useValue: service },
{
provide: OrchestrationService,
useValue: {
findAll: () => db.orchestrationTask.findMany(),
findOne: (id: string) =>
db.orchestrationTask.findUniqueOrThrow({ where: { id } }),
},
},
],
})
.overrideGuard(JwtAuthGuard)
.useValue({
canActivate(context: any) {
context.switchToHttp().getRequest().user = {
sub: admin.id,
role: admin.role,
};
return true;
},
})
.overrideGuard(RolesGuard)
.useValue({ canActivate: () => true })
.compile();
const app = module.createNestApplication();
await app.init();
try {
const input = dto();
const response = await request(app.getHttpServer())
.post('/admin/orchestration/tasks')
.send(input)
.expect(201);
expect(response.body.metadata).toEqual({
scope: input.metadata.scope,
acceptanceCriteria: input.metadata.acceptanceCriteria,
commitSha: input.metadata.commitSha,
environment: 'staging',
});
expect(response.body.availableActions).toEqual(['SUBMIT_GATE1']);
const detail = await request(app.getHttpServer())
.get(`/admin/orchestration/tasks/${response.body.id}`)
.expect(200);
expect(detail.body.metadata).toEqual(response.body.metadata);
const list = await request(app.getHttpServer())
.get('/admin/orchestration/tasks')
.expect(200);
expect(
list.body.find((row: any) => row.id === response.body.id).metadata,
).toEqual(response.body.metadata);
expect(JSON.stringify(response.body)).not.toMatch(
/createdBy|must-not-persist|actorId|workflowScope/,
);
await request(app.getHttpServer())
.post('/admin/orchestration/tasks')
.send(input)
.expect(409);
await request(app.getHttpServer())
.post('/admin/orchestration/tasks')
.send({
...input,
key: `${input.key}-invalid`,
metadata: { scope: 'only stage', acceptanceCriteria: ['QA passes'] },
})
.expect(400);
await request(app.getHttpServer())
.post('/admin/orchestration/tasks')
.send({
...input,
key: `${input.key}-invalid`,
metadata: { ...input.metadata, acceptanceCriteria: [' '] },
})
.expect(400);
} finally {
await app.close();
}
});
it('fences heartbeat and completes QA plus independent Stage evidence only to Gate2 pending', async () => {
const t = await ready();
const c = await service.claim(worker, t.id);
await expect(
service.heartbeat({ ...worker, id: 'worker-2' }, c),
).rejects.toThrow(/lease/i);
await service.heartbeat(worker, c);
const qa = {
...c,
sha256: 'b'.repeat(64),
uri: 'https://ci.example/qa',
actualCents: 8,
};
await service.complete(worker, qa);
await expect(
service.stageEvidence(
{ id: 'proposer', role: 'Admin' },
{
taskId: t.id,
runId: c.runId,
sha256: qa.sha256,
commitSha: c.commitSha,
evidenceSha256: 'c'.repeat(64),
uri: 'https://ci.example/stage',
},
),
).rejects.toThrow(/identity/i);
await service.stageEvidence(ci, {
taskId: t.id,
runId: c.runId,
sha256: qa.sha256,
commitSha: c.commitSha,
evidenceSha256: 'c'.repeat(64),
uri: 'https://ci.example/stage',
});
expect(
await db.orchestrationTask.findUnique({ where: { id: t.id } }),
).toMatchObject({ state: 'GATE2_PENDING' });
expect(
await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
}),
).toMatchObject({ _sum: { amountCents: 8 } });
await expect(service.complete(worker, qa)).rejects.toThrow(/lease|active/i);
});
it('bounds expired-lease retries and rejects stale completion without releasing unknown costs', async () => {
const t = await service.create({ ...dto(), budgetLimitCents: 60 }, admin);
let current = await service.transition(
t.id,
{
toState: 'GATE1_PENDING',
expectedVersion: 1,
idempotencyKey: `s-${t.id}`,
},
admin,
);
current = await service.decide(
t.id,
1,
{
decision: 'APPROVED',
expectedVersion: current.version,
idempotencyKey: `a-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
},
reviewer,
);
await service.transition(
t.id,
{
toState: 'READY',
expectedVersion: current.version,
idempotencyKey: `q-${t.id}`,
},
admin,
);
const first = await service.claim(worker, t.id);
for (let i = 0; i < 2; i++) {
await db.prepareWorkflowOutbox.update({
where: { taskId: t.id },
data: { leaseUntil: new Date(0) },
});
const next = await service.claim(worker, t.id);
expect(next.attempt).toBe(i + 2);
}
await expect(
service.complete(worker, {
...first,
sha256: 'b'.repeat(64),
uri: 'https://ci.example/qa',
actualCents: 0,
}),
).rejects.toThrow(/lease/i);
await db.prepareWorkflowOutbox.update({
where: { taskId: t.id },
data: { leaseUntil: new Date(0) },
});
await expect(service.claim(worker, t.id)).rejects.toThrow(/exhausted/i);
expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe(
3,
);
expect(
await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
}),
).toMatchObject({ _sum: { amountCents: 60 } });
});
it('rejects self approval, non-PREPARE and unprovisioned workers', async () => {
await expect(
service.create(
{ ...dto(), operationMode: OperationMode.MUTATE_PRODUCTION },
admin,
),
).rejects.toThrow(/PREPARE/);
let t = await service.create(dto(), reviewer);
t = await service.transition(
t.id,
{
toState: 'GATE1_PENDING',
expectedVersion: 1,
idempotencyKey: `s-${t.id}`,
},
reviewer,
);
await expect(
service.decide(
t.id,
1,
{
decision: 'APPROVED',
expectedVersion: t.version,
idempotencyKey: `a-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
},
reviewer,
),
).rejects.toThrow(/independent/i);
await expect(
service.claim({ id: 'spoof', role: 'WORKFLOW_WORKER' }),
).rejects.toThrow(/provisioned/i);
await expect(service.decide(t.id, 2, {}, reviewer)).rejects.toThrow(
/disabled/i,
);
});
it('serializes duplicate queue submission and denies claims beyond remaining task budget', async () => {
const t = await ready();
await db.orchestrationBudgetLedger.create({
data: {
taskId: t.id,
amountCents: 1,
kind: 'SPEND',
actorId: 'fixture',
idempotencyKey: `spend-${t.id}`,
},
});
await expect(service.claim(worker, t.id)).rejects.toThrow(/budget/i);
expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe(
0,
);
expect(
await db.prepareWorkflowOutbox.count({ where: { taskId: t.id } }),
).toBe(1);
});
it('replays submission safely and serializes racing queue requests', async () => {
let t = await service.create(dto(), admin);
const submit = {
toState: 'GATE1_PENDING',
expectedVersion: t.version,
idempotencyKey: `replay-${t.id}`,
};
t = await service.transition(t.id, submit, admin);
expect((await service.transition(t.id, submit, admin)).version).toBe(
t.version,
);
await expect(
service.transition(t.id, { ...submit, toState: 'READY' }, admin),
).rejects.toThrow(/mismatch/i);
t = await service.decide(
t.id,
1,
{
decision: 'APPROVED',
expectedVersion: t.version,
idempotencyKey: `r-approve-${t.id}`,
expiresAt: new Date(Date.now() + 60000).toISOString(),
},
reviewer,
);
const results = await Promise.allSettled(
['one', 'two'].map((k) =>
service.transition(
t.id,
{
toState: 'READY',
expectedVersion: t.version,
idempotencyKey: `${k}-${t.id}`,
},
admin,
),
),
);
expect(results.filter((r) => r.status === 'fulfilled')).toHaveLength(1);
expect(
await db.prepareWorkflowOutbox.count({ where: { taskId: t.id } }),
).toBe(1);
});
it('kill switch freezes claims without creating run or reservation', async () => {
const t = await ready();
await db.orchestrationKillSwitch.create({
data: {
scope: 'GLOBAL',
level: 'FREEZE_NEW_WORK',
reason: 'isolated test',
actorId: 'fixture',
},
});
try {
await expect(service.claim(worker, t.id)).rejects.toThrow(/kill switch/i);
} finally {
await db.orchestrationKillSwitch.delete({ where: { scope: 'GLOBAL' } });
}
expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe(
0,
);
});
it('persists an atomic outbox and exactly one worker wins concurrent claims', async () => {
const t = await ready();
const claims = await Promise.all([
service.claim(worker, t.id),
service.claim({ id: 'worker-2', role: 'WORKFLOW_WORKER' }, t.id),
]);
expect(claims.filter(Boolean)).toHaveLength(1);
const claim = claims.find(Boolean)!;
expect(claim.taskId).toBe(t.id);
expect(claim.attempt).toBe(1);
expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe(
1,
);
expect(
await db.orchestrationBudgetLedger.aggregate({
where: { taskId: t.id },
_sum: { amountCents: true },
}),
).toMatchObject({ _sum: { amountCents: 20 } });
expect(
await service.project(
await db.orchestrationTask.findUniqueOrThrow({ where: { id: t.id } }),
admin,
),
).toMatchObject({
metadata: {
scope: 'Staging schema audit only',
acceptanceCriteria: ['Report all schema failures'],
environment: 'staging',
commitSha: 'a'.repeat(40),
},
});
});
});
+73 -24
View File
@@ -3,6 +3,11 @@ import { PrismaService } from "../prisma/prisma.service";
import { GetProductsDto } from "./dto/get-products.dto";
import { Prisma } from "@prisma/client";
import { RevalidationService } from "../common/revalidation/revalidation.service";
import {
createPaginationMeta,
extractSearchTokens,
calculateRelevanceScore,
} from "../common/utils/search.utils";
@Injectable()
export class ProductsService {
@@ -62,37 +67,60 @@ export class ProductsService {
andConditions.push({ priceValue: { lte: Number(maxPrice) } });
}
if (search) {
andConditions.push({
OR: [
{ artNo: { contains: search, mode: "insensitive" } },
{ barcode: { contains: search, mode: "insensitive" } },
{ nameFa: { contains: search, mode: "insensitive" } },
{ nameEn: { contains: search, mode: "insensitive" } },
{ description: { contains: search, mode: "insensitive" } },
{ shortDescription: { contains: search, mode: "insensitive" } },
const tokens = extractSearchTokens(search);
if (tokens.length > 0) {
const mode = "insensitive" as const;
const searchConditions: Prisma.ProductWhereInput[] = [
{ artNo: { contains: search, mode } },
{ barcode: { contains: search, mode } },
{ slug: { contains: search, mode } },
{ nameFa: { contains: search, mode } },
{ nameEn: { contains: search, mode } },
{ shortDescription: { contains: search, mode } },
];
for (const token of tokens) {
searchConditions.push(
{ nameFa: { contains: token, mode } },
{ nameEn: { contains: token, mode } },
{
symptoms: {
ingredientList: {
some: {
symptom: { contains: search, mode: "insensitive" },
OR: [
{ ingredient: { contains: token, mode } },
{ ingredientCardSlug: { contains: token, mode } },
],
},
},
},
],
{
symptoms: {
some: {
symptom: { contains: token, mode },
},
},
},
);
}
andConditions.push({
OR: searchConditions,
});
}
const whereClause: Prisma.ProductWhereInput =
andConditions.length > 0 ? { AND: andConditions } : {};
const skip = (page - 1) * limit;
const safePage = Math.max(1, Number(page) || 1);
const safeLimit = Math.max(1, Number(limit) || 50);
const skip = (safePage - 1) * safeLimit;
// 1. Fetch products with lean relations (no heavy N+1 orderItems join)
// 1. Fetch products with lean relations
const [rawProducts, total] = await Promise.all([
this.prisma.product.findMany({
where: whereClause,
skip,
take: limit,
skip: tokens.length > 0 ? undefined : skip,
take: tokens.length > 0 ? 100 : safeLimit,
orderBy: { [sortBy]: sortOrder },
include: {
ingredientList: true,
@@ -102,8 +130,34 @@ export class ProductsService {
this.prisma.product.count({ where: whereClause }),
]);
// Rank by relevance if searching
let candidateProducts = rawProducts;
if (tokens.length > 0 && search) {
candidateProducts = [...rawProducts]
.map((p) => ({
product: p,
score: calculateRelevanceScore(
{
artNo: p.artNo,
barcode: p.barcode,
slug: p.slug,
title: p.nameFa || p.nameEn,
shortDescription: p.shortDescription,
description: p.description,
ingredients: p.ingredientList,
symptoms: p.symptoms,
},
search,
tokens,
),
}))
.sort((a, b) => b.score - a.score)
.map((item) => item.product)
.slice(skip, skip + safeLimit);
}
// 2. Efficient single aggregate query for total sold counts for the current page slice
const productIds = rawProducts.map((p) => p.id);
const productIds = candidateProducts.map((p) => p.id);
let salesMap: Record<string, number> = {};
if (productIds.length > 0) {
@@ -131,7 +185,7 @@ export class ProductsService {
userRole === "SuperAdmin";
const isAdmin = userRole === "ADMIN" || userRole === "SuperAdmin";
const data = rawProducts.map((p) => {
const data = candidateProducts.map((p) => {
const totalSold = salesMap[p.id] || 0;
const { buyPrice, wholesalePrice, ...publicProduct } = p;
void buyPrice;
@@ -146,12 +200,7 @@ export class ProductsService {
return {
data,
meta: {
total,
page,
lastPage: Math.ceil(total / limit) || 1,
limit,
},
meta: createPaginationMeta(total, safePage, safeLimit),
};
}
@@ -1,71 +0,0 @@
import { RouterUsageAdapter } from './router-usage.adapter';
const stats = {totalRequests:0,totalPromptTokens:0,totalCompletionTokens:0,totalCachedTokens:0,byModel:{},byProvider:{},byAccount:{}};
describe('bounded read-only adapter', () => {
afterEach(() => jest.restoreAllMocks());
it('uses only authenticated GET stats with a validated period and never follows redirects', async () => {
const fetcher = jest.spyOn(global, 'fetch').mockResolvedValue(new Response(JSON.stringify(stats)));
const adapter = new RouterUsageAdapter();
process.env.ROUTER_USAGE_BASE_URL = 'https://nr.parsaaghayi.ir';
process.env.ROUTER_USAGE_CLI_TOKEN = 'server-only-secret';
const result = await adapter.summary('24h');
expect(result.status).toBe('available');
expect(result.attribution).toEqual({scope:'9router_total',hermes:null,additive:false});
expect(fetcher).toHaveBeenCalledTimes(1);
expect(fetcher).toHaveBeenCalledWith('https://nr.parsaaghayi.ir/api/usage/stats?period=24h', expect.objectContaining({method:'GET',redirect:'error',headers:{'x-9r-cli-token':'server-only-secret',Accept:'application/json'}}));
expect(JSON.stringify(result)).not.toContain('server-only-secret');
});
it('rejects invalid time filters before IO', async () => {
const fetcher = jest.spyOn(global,'fetch');
await expect(new RouterUsageAdapter().summary('../providers')).rejects.toThrow();
expect(fetcher).not.toHaveBeenCalled();
});
it('fails closed when credential is missing', async () => {
delete process.env.ROUTER_USAGE_CLI_TOKEN;
const fetcher = jest.spyOn(global,'fetch');
const result = await new RouterUsageAdapter().summary('7d');
expect(result).toMatchObject({status:'unavailable',data:null,reason:'not_configured'});
expect(fetcher).not.toHaveBeenCalled();
});
it.each([401,403,429,500])('returns unknown data without upstream error text for %s', async status => {
process.env.ROUTER_USAGE_CLI_TOKEN='secret';
jest.spyOn(global,'fetch').mockResolvedValue(new Response('credential-secret',{status}));
const result = await new RouterUsageAdapter().summary('7d');
expect(result).toMatchObject({status:'unavailable',data:null,reason:'upstream_unavailable'});
expect(JSON.stringify(result)).not.toContain('credential-secret');
});
it('rejects oversized bodies even without content length', async () => {
process.env.ROUTER_USAGE_CLI_TOKEN='secret';
jest.spyOn(global,'fetch').mockResolvedValue(new Response('x'.repeat(1048577)));
expect(await new RouterUsageAdapter().summary('7d')).toMatchObject({status:'unavailable',data:null});
});
it('does not return stale last-good totals after a failure', async () => {
process.env.ROUTER_USAGE_CLI_TOKEN='secret';
jest.spyOn(global,'fetch').mockResolvedValueOnce(new Response(JSON.stringify(stats))).mockRejectedValueOnce(new Error('token-secret'));
const adapter=new RouterUsageAdapter();
expect((await adapter.summary('7d')).status).toBe('available');
expect(await adapter.summary('7d')).toMatchObject({status:'unavailable',data:null});
});
});
describe('transport boundaries', () => {
afterEach(()=>jest.restoreAllMocks());
it('never sends credentials to a configured alternate origin', async()=>{
process.env.ROUTER_USAGE_CLI_TOKEN='secret';
process.env.ROUTER_USAGE_BASE_URL='https://attacker.invalid';
const fetcher=jest.spyOn(global,'fetch');
expect(await new RouterUsageAdapter().summary()).toMatchObject({status:'unavailable',reason:'invalid_configuration'});
expect(fetcher).not.toHaveBeenCalled();
delete process.env.ROUTER_USAGE_BASE_URL;
});
it('bounds simultaneous upstream calls and exposes no stale totals', async()=>{
process.env.ROUTER_USAGE_CLI_TOKEN='secret';
let resolve!: (value: Response) => void;
const pending=new Promise<Response>(r=>{resolve=r;});
jest.spyOn(global,'fetch').mockReturnValue(pending);
const adapter=new RouterUsageAdapter();
const calls=Array.from({length:4},()=>adapter.summary());
expect(await adapter.summary()).toMatchObject({status:'unavailable',reason:'busy',data:null});
resolve(new Response('',{status:503}));
await Promise.all(calls);
});
});
@@ -1,45 +0,0 @@
import { BadRequestException, Injectable } from '@nestjs/common';
import { normalizeStats } from './router-usage.contract';
export const ROUTER_PERIODS = ['today','24h','7d','30d','60d','all'] as const;
@Injectable()
export class RouterUsageAdapter {
private active = 0;
async summary(period = '7d') {
if (!ROUTER_PERIODS.includes(period as typeof ROUTER_PERIODS[number])) throw new BadRequestException('Invalid period');
const base = {source:'9router' as const,period,attribution:{scope:'9router_total',hermes:null,additive:false},
capabilities:{errors:false,reasoningTokens:false,cacheWriteTokens:false,quota:false,customTimeRange:false},
freshness:{retrievedAt:null as string | null,sourceUpdatedAt:null,stale:null as boolean | null}};
const unavailable = (reason: string) => ({...base,status:'unavailable' as const,reason,data:null});
const token=process.env.ROUTER_USAGE_CLI_TOKEN;
if (!token) return unavailable('not_configured');
if (this.active >= 4) return unavailable('busy');
this.active++;
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(),5000);
try {
const url=new URL(process.env.ROUTER_USAGE_BASE_URL || 'https://nr.parsaaghayi.ir');
if (url.origin !== 'https://nr.parsaaghayi.ir' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) return unavailable('invalid_configuration');
const response=await fetch(`${url.origin}/api/usage/stats?period=${period}`,{
method:'GET',redirect:'error',signal:controller.signal,
headers:{'x-9r-cli-token':token,Accept:'application/json'},
});
if (!response.ok || !response.body) throw new Error('Upstream unavailable');
const reader=response.body.getReader();
const chunks:Uint8Array[]=[];
let size=0;
try {
while (true) {
const {done,value}=await reader.read();
if (done) break;
size+=value.byteLength;
if (size>1048576) {await reader.cancel(); throw new Error('Response too large');}
chunks.push(value);
}
} finally { reader.releaseLock(); }
const data=normalizeStats(JSON.parse(Buffer.concat(chunks).toString('utf8')));
return {...base,status:'available' as const,reason:null,data,
freshness:{retrievedAt:new Date().toISOString(),sourceUpdatedAt:null,stale:null}};
} catch { return unavailable('upstream_unavailable'); }
finally { clearTimeout(timeout); this.active--; }
}
}
@@ -1,37 +0,0 @@
type RecordValue = Record<string, unknown>;
export function record(value: unknown): RecordValue {
if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid upstream schema');
return value as RecordValue;
}
function count(value: unknown): number | null {
return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
}
function identifier(value: unknown): string | null {
return typeof value === 'string' && /^[a-zA-Z0-9_./:@()+ -]{1,180}$/.test(value) && !value.includes('@') && !/^(sk-|Bearer )/i.test(value) ? value : null;
}
function metrics(row: RecordValue, prefix = '') {
const key = (name: string) => prefix ? prefix + name[0].toUpperCase() + name.slice(1) : name;
return {
requests: count(row[key('requests')]), inputTokens: count(row[key('promptTokens')]),
outputTokens: count(row[key('completionTokens')]), cacheReadTokens: count(row[key('cachedTokens')]),
cacheWriteTokens: null, reasoningTokens: null, errors: null,
};
}
export function normalizeStats(value: unknown) {
const stats = record(value);
if (count(stats.totalRequests) === null) throw new Error('Invalid stats');
const rows = (key: string) => {
const entries = Object.entries(record(stats[key]));
if (entries.length > 2000) throw new Error('Too many aggregates');
return entries;
};
return {
totals: metrics(stats, 'total'),
providers: rows('byProvider').map(([id, row]) => ({provider: identifier(id), ...metrics(record(row))})),
models: rows('byModel').map(([, row]) => { const r = record(row); return {model: identifier(r.rawModel), provider: identifier(r.provider), ...metrics(r)}; }),
accounts: rows('byAccount').map(([, row]) => { const r = record(row); return {
accountId: identifier(r.connectionId), model: identifier(r.rawModel), provider: identifier(r.provider), ...metrics(r),
quota: {status: 'unknown' as const, remaining: null, resetAt: null, reason: 'upstream_quota_get_mutates_credentials'},
}; }),
};
}
@@ -1,22 +0,0 @@
import { Controller, Get, Header, Query, UseGuards, ValidationPipe } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { IsIn, IsOptional } from 'class-validator';
import { Roles } from '../common/decorators/roles.decorator';
import { RolesGuard } from '../common/guards/roles.guard';
import { ROUTER_PERIODS, RouterUsageAdapter } from './router-usage.adapter';
export class RouterUsageQuery {
@IsOptional()
@IsIn(ROUTER_PERIODS)
period?: string;
}
@Controller('admin/router-usage')
@UseGuards(AuthGuard('jwt'), RolesGuard)
@Roles('admin')
export class RouterUsageController {
constructor(private readonly adapter: RouterUsageAdapter) {}
@Get()
@Header('Cache-Control','private, no-store')
summary(@Query(new ValidationPipe({transform:true,whitelist:true,forbidNonWhitelisted:true})) query: RouterUsageQuery) {
return this.adapter.summary(query.period ?? '7d');
}
}
@@ -1,36 +0,0 @@
import { Test } from '@nestjs/testing';
import { INestApplication, ValidationPipe } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import request from 'supertest';
import { RouterUsageModule } from './router-usage.module';
import { RouterUsageAdapter } from './router-usage.adapter';
describe('protected router usage HTTP contract', () => {
let app: INestApplication;
const summary=jest.fn().mockResolvedValue({status:'available',data:{}});
beforeAll(async () => {
const module=await Test.createTestingModule({imports:[RouterUsageModule]})
.overrideProvider(RouterUsageAdapter).useValue({summary})
.overrideGuard(AuthGuard('jwt')).useValue({canActivate(context: any){
const req=context.switchToHttp().getRequest();
if (!req.headers.authorization) return false;
req.user={role:req.headers.authorization}; return true;
}}).compile();
app=module.createNestApplication();
app.useGlobalPipes(new ValidationPipe({transform:true,whitelist:true,forbidNonWhitelisted:true}));
await app.init();
});
afterAll(async()=>app.close());
it('blocks unauthenticated access', async()=>{ await request(app.getHttpServer()).get('/admin/router-usage').expect(403); });
it('blocks non-admin users', async()=>{ await request(app.getHttpServer()).get('/admin/router-usage').set('Authorization','customer').expect(403); });
it('permits admins and defaults to 7d', async()=>{
await request(app.getHttpServer()).get('/admin/router-usage').set('Authorization','admin').expect(200);
expect(summary).toHaveBeenCalledWith('7d');
});
it('rejects unsupported custom time range', async()=>{
await request(app.getHttpServer()).get('/admin/router-usage?from=2026-01-01').set('Authorization','admin').expect(400);
});
it('rejects invalid period', async()=>{
await request(app.getHttpServer()).get('/admin/router-usage?period=invalid').set('Authorization','admin').expect(400);
});
});
@@ -1,6 +0,0 @@
import { Module } from '@nestjs/common';
import { RouterUsageController } from './router-usage.controller';
import { RouterUsageAdapter } from './router-usage.adapter';
import { RolesGuard } from '../common/guards/roles.guard';
@Module({controllers:[RouterUsageController],providers:[RouterUsageAdapter,RolesGuard],exports:[RouterUsageAdapter]})
export class RouterUsageModule {}
@@ -1,28 +0,0 @@
import { normalizeStats } from './router-usage.contract';
describe('9router stats allowlist', () => {
it('maps real aggregate fields without leaking API-key map keys or account labels', () => {
const result = normalizeStats({totalRequests:2,totalPromptTokens:10,totalCompletionTokens:4,totalCachedTokens:3,
byProvider:{codex:{requests:2,promptTokens:10,completionTokens:4,cachedTokens:3}},
byModel:{'m (codex)':{rawModel:'m',provider:'codex',requests:2}},
byAccount:{'private@example.com':{rawModel:'m',provider:'codex',connectionId:'account-1',accountName:'private@example.com',requests:2}},
byApiKey:{'SECRET-KEY|m':{apiKey:'SECRET-KEY'}},accessToken:'SECRET-TOKEN'});
expect(result.totals).toEqual({requests:2,inputTokens:10,outputTokens:4,cacheReadTokens:3,cacheWriteTokens:null,reasoningTokens:null,errors:null});
expect(result.models[0]).toMatchObject({model:'m',provider:'codex',requests:2});
expect(result.accounts[0]).toMatchObject({accountId:'account-1',quota:{status:'unknown',remaining:null,resetAt:null,reason:'upstream_quota_get_mutates_credentials'}});
expect(JSON.stringify(result)).not.toMatch(/SECRET|private@|accountName|byApiKey/);
});
});
describe('unknown rather than fabricated metrics', () => {
const empty = {totalRequests:0,byProvider:{},byModel:{},byAccount:{}};
it('preserves known zero and unknown missing counters separately', () => {
expect(normalizeStats(empty).totals).toEqual({requests:0,inputTokens:null,outputTokens:null,cacheReadTokens:null,cacheWriteTokens:null,reasoningTokens:null,errors:null});
});
it.each([null,{},[],{...empty,totalRequests:-1},{...empty,byModel:null}])('rejects invalid schemas', value => {
expect(()=>normalizeStats(value)).toThrow();
});
it('rejects unsafe metric values instead of coercing them to zero', () => {
expect(normalizeStats({...empty,totalPromptTokens:'10',totalCompletionTokens:-4,totalCachedTokens:Infinity}).totals).toMatchObject({inputTokens:null,outputTokens:null,cacheReadTokens:null});
});
});
@@ -20,7 +20,10 @@ describe('support HTTP boundary', () => {
beforeAll(async () => {
process.env.JWT_ACCESS_SECRET = 'test-secret-with-at-least-32-characters';
const mod = await Test.createTestingModule({ imports: [PassportModule], controllers: [SupportChatController], providers: [{ provide: SupportChatSettingsService, useValue: { read: async () => ({ enabled: true, provider: 'p', model: 'm' }) } }, SupportChatService, OptionalCustomerJwtGuard, TestJwt, { provide: PrismaService, useValue: prisma }] }).compile();
app = mod.createNestApplication(); app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true, forbidNonWhitelisted: true })); await app.init();
app = mod.createNestApplication(); app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true, forbidNonWhitelisted: true }));
// Own the listener for the entire suite. Otherwise Supertest lets the first
// request start the server and close it while its concurrent peer is using it.
await app.listen(0, '127.0.0.1');
});
afterAll(() => app.close());
beforeEach(() => {
@@ -45,7 +48,14 @@ describe('support HTTP boundary', () => {
});
it('scopes wallet to validated identity across concurrent callers', async () => {
const replies=await Promise.all(['alice','bob'].map(sub => request(app.getHttpServer()).post('/support-chat/ask').set('Authorization','Bearer '+jwt.sign({sub})).send({message:'کیف پول'}).expect(201)));
expect(replies[0].body.answer).toContain('11'); expect(replies[0].body.answer).not.toContain('22'); expect(replies[1].body.answer).toContain('22'); expect(prisma.product.findMany).not.toHaveBeenCalled();
expect(replies[0].body.answer).toBe('موجودی کیف پول شما: 11 تومان.');
expect(replies[1].body.answer).toBe('موجودی کیف پول شما: 22 تومان.');
expect(prisma.user.findUnique).toHaveBeenCalledTimes(2);
for (const id of ['alice', 'bob']) {
expect(prisma.user.findUnique).toHaveBeenCalledWith({ where: { id }, select: { walletBalance: true } });
}
expect(prisma.product.findMany).not.toHaveBeenCalled();
expect(prisma.order.findMany).not.toHaveBeenCalled();
});
it('scopes bounded orders to identity', async () => { const r=await request(app.getHttpServer()).post('/support-chat/ask').set('Authorization','Bearer '+jwt.sign({sub:'bob'})).send({message:'سفارش'}).expect(201); expect(r.body.answer).toContain('bob-order'); expect(prisma.order.findMany).toHaveBeenCalledWith(expect.objectContaining({ where:{userId:'bob'}, take:5 })); });
it.each(['', 'x'.repeat(1501)])('bounds message length', async message => { await request(app.getHttpServer()).post('/support-chat/ask').send({message}).expect(400); });
+42 -13
View File
@@ -2,6 +2,11 @@ import { Injectable, NotFoundException } from "@nestjs/common";
import { Prisma } from "@prisma/client";
import { PrismaService } from "../prisma/prisma.service";
import { PaginationDto } from "../common/dto/pagination.dto";
import {
createPaginationMeta,
extractSearchTokens,
calculateRelevanceScore,
} from "../common/utils/search.utils";
@Injectable()
export class WikiService {
@@ -19,33 +24,57 @@ export class WikiService {
const sortBy = allowedSortFields.includes(rawSortBy) ? rawSortBy : "term";
const whereClause: Prisma.ScientificTermWhereInput = {};
if (search) {
const tokens = extractSearchTokens(search);
if (tokens.length > 0) {
const mode = "insensitive" as const;
whereClause.OR = [
{ term: { contains: search, mode: "insensitive" } },
{ definition: { contains: search, mode: "insensitive" } },
{ term: { contains: search, mode } },
{ key: { contains: search, mode } },
{ definition: { contains: search, mode } },
...tokens.flatMap((token) => [
{ term: { contains: token, mode } },
{ key: { contains: token, mode } },
]),
];
}
const skip = (page - 1) * limit;
const safePage = Math.max(1, Number(page) || 1);
const safeLimit = Math.max(1, Number(limit) || 10);
const skip = (safePage - 1) * safeLimit;
const [data, total] = await Promise.all([
const [rawTerms, total] = await Promise.all([
this.prisma.scientificTerm.findMany({
where: whereClause,
skip,
take: limit,
skip: tokens.length > 0 ? undefined : skip,
take: tokens.length > 0 ? 100 : safeLimit,
orderBy: { [sortBy]: sortOrder },
}),
this.prisma.scientificTerm.count({ where: whereClause }),
]);
let data = rawTerms;
if (tokens.length > 0 && search) {
data = [...rawTerms]
.map((t) => ({
term: t,
score: calculateRelevanceScore(
{
slug: t.key,
title: t.term,
description: t.definition,
},
search,
tokens,
),
}))
.sort((a, b) => b.score - a.score)
.map((item) => item.term)
.slice(skip, skip + safeLimit);
}
return {
data,
meta: {
total,
page,
lastPage: Math.ceil(total / limit),
limit,
},
meta: createPaginationMeta(total, safePage, safeLimit),
};
}
+30
View File
@@ -0,0 +1,30 @@
# Narrow auth schema operation — approval required
## Exact scope
`auth-schema-reconcile.sql` adds only users.auth_expires_at TIMESTAMPTZ NULL, stage_test_session VARCHAR(64) NULL, stage_test_generation UUID NULL (no defaults/backfill), and prepare_workflow_outbox with its original CHECKs, three RESTRICT FKs, task uniqueness, lease and due indexes, including nullable not_before. No existing rows changed, no auth behavior disabled, no Prisma metadata altered.
Read-only production PostgreSQL 16.14 catalogs verified all three users columns and outbox absent; users.id and orchestration_tasks/runs/budget_ledger.id are UUID PKs. Existing users wallet CHECK and orchestration constraints stay intact. Production has six ledger rows (one historical rolled-back admin_modules attempt), no Oct22–24 entries despite orchestration objects existing. Never run generic migrate deploy or mark whole pending history applied.
Historical principal migration at e036c5d has two columns, SHA256 8b4fe1fdedd2ae459b720f78479cfcb13da465eec821b422ece5e9bb41dc47ae; 80a2e18 edited it to three, SHA256 a458a94329b1ad078298b042ae0bd2e25439c1f0bb5a086beb55c517d9e0aa28. Read-only Stage ledger records the latter, not the former. Preserve both historical files unchanged here. This operation is separately journaled by CI/backup receipt, not invented Prisma history. Broader baseline/history repair remains separate work.
## Execution contract
Dedicated push workflow `auth-schema-reconcile.yml` uses DEPLOY_KEY and pinned DEPLOY_KNOWN_HOSTS, fixed SSH endpoint, isolated immutable Git checkout; it does not deploy applications. It accepts only exact branches `ops/auth-schema-stage` and `ops/auth-schema-production`, mapping their full refs to Stage and production respectively. It requires REVIEWED_AUTH_SCHEMA_COMMIT matching the event SHA and checks detached checkout HEAD equals that SHA. SQL digest is fixed to `8a22f3e89efb3dacc24f3ed9337ae87d0b4345da003a607bc1994478f69c6feb`, approval ID to `CEO-AUTH-SCHEMA-20261025`; neither is push-supplied input. Production additionally requires PRODUCTION_AUTH_SCHEMA_APPROVAL = SHA:SQL_SHA256:APPROVAL_ID and STAGE_AUTH_SCHEMA_ACCEPTANCE = SHA:SQL_SHA256, provisioned only after real review and Stage auth acceptance. These are explicit approval records, not automatically issued receipts. The repository's workflow/secret permissions must restrict dedicated-ref mutation to trusted maintainers; unrestricted malicious workflow edits can bypass any workflow-local gate. Review/protect this boundary before provisioning production approval.
Stage already has the DDL: Stage mode backs up production read-only, restores into isolated network-none temporary PostgreSQL, applies exact SQL there, compares resulting catalog with Stage read-only, and writes a SHA-bound structural receipt only. Production requires that receipt, repeats fresh full backup and restore/patch rehearsal, then executes only exact approved SQL. Full dumps remain mode600 host-only under /opt/backups/canina-auth-reconcile; never upload/log PII. Backup nonempty and pg_restore TOC checked. Restore errors/capacity failure stop before DDL. tmpfs is capped at 1GiB: if full restore exceeds capacity, separately review capacity rather than skipping restore. Existing read-only schema backup was 94,694 bytes / 67 tables, no PII copied; its restored PostgreSQL rehearsal is genuine, not a full data-backup recovery claim.
SQL lock_timeout 3s, statement_timeout 30s, idle transaction 60s; advisory lock plus host flock. DDL transactional; lock/contention failure aborts all. No automatic retries. Re-execution with existing outbox fails closed pending comparison, rather than silently accepting drift. Stage/production outputs compare columns/types/nullability/defaults, all outbox constraints/indexes to fresh rehearsed expected schema.
## Gitea 1.22.6 trigger semantics and operator sequence
Gitea [1.22 comparison](https://docs.gitea.com/1.22/usage/actions/comparison) explicitly marks `workflow_dispatch` ignored. The [v1.22.6 notifier implementation](https://github.com/go-gitea/gitea/blob/v1.22.6/services/actions/notifier_helper.go) resolves the pushed ref's commit, detects workflows at that commit and records `Ref` and `CommitSHA` on the run. Push is not default-branch-only. The dedicated branch must therefore contain this workflow and point to the **final integrated reviewed commit**, not a new trigger-only commit. Existing app deployment listens only to `main`/`develop`, not either operations branch.
After independent review/authorization, a trusted operator can push `<REVIEWED_FULL_SHA>:refs/heads/ops/auth-schema-stage` to origin. Inspect that CI run's SHA and structural receipt, then complete real Stage auth tests. Only after separate production and Stage acceptance approval records exist for the **same** SHA/digest may the operator push `<REVIEWED_FULL_SHA>:refs/heads/ops/auth-schema-production`. No empty commits, merges, arbitrary ref inputs, secret updates by this workflow, automatic acceptance, or app promotion. A no-op push does not retrigger; do not change the reviewed SHA to manufacture a run. Any SHA change requires fresh review, approval bindings and Stage evidence. Workflow preparation has not pushed either branch, changed secrets/protections or executed the operation.
## Acceptance and rollback
1. Parent DBA review exact commit/diff plus SQL hash and workflow trusted-ref/secret permissions. Approve read-only production full backup + isolated full restore scope separately from production DDL.
2. Run Stage workflow from exact commit; inspect successful backup/restore/catalog comparison. Existing Stage backend must pass ordinary admin password login + protected dashboard, OTP flow with authorized principal, refresh, and expiry/session/generation rejection tests. Do not manufacture acceptance if no approved credential/test principal is available. Record actual test run identifiers before setting Stage acceptance approval.
3. Obtain explicit approval: execute only this commit's SQL in caninodb_prod, three nullable users columns + empty outbox and declared constraints/indexes, 3s lock/30s statement budgets, no unrelated migrations/history writes/seeds. Provision approval binding SHA, SQL digest, approval record. Trigger production workflow, inspect terminal CI log. No production execution has been performed during preparation.
4. Release separately via existing code-only develop→Stage→main CI, using actual regenerated backend client, runtime-image/schema guard, immutable image receipts and authenticated login/OTP/refresh/protected data acceptance. Keep current compatible backend until this passes. Schema approval alone does not authorize application promotion.
5. Before commit failure: transaction rollback. After successful DDL: leave additive nullable fields/table intact, roll back application to known compatible immutable image via approved CI; do not DROP columns or outbox after writes. Restore full backup only under separately approved incident/data-loss recovery process. Existing backup tables remain untouched.
## Verified preparation / limitations
Disposable network-none PG16 schema-only restore and exact SQL executed successfully (see JSON). Missing-column SELECT failed before patch and passed after; invalid status rejected; second application rejected without changes; container removed. Independent reviewer found SQL definition matched history; requested stronger gating, Stage preexisting-schema handling, capacity awareness and postcondition validation, addressed or explicit prerequisites above. Full-data restore and dedicated workflow SSH path are implemented but not yet executed in actual CI. No production writes or deployments occurred. Approval/environment gates must not be represented as production repair completion.
+14
View File
@@ -0,0 +1,14 @@
{
"schema_backup_bytes": 94694,
"schema_backup_sha256": "9c6367a06acaf97c1afe9355e4306d2a10f878b7fe156c7dbc5d58d675262c72",
"schema_tables": 67,
"pii_copied": false,
"postgres": "16.14",
"restore_and_patch_seconds": 3.669,
"pre_patch_missing_columns_failed": true,
"post_patch_queries": " auth_expires_at | stage_test_session | stage_test_generation \n-----------------+--------------------+-----------------------\n(0 rows)\n\n count \n-------\n 0\n(1 row)\n\n count \n-------\n 0\n(1 row)\n\n",
"constraints": " conname | pg_get_constraintdef \n---------------------------------------------+-----------------------------------------------------------------------------------------------------------\n prepare_workflow_outbox_attempts_check | CHECK (((attempts >= 0) AND (attempts <= 3)))\n prepare_workflow_outbox_pkey | PRIMARY KEY (id)\n prepare_workflow_outbox_reservation_id_fkey | FOREIGN KEY (reservation_id) REFERENCES orchestration_budget_ledger(id) ON DELETE RESTRICT\n prepare_workflow_outbox_run_id_fkey | FOREIGN KEY (run_id) REFERENCES orchestration_runs(id) ON DELETE RESTRICT\n prepare_workflow_outbox_status_check | CHECK (((status)::text = ANY ((ARRAY['PENDING'::character varying, 'DONE'::character varying])::text[])))\n prepare_workflow_outbox_task_id_fkey | FOREIGN KEY (task_id) REFERENCES orchestration_tasks(id) ON DELETE RESTRICT\n prepare_workflow_outbox_task_id_key | UNIQUE (task_id)\n(7 rows)\n\n",
"invalid_status_rejected": true,
"repeat_execution_rejected_without_writes": true,
"production_writes": false
}
Loaded 100 of 271 files, more files were not shown because too many files have changed in this diff. Show more