devcontour-harness 0.0.0-stage → 0.1.0-alpha.6

package/lib/verification/requirements.js

@@ -0,0 +1,69 @@
+import { execFileSync } from 'node:child_process';
+import { HarnessError, relativePathSchema, sha256 } from "../contracts/index.js";
+/** Требование заканчивается на следующем заголовке уровня 1–2; примеры в fenced-блоках не считаются. */
+export function parseRequirements(markdown) {
+    if (Buffer.byteLength(markdown) > 1_000_000)
+        throw new HarnessError('INVALID_INPUT', 'Источник требований превышает 1 MB');
+    const found = [];
+    let current;
+    let fence;
+    const finish = () => {
+        if (!current)
+            return;
+        const text = current.lines.join('\n').trim();
+        if (text.length > 12000)
+            throw new HarnessError('INVALID_INPUT', 'Разбейте требование: ' + current.id);
+        if (found.some((r) => r.id === current.id))
+            throw new HarnessError('INVALID_INPUT', 'Повтор ID: ' + current.id);
+        found.push({ id: current.id, text, digest: sha256(text) });
+        current = undefined;
+    };
+    for (const line of markdown.replaceAll('\r\n', '\n').split('\n')) {
+        const delimiter = line.match(/^\s{0,3}(`{3,}|~{3,})/)?.[1];
+        if (delimiter) {
+            if (!fence)
+                fence = delimiter;
+            else if (delimiter[0] === fence[0] && delimiter.length >= fence.length)
+                fence = undefined;
+            current?.lines.push(line);
+            continue;
+        }
+        if (!fence && /^#{1,2}\s/.test(line)) {
+            finish();
+            const id = line.match(/^## (REQ-[A-Za-z0-9_-]{1,64})(?:\s|:|$)/)?.[1];
+            if (id)
+                current = { id, lines: [] };
+        }
+        current?.lines.push(line);
+    }
+    finish();
+    return found;
+}
+/** Требования источника на коммите: файл обязан быть обычным Git-файлом. */
+export function requirementSnapshot(cwd, source, ref = 'HEAD') {
+    relativePathSchema.parse(source);
+    if (!/^(HEAD|[a-f0-9]{40,64})$/.test(ref))
+        throw new HarnessError('INVALID_INPUT', 'Нужен HEAD или точный SHA');
+    const git = (...args) => execFileSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 1_100_000 }).trimEnd();
+    const sha = git('rev-parse', '--verify', ref + '^{commit}');
+    if (!/^100(644|755) blob /.test(git('ls-tree', sha, '--', source)))
+        throw new HarnessError('NOT_READY', 'Источник требований должен быть обычным Git-файлом: ' + source);
+    return { source, sha, requirements: parseRequirements(git('show', `${sha}:${source}`)) };
+}
+/**
+ * Совпадают ли закреплённые требования поручения с источником на `ref`.
+ * Изменённое или удалённое требование — отказ: исполнение по устаревшей
+ * постановке не продолжается.
+ */
+export function assertRequirements(order, cwd, ref = 'HEAD') {
+    const snapshots = new Map();
+    const stale = order.requirements.filter((link) => {
+        if (!snapshots.has(link.source))
+            snapshots.set(link.source, requirementSnapshot(cwd, link.source, ref));
+        return (snapshots.get(link.source).requirements.find((r) => r.id === link.id)?.digest !== link.digest);
+    });
+    if (stale.length)
+        throw new HarnessError('APPROVAL_STALE', 'Требования изменились или удалены: ' + stale.map((r) => r.id).join(', '));
+}
+/** Псевдо-gate актуальности требований: обязателен в обеих фазах, если у поручения есть требования. */
+export const REQUIREMENT_GATE = 'requirement-source';

package/lib/verification/self-check.d.ts

@@ -0,0 +1,29 @@
+import type { ContractDocument, GatePolicy, WorkOrder } from '../contracts/index.ts';
+/**
+ * Самопроверка исполнителя: тот же закреплённый checker, полный корпус
+ * закреплённой версии, генератор с воспроизводимым seed и селектор свойств
+ * поручения. Проверяется рабочий, незакоммиченный код — результат
+ * диагностический и не заменяет evidence controller на commit SHA: gates
+ * исполняются всегда, с самопроверкой или без неё.
+ */
+export interface SelfCheckPlan {
+    command: string[];
+    corpus?: string;
+    cases: number;
+    seed: number;
+    properties: string[];
+}
+export declare function writeSelfCheck(input: {
+    order: Pick<WorkOrder, 'id' | 'properties'>;
+    contracts: ContractDocument[];
+    gates: GatePolicy[];
+    dir: string;
+    seed: number;
+    /** Канонический файл закреплённой версии корпуса и число её случаев. */
+    corpus?: {
+        content: string;
+        cases: number;
+    };
+}): Promise<SelfCheckPlan | undefined>;
+/** Строка запроса исполнителю о самопроверке. */
+export declare function selfCheckNote(plan: SelfCheckPlan): string;

package/lib/verification/self-check.js

@@ -0,0 +1,99 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { obligationOf } from "./checks.js";
+export async function writeSelfCheck(input) {
+    const gates = new Map();
+    for (const id of input.order.properties ?? []) {
+        const found = obligationOf(input.contracts, id);
+        const gate = found && input.gates.find((g) => g.id === found.gate && g.property);
+        if (!gate)
+            continue;
+        const entry = gates.get(gate.id) ?? {
+            command: gate.command,
+            ...(gate.cwd ? { cwd: gate.cwd } : {}),
+            properties: [],
+        };
+        entry.properties.push(id);
+        gates.set(gate.id, entry);
+    }
+    if (!gates.size)
+        return undefined;
+    await mkdir(input.dir, { recursive: true });
+    const corpus = input.corpus ? join(input.dir, 'corpus.json') : undefined;
+    if (input.corpus)
+        await writeFile(corpus, input.corpus.content);
+    const plan = {
+        work: input.order.id,
+        seed: input.seed,
+        corpus: corpus ?? null,
+        gates: [...gates].map(([id, g]) => ({ id, ...g })),
+    };
+    const script = join(input.dir, 'selfcheck.mjs');
+    await writeFile(script, selfCheckSource(plan));
+    return {
+        command: [process.execPath, script],
+        ...(corpus ? { corpus } : {}),
+        cases: input.corpus?.cases ?? 0,
+        seed: input.seed,
+        properties: [...gates.values()].flatMap((g) => g.properties),
+    };
+}
+/** Строка запроса исполнителю о самопроверке. */
+export function selfCheckNote(plan) {
+    return `Self-check: run \`${plan.command.join(' ')}\` from the worktree root before returning. It runs the pinned checker on your working tree with ${plan.cases} mandatory corpus cases, the generator with seed ${plan.seed} and your properties (${plan.properties.join(', ')}). A non-zero exit names the property, the exact input and the reason. It is diagnostic: the controller still runs the gates on your commit.`;
+}
+function selfCheckSource(plan) {
+    return `// Самопроверка исполнителя: закреплённый checker, полный корпус, seed и
+// свойства поручения. Диагностика рабочего кода: controller всё равно
+// исполняет gates на commit SHA. Ненулевой код — свойство, точный вход и причина.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const plan = ${JSON.stringify(plan, null, 2)};
+const both = (name, value) => ({ ['DEVCONTOUR_' + name]: value, ['HARNESS_' + name]: value });
+let failed = 0;
+for (const gate of plan.gates) {
+  const scratch = mkdtempSync(join(tmpdir(), 'harness-self-'));
+  const report = join(scratch, 'property.json');
+  const result = spawnSync(gate.command[0], gate.command.slice(1), {
+    cwd: gate.cwd ? join(process.cwd(), gate.cwd) : process.cwd(),
+    stdio: ['ignore', 'ignore', 'inherit'],
+    env: {
+      ...process.env,
+      ...both('SEED', String(plan.seed)),
+      ...both('PROPERTIES', gate.properties.join(',')),
+      ...(plan.corpus ? both('CORPUS', plan.corpus) : {}),
+      ...both('PROPERTY_REPORT', report),
+      ...both('REPORT_PATH', join(scratch, 'junit.xml')),
+    },
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(report, 'utf8'));
+  } catch {}
+  rmSync(scratch, { recursive: true, force: true });
+  if (!parsed) {
+    failed++;
+    console.log('FAIL ' + gate.id + ': отчёт свойств не записан (код выхода ' + result.status + ')');
+    continue;
+  }
+  for (const p of parsed.properties) {
+    if (p.status === 'passed') continue;
+    failed++;
+    const c = p.counterexample;
+    const input = c ? (c.reduced ?? c.original) : p.current;
+    const reason = p.error ?? (c ? 'ожидалось ' + JSON.stringify(c.expected) + ', получено ' + JSON.stringify(c.actual) : 'не завершилось');
+    console.log('FAIL ' + p.testId + (c && c.case ? ' [случай корпуса ' + c.case + ']' : '') + ': input=' + JSON.stringify(input) + ' — ' + reason);
+  }
+  for (const f of parsed.corpus?.failed ?? [])
+    console.log('CORPUS ' + f.property + ' [' + f.id + ']: ожидалось ' + JSON.stringify(f.expected) + ', получено ' + JSON.stringify(f.actual));
+  if (result.status && !parsed.properties.some((p) => p.status !== 'passed')) {
+    failed++;
+    console.log('FAIL ' + gate.id + ': код выхода ' + result.status);
+  }
+}
+console.log(failed ? 'self-check: ' + failed + ' failing (seed ' + plan.seed + ')' : 'self-check: all properties hold (seed ' + plan.seed + '); diagnostic only — the controller runs the gates on your commit');
+process.exit(failed ? 1 : 0);
+`;
+}

package/lib/verification/spike.d.ts

@@ -0,0 +1,79 @@
+import { type ExecutionPolicy, type ExecutionView, type Spike } from '../contracts/index.ts';
+import type { Engine } from '../engine/engine.ts';
+/** Что нужно эксперименту от controller. */
+export interface SpikeContext {
+    engine: Engine;
+    policy: ExecutionPolicy;
+    stateDir: string;
+    repoPath(repo: ExecutionPolicy['repositories'][number]): string;
+    /** Закрытое проверке и открытое внутри него. */
+    boundary(): {
+        hidden: string[];
+        readable: string[];
+    };
+    environment?: NodeJS.ProcessEnv;
+}
+/** Эксперимент репозитория по ID или undefined. */
+export declare function spikeOf(view: ExecutionView, repositoryId: string, id: string): {
+    id: string;
+    repositoryId: string;
+    sha: string;
+    command: string[];
+    seed: number;
+    sizes: number[];
+    timeoutMs: number;
+    question: string;
+    results: {
+        size: number;
+        ms: number;
+        outcome: "error" | "ok" | "timeout";
+        exitCode: number;
+    }[];
+    outcome: "failed" | "feasible" | "inconclusive";
+    limits: string;
+    environment: {
+        platform: string;
+        arch: string;
+        node: string;
+        cpus: number;
+        isolation: string;
+    };
+    at: string;
+    digest: string;
+} | undefined;
+/** Эксперименты репозитория. */
+export declare function spikesOf(view: ExecutionView, repositoryId?: string): {
+    id: string;
+    repositoryId: string;
+    sha: string;
+    command: string[];
+    seed: number;
+    sizes: number[];
+    timeoutMs: number;
+    question: string;
+    results: {
+        size: number;
+        ms: number;
+        outcome: "error" | "ok" | "timeout";
+        exitCode: number;
+    }[];
+    outcome: "failed" | "feasible" | "inconclusive";
+    limits: string;
+    environment: {
+        platform: string;
+        arch: string;
+        node: string;
+        cpus: number;
+        isolation: string;
+    };
+    at: string;
+    digest: string;
+}[];
+/**
+ * Ограниченный эксперимент выполнимости: команда на закреплённом SHA в
+ * отдельном worktree, для каждого размера — под той же изоляцией, что gates,
+ * с пределом времени. После таймаута большие размеры не запускаются: они
+ * ничего не добавят к выводу. Результат с версиями среды и пределами вывода
+ * сохраняется под digest; ссылка тяжёлого обязательства закрепляет этот digest.
+ */
+export declare function runSpike(ctx: SpikeContext, raw: unknown): Promise<Spike>;

package/lib/verification/spike.js

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
+import { arch, cpus, platform } from 'node:os';
+import { join } from 'node:path';
+import { HarnessError, digestOf, spikeInputSchema, spikeSchema, } from "../contracts/index.js";
+import { git } from "../environment/process.js";
+import { executionEnvironment } from "../environment/lifecycle.js";
+import { redactDeep, redactError } from "../environment/redaction.js";
+import { runCheck } from "./gates.js";
+/** Эксперимент репозитория по ID или undefined. */
+export function spikeOf(view, repositoryId, id) {
+    return view.local('spikes', repositoryId, id);
+}
+/** Эксперименты репозитория. */
+export function spikesOf(view, repositoryId) {
+    return view.locals('spikes', repositoryId).map((x) => x.value);
+}
+/**
+ * Ограниченный эксперимент выполнимости: команда на закреплённом SHA в
+ * отдельном worktree, для каждого размера — под той же изоляцией, что gates,
+ * с пределом времени. После таймаута большие размеры не запускаются: они
+ * ничего не добавят к выводу. Результат с версиями среды и пределами вывода
+ * сохраняется под digest; ссылка тяжёлого обязательства закрепляет этот digest.
+ */
+export async function runSpike(ctx, raw) {
+    const input = spikeInputSchema.parse(raw);
+    const repo = input.repositoryId
+        ? ctx.policy.repositories.find((r) => r.id === input.repositoryId)
+        : ctx.policy.repositories[0];
+    if (!repo)
+        throw new HarnessError('NOT_FOUND', 'Репозиторий не объявлен: ' + input.repositoryId);
+    // Окружение и его маска — до любой работы: недостающий секрет — отказ без
+    // worktree и записи, а известные значения не попадают в сохраняемую запись.
+    const environmentOf = (size) => executionEnvironment([ctx.policy.environment, repo.environment], { DEVCONTOUR_SPIKE_SIZE: String(size), DEVCONTOUR_SEED: String(input.seed) }, ctx.environment ?? process.env);
+    let redact;
+    try {
+        redact = environmentOf(input.sizes[0]).redact;
+    }
+    catch (error) {
+        throw new HarnessError('RUNTIME_UNAVAILABLE', 'Окружение эксперимента: ' + (error instanceof Error ? error.message : String(error)));
+    }
+    const path = ctx.repoPath(repo);
+    const sha = input.sha ?? (await git(path, 'rev-parse', 'HEAD'));
+    await git(path, 'cat-file', '-e', `${sha}^{commit}`).catch(() => {
+        throw new HarnessError('NOT_FOUND', `Commit ${sha} недоступен в ${repo.id}`);
+    });
+    const id = 'SP-' + randomUUID();
+    const root = join(ctx.stateDir, 'spikes');
+    const dir = join(root, id);
+    await mkdir(root, { recursive: true });
+    await git(path, 'worktree', 'add', '--detach', dir, sha);
+    const results = [];
+    try {
+        const boundary = ctx.boundary();
+        for (const size of input.sizes) {
+            const environment = environmentOf(size);
+            const started = Date.now();
+            const result = await runCheck({ config: ctx.policy }, {
+                argv: input.command,
+                cwd: dir,
+                env: environment.env,
+                redact: environment.redact,
+                timeoutMs: input.timeoutMs,
+                signal: AbortSignal.timeout(input.timeoutMs + 60000),
+                write: [dir],
+                readable: boundary.readable,
+                controller: boundary.hidden,
+                settingsDir: join(root, `${id}-settings`),
+            });
+            results.push({
+                size,
+                ms: Date.now() - started,
+                outcome: result.timedOut ? 'timeout' : result.code === 0 ? 'ok' : 'error',
+                exitCode: result.code,
+            });
+            if (result.timedOut)
+                break;
+        }
+    }
+    catch (error) {
+        // Класс и код отказа сохраняются, известные значения — ни в одном поле.
+        throw redactError(error, redact);
+    }
+    finally {
+        await git(path, 'worktree', 'remove', '--force', dir).catch(() => undefined);
+    }
+    const outcome = results.some((r) => r.outcome === 'timeout')
+        ? 'inconclusive'
+        : results.some((r) => r.outcome === 'error')
+            ? 'failed'
+            : 'feasible';
+    const timeout = results.find((r) => r.outcome === 'timeout');
+    const limits = outcome === 'inconclusive'
+        ? `Таймаут ${input.timeoutMs} мс на размере ${timeout.size}: для этого способа и бюджета вывод не сделан. Это не доказательство невыполнимости или трудности и не основание менять требование.`
+        : outcome === 'failed'
+            ? 'Команда эксперимента завершилась ошибкой: вывод о выполнимости не сделан.'
+            : `Успех на размерах ${input.sizes.join(', ')} с seed ${input.seed} в указанной среде. Не доказывает верхней границы на любом входе и других размерах.`;
+    const record = {
+        id,
+        repositoryId: repo.id,
+        sha,
+        command: input.command,
+        seed: input.seed,
+        sizes: input.sizes,
+        timeoutMs: input.timeoutMs,
+        question: input.question,
+        results,
+        outcome,
+        limits,
+        environment: {
+            platform: platform(),
+            arch: arch(),
+            node: process.version,
+            cpus: cpus().length,
+            isolation: ctx.policy.isolation.mode,
+        },
+        at: new Date().toISOString(),
+    };
+    // Сохраняется и возвращается маскированная форма; digest — от неё.
+    const safe = redactDeep(record, redact);
+    const spike = spikeSchema.parse({ ...safe, digest: digestOf(safe) });
+    ctx.engine.host.store.transact('checks.spike', (tx) => tx.putLocal('spikes', repo.id, id, spike));
+    return spike;
+}

package/package.json

@@ -1,6 +1,102 @@
 {
   "name": "devcontour-harness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.6",
+  "description": "Headless execution harness: work graph, isolated attempts, gates, independent reviews and accepted results.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/step1ov/devcontour-harness.git"
+  },
+  "homepage": "https://github.com/step1ov/devcontour-harness#readme",
+  "bugs": {
+    "url": "https://github.com/step1ov/devcontour-harness/issues"
+  },
+  "engines": {
+    "node": ">=24.3.0"
+  },
+  "bin": {
+    "harness": "lib/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./contracts": {
+      "types": "./lib/contracts/index.d.ts",
+      "default": "./lib/contracts/index.js"
+    },
+    "./package.json": "./package.json",
+    "./schemas/*": "./schemas/*",
+    "./testing": {
+      "types": "./lib/testing/index.d.ts",
+      "default": "./lib/testing/index.js"
+    },
+    "./toolchains": {
+      "types": "./lib/toolchains/index.d.ts",
+      "default": "./lib/toolchains/index.js"
+    },
+    "./integrations/connector": {
+      "types": "./lib/integrations/connector/index.d.ts",
+      "default": "./lib/integrations/connector/index.js"
+    },
+    "./integrations/relay-v1": {
+      "types": "./lib/integrations/relay-v1/index.d.ts",
+      "default": "./lib/integrations/relay-v1/index.js"
+    },
+    "./integrations/relay-v2": {
+      "types": "./lib/integrations/relay-v2/index.d.ts",
+      "default": "./lib/integrations/relay-v2/index.js"
+    },
+    "./integrations/memory": {
+      "types": "./lib/integrations/memory/index.d.ts",
+      "default": "./lib/integrations/memory/index.js"
+    }
+  },
+  "files": [
+    "lib",
+    "schemas",
+    "docs",
+    "examples",
+    "profiles",
+    "skills",
+    "templates",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "node scripts/clean.mjs && tsc -p tsconfig.build.json",
+    "prepack": "npm run schemas:check && npm run build",
+    "schemas": "node --import tsx scripts/build-schemas.ts",
+    "schemas:check": "node --import tsx scripts/build-schemas.ts --check",
+    "lint": "eslint .",
+    "test": "node scripts/test.mjs",
+    "test:integration": "node --import tsx --test --test-concurrency=1 --test-timeout=1800000 tests/integration/*.test.ts",
+    "test:package": "npm run build && node scripts/smoke-package.mjs",
+    "check": "npm run lint && npm run typecheck && npm run schemas:check && npm run build && npm test && node scripts/smoke-package.mjs",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check:install": "node scripts/install-check.mjs"
+  },
+  "dependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.77",
+    "fast-xml-parser": "5.11.1",
+    "zod": "4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.5",
+    "ajv": "8.20.0",
+    "eslint": "10.10.0",
+    "prettier": "3.9.7",
+    "tsx": "4.23.13",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.70.0"
+  }
+}

package/profiles/expo-mobile.json

@@ -0,0 +1,15 @@
+{
+  "id": "expo-mobile",
+  "version": "0.2.0",
+  "extends": [
+    "react-native"
+  ],
+  "capabilities": [
+    "expo"
+  ],
+  "protectedPaths": [
+    "app.config.js",
+    "app.config.ts",
+    "eas.json"
+  ]
+}

package/profiles/go-api.json

@@ -0,0 +1,15 @@
+{
+  "id": "go-api",
+  "version": "0.1.0",
+  "capabilities": ["go", "openapi", "integration-tests"],
+  "gates": [
+    { "id": "vet", "kind": "check", "command": ["go", "vet", "./..."], "timeoutMs": 120000 },
+    {
+      "id": "acceptance",
+      "kind": "test",
+      "command": ["gotestsum", "--junitfile", ".reports/junit.xml", "--", "-race", "./..."],
+      "timeoutMs": 240000,
+      "report": { "type": "junit", "path": ".reports/junit.xml" }
+    }
+  ]
+}

package/profiles/go-gotestsum.json

@@ -0,0 +1,21 @@
+{
+  "id": "go-gotestsum",
+  "version": "0.1.0",
+  "capabilities": ["go", "unit-tests"],
+  "protectedPaths": ["go.mod", "go.sum"],
+  "toolchain": {
+    "tools": { "gotestsum": "1.12.3" }
+  },
+  "prepare": [{ "id": "install", "command": ["go", "mod", "download"], "timeoutMs": 600000 }],
+  "gates": [
+    { "id": "vet", "kind": "check", "command": ["go", "vet", "./..."], "timeoutMs": 240000 },
+    {
+      "id": "acceptance",
+      "kind": "test",
+      "command": ["gotestsum", "--junitfile", ".reports/junit.xml", "--", "-count=1", "./..."],
+      "timeoutMs": 240000,
+      "dependsOn": ["vet"],
+      "report": { "type": "junit", "path": ".reports/junit.xml" }
+    }
+  ]
+}

package/profiles/mobile-maestro.json

@@ -0,0 +1,29 @@
+{
+  "id": "mobile-maestro",
+  "version": "0.1.0",
+  "capabilities": ["mobile", "maestro", "device-lease-required"],
+  "concurrency": 1,
+  "gates": [
+    {
+      "id": "build-and-install",
+      "kind": "check",
+      "command": ["npm", "run", "mobile:devcontour:prepare"],
+      "timeoutMs": 600000
+    },
+    {
+      "id": "mobile-acceptance",
+      "kind": "test",
+      "command": [
+        "maestro",
+        "test",
+        ".maestro/",
+        "--format",
+        "junit",
+        "--output",
+        ".reports/junit.xml"
+      ],
+      "timeoutMs": 600000,
+      "report": { "type": "junit", "path": ".reports/junit.xml" }
+    }
+  ]
+}

package/profiles/nest-api.json

@@ -0,0 +1,26 @@
+{
+  "id": "nest-api",
+  "version": "0.1.0",
+  "extends": ["node-checks"],
+  "capabilities": ["nestjs", "api", "integration-tests"],
+  "gates": [
+    {
+      "id": "build",
+      "kind": "check",
+      "command": ["npm", "run", "build"],
+      "timeoutMs": 240000,
+      "dependsOn": ["typecheck"]
+    },
+    {
+      "id": "api-acceptance",
+      "kind": "test",
+      "command": ["npm", "run", "test:devcontour:integration"],
+      "timeoutMs": 240000,
+      "dependsOn": ["build"],
+      "report": {
+        "type": "junit",
+        "path": ".reports/integration.xml"
+      }
+    }
+  ]
+}