@yanolja-next/noya-sdk 0.1.0

package/dist/src/sentry.js

@@ -0,0 +1,125 @@
+import crypto from "node:crypto";
+export async function fetchSentryEventContext(project, sentry) {
+    const integration = sentryIntegration(project);
+    const eventId = sentry?.event_id;
+    if (!eventId || Object.keys(integration).length === 0)
+        return {};
+    const apiBase = String(integration.api_base ?? "https://sentry.io").replace(/\/$/, "");
+    const orgSlug = stringSetting(integration.org_slug) ?? project.telemetry?.org_slug ?? project.sentry?.org_slug;
+    const projectSlug = stringSetting(integration.project_slug) ?? project.telemetry?.project_slug ?? project.sentry?.project_slug;
+    const tokenEnv = stringSetting(integration.token_env);
+    if (!orgSlug || !projectSlug || !tokenEnv)
+        return {};
+    const token = process.env[tokenEnv];
+    if (!token)
+        throw new Error(`Missing Sentry token env var: ${tokenEnv}`);
+    const response = await fetch(`${apiBase}/api/0/projects/${encodeURIComponent(orgSlug)}/${encodeURIComponent(projectSlug)}/events/${encodeURIComponent(eventId)}/`, {
+        headers: {
+            authorization: `Bearer ${token}`,
+            accept: "application/json",
+        },
+    });
+    if (!response.ok)
+        throw new Error(`Sentry event lookup failed: ${response.status}`);
+    return sentryEventToReport((await response.json()));
+}
+export function verifySentryWebhookSignature({ project, rawBody, signature, }) {
+    const integration = sentryIntegration(project);
+    const secretEnv = stringSetting(integration.webhook_secret_env);
+    if (!secretEnv)
+        return;
+    const secret = process.env[secretEnv];
+    if (!secret)
+        throw Object.assign(new Error(`Missing Sentry webhook secret env var: ${secretEnv}`), { status: 500 });
+    if (!signature)
+        throw Object.assign(new Error("Missing Sentry webhook signature"), { status: 401 });
+    const expected = crypto.createHmac("sha256", secret).update(rawBody).digest("hex");
+    if (!constantTimeEqual(signature.replace(/^sha256=/, ""), expected)) {
+        throw Object.assign(new Error("Invalid Sentry webhook signature"), { status: 401 });
+    }
+}
+function sentryEventToReport(event) {
+    const tags = tagsToObject(event.tags);
+    const request = objectValue(event.request);
+    const user = objectValue(event.user);
+    const contexts = objectValue(event.contexts);
+    const replay = objectValue(contexts?.replay);
+    const entries = Array.isArray(event.entries) ? event.entries : [];
+    const breadcrumbs = entries.find((entry) => {
+        const candidate = objectValue(entry);
+        return candidate?.type === "breadcrumbs";
+    });
+    return {
+        message: stringValue(event.title) ?? stringValue(event.message),
+        release: stringValue(event.release) ?? stringValue(tags.release),
+        environment: stringValue(event.environment),
+        route: stringValue(request?.url) ?? stringValue(tags.route),
+        request_id: stringValue(tags.request_id) ?? stringValue(event.request_id),
+        screenshot_url: stringValue(event.screenshot_url) ??
+            stringValue(event.screenshotUrl) ??
+            stringValue(tags.screenshot_url),
+        sentry: {
+            event_id: stringValue(event.eventID) ?? stringValue(event.event_id) ?? stringValue(event.id),
+            replay_id: stringValue(replay?.replay_id) ?? stringValue(tags.replay_id),
+            feedback_id: stringValue(tags.feedback_id),
+            event_url: stringValue(event.web_url),
+        },
+        telemetry: {
+            provider: "sentry",
+            event_id: stringValue(event.eventID) ?? stringValue(event.event_id) ?? stringValue(event.id),
+            replay_id: stringValue(replay?.replay_id) ?? stringValue(tags.replay_id),
+            feedback_id: stringValue(tags.feedback_id),
+            event_url: stringValue(event.web_url),
+        },
+        context: {
+            user_id: stringValue(user?.id),
+            email: stringValue(user?.email),
+            tenant_id: stringValue(tags.tenant_id),
+            trace_id: stringValue(tags.trace_id),
+            sentry_breadcrumbs: objectValue(breadcrumbs)?.data ?? null,
+        },
+    };
+}
+function sentryIntegration(project) {
+    const integrations = project.integrations ?? {};
+    const telemetry = objectValue(integrations.telemetry);
+    if (!telemetry || telemetry.provider === "sentry") {
+        return ((integrations.sentry ?? telemetry) ?? {});
+    }
+    return {};
+}
+function tagsToObject(value) {
+    if (!value)
+        return {};
+    if (!Array.isArray(value) && typeof value === "object")
+        return value;
+    if (!Array.isArray(value))
+        return {};
+    return Object.fromEntries(value
+        .map((entry) => {
+        const object = objectValue(entry);
+        const key = stringValue(object?.key) ?? stringValue(object?.name);
+        if (!key)
+            return null;
+        return [key, object?.value];
+    })
+        .filter((entry) => entry != null));
+}
+function objectValue(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function stringSetting(value) {
+    return stringValue(value);
+}
+function constantTimeEqual(left, right) {
+    const leftBuffer = Buffer.from(left, "hex");
+    const rightBuffer = Buffer.from(right, "hex");
+    if (leftBuffer.length !== rightBuffer.length)
+        return false;
+    return crypto.timingSafeEqual(leftBuffer, rightBuffer);
+}

package/dist/src/server.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from "node:http";
+import { JsonStore } from "./store.js";
+type NoyaServer = Server & {
+    store: JsonStore;
+};
+export declare function createServer({ storePath, seed, }?: {
+    storePath?: string;
+    seed?: boolean;
+}): NoyaServer;
+export {};

package/dist/src/server.js

@@ -0,0 +1,498 @@
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { verifySentryWebhookSignature } from "./sentry.js";
+import { JsonStore } from "./store.js";
+import { publicState } from "./store.js";
+import { approveFix, completeJob, failJob, heartbeatJob, nextRunnerJob, receiveReport, receiveSentryWebhook, upsertProject, } from "./orchestrator.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const compiledRoot = path.resolve(__dirname, "..");
+const rootDir = fs.existsSync(path.join(compiledRoot, "public"))
+    ? compiledRoot
+    : path.resolve(compiledRoot, "..");
+export function createServer({ storePath = ".noya/state.json", seed = true, } = {}) {
+    const store = new JsonStore(storePath);
+    if (seed && !store.state.projects["agency-platform"]) {
+        upsertProject(store, defaultAgencyProject());
+    }
+    const server = http.createServer(async (req, res) => {
+        try {
+            await route(req, res, store);
+        }
+        catch (error) {
+            const status = typeof error === "object" && error && "status" in error ? Number(error.status) : 500;
+            sendJson(res, status, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    const noyaServer = server;
+    noyaServer.store = store;
+    return noyaServer;
+}
+async function route(req, res, store) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (req.method === "GET" && (url.pathname === "/healthz" || url.pathname === "/api/healthz")) {
+        return sendJson(res, 200, { ok: true });
+    }
+    if (req.method === "GET" && url.pathname === "/api/dashboard/state") {
+        requireAdminAuth(req);
+        return sendJson(res, 200, dashboardState(store));
+    }
+    if (req.method === "POST" && url.pathname === "/api/projects") {
+        requireAdminAuth(req);
+        return sendJson(res, 200, upsertProject(store, (await readJson(req))));
+    }
+    const retention = url.pathname.match(/^\/api\/projects\/([^/]+)\/retention\/cleanup$/);
+    if (req.method === "POST" && retention) {
+        requireAdminAuth(req);
+        return sendJson(res, 200, cleanupProjectRetention(store, decodeURIComponent(retention[1])));
+    }
+    if (req.method === "POST" && url.pathname === "/api/reports") {
+        return sendJson(res, 202, await receiveReport(store, (await readJson(req))));
+    }
+    if (req.method === "POST" && url.pathname === "/api/webhooks/sentry") {
+        const rawBody = await readRaw(req);
+        const payload = parseJson(rawBody);
+        verifyWebhookAuth(store, payload, rawBody, req);
+        return sendJson(res, 202, await receiveSentryWebhook(store, payload));
+    }
+    if (req.method === "POST" && url.pathname === "/api/webhooks/telemetry") {
+        const rawBody = await readRaw(req);
+        const payload = parseJson(rawBody);
+        verifyWebhookAuth(store, payload, rawBody, req);
+        return sendJson(res, 202, await receiveSentryWebhook(store, payload));
+    }
+    if (req.method === "POST" && url.pathname === "/api/dev/sample/agency-platform-report") {
+        requireAdminAuth(req);
+        return sendJson(res, 202, await receiveReport(store, sampleAgencyReport()));
+    }
+    if (req.method === "GET" && url.pathname === "/runner/jobs/next") {
+        requireRunnerAuth(store, url.searchParams.get("project_key"), req);
+        const capabilities = parseJsonParam(url.searchParams.get("capabilities")) ?? {
+            collect: { enabled: true },
+            fix: { enabled: true },
+        };
+        const job = nextRunnerJob(store, {
+            projectKey: url.searchParams.get("project_key"),
+            runnerId: url.searchParams.get("runner_id") ?? "runner-local",
+            capabilities: capabilities,
+        });
+        return sendJson(res, 200, { job });
+    }
+    const heartbeat = url.pathname.match(/^\/runner\/jobs\/([^/]+)\/heartbeat$/);
+    if (req.method === "POST" && heartbeat) {
+        requireRunnerAuth(store, projectKeyForJob(store, heartbeat[1]), req);
+        return sendJson(res, 200, heartbeatJob(store, heartbeat[1]));
+    }
+    const complete = url.pathname.match(/^\/runner\/jobs\/([^/]+)\/complete$/);
+    if (req.method === "POST" && complete) {
+        requireRunnerAuth(store, projectKeyForJob(store, complete[1]), req);
+        return sendJson(res, 200, await completeJob(store, complete[1], await readJson(req)));
+    }
+    const fail = url.pathname.match(/^\/runner\/jobs\/([^/]+)\/fail$/);
+    if (req.method === "POST" && fail) {
+        requireRunnerAuth(store, projectKeyForJob(store, fail[1]), req);
+        return sendJson(res, 200, failJob(store, fail[1], await readJson(req)));
+    }
+    const approve = url.pathname.match(/^\/api\/issues\/([^/]+)\/approve-fix$/);
+    if (req.method === "POST" && approve) {
+        requireAdminAuth(req);
+        return sendJson(res, 202, approveFix(store, approve[1]));
+    }
+    const artifact = url.pathname.match(/^\/artifacts\/(issues|prs)\/([^/]+)$/);
+    if (req.method === "GET" && artifact) {
+        requireAdminAuth(req);
+        return serveArtifact(res, store, artifact[1], artifact[2]);
+    }
+    if (req.method === "GET")
+        return serveStatic(res, url.pathname);
+    sendJson(res, 404, { error: "not found" });
+}
+function serveArtifact(res, store, kind, id) {
+    const artifact = artifactPathFor(store, kind, id);
+    const artifactPath = artifact?.path;
+    if (!artifactPath)
+        return sendJson(res, 404, { error: "artifact not found" });
+    const resolved = path.resolve(artifactPath);
+    const artifactRoot = path.resolve(artifact.project.artifact_dir);
+    if (!isPathInside(resolved, artifactRoot)) {
+        return sendJson(res, 403, { error: "artifact path outside project artifact_dir" });
+    }
+    if (!fs.existsSync(resolved) || fs.statSync(resolved).isDirectory()) {
+        return sendJson(res, 404, { error: "artifact not found" });
+    }
+    res.writeHead(200, {
+        "content-type": "text/markdown; charset=utf-8",
+        "x-content-type-options": "nosniff",
+    });
+    fs.createReadStream(resolved).pipe(res);
+}
+function dashboardState(store) {
+    return {
+        ...publicState(store.state),
+        readiness: Object.values(store.state.projects).map((project) => ({
+            project_key: project.project_key,
+            checks: readinessChecks(project),
+        })),
+    };
+}
+function readinessChecks(project) {
+    return [
+        artifactDirCheck(project),
+        retentionCheck(project),
+        runnerRepoCheck(project),
+        envCheck("Runner token", project.runner?.token_env),
+        providerCheck(project),
+        envCheck("Telemetry lookup token", stringAt(telemetryIntegration(project), "token_env")),
+        envCheck("Telemetry webhook secret", stringAt(telemetryIntegration(project), "webhook_secret_env")),
+    ];
+}
+function retentionCheck(project) {
+    if (project.retention_days == null) {
+        return { name: "Artifact retention", status: "warn", detail: "not configured" };
+    }
+    return {
+        name: "Artifact retention",
+        status: "pass",
+        detail: `${project.retention_days} day(s)`,
+    };
+}
+function artifactDirCheck(project) {
+    try {
+        fs.mkdirSync(project.artifact_dir, { recursive: true });
+        fs.accessSync(project.artifact_dir, fs.constants.W_OK);
+        return { name: "Artifact directory", status: "pass", detail: project.artifact_dir };
+    }
+    catch (error) {
+        return {
+            name: "Artifact directory",
+            status: "fail",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function runnerRepoCheck(project) {
+    const repoPath = project.runner?.repo_path;
+    if (!repoPath)
+        return { name: "Runner repo", status: "warn", detail: "No runner repo_path configured" };
+    if (process.env.NOYA_VALIDATE_RUNNER_REPO === "false") {
+        return { name: "Runner repo", status: "pass", detail: `configured for runner: ${repoPath}` };
+    }
+    const packageJson = path.join(repoPath, "package.json");
+    const gitDir = path.join(repoPath, ".git");
+    if (!fs.existsSync(repoPath))
+        return { name: "Runner repo", status: "fail", detail: repoPath };
+    if (!fs.existsSync(packageJson) && !fs.existsSync(gitDir)) {
+        return { name: "Runner repo", status: "warn", detail: `${repoPath} exists without package.json or .git` };
+    }
+    return { name: "Runner repo", status: "pass", detail: repoPath };
+}
+function providerCheck(project) {
+    if (project.issue_provider === "local")
+        return { name: "Issue provider", status: "pass", detail: "local" };
+    if (project.issue_provider === "github") {
+        const github = project.integrations?.github;
+        const missing = ["owner", "repo", "token_env"].filter((key) => !stringAt(github, key));
+        if (missing.length > 0) {
+            return { name: "Issue provider", status: "fail", detail: `github missing ${missing.join(", ")}` };
+        }
+        return envCheck("Issue provider", stringAt(github, "token_env"), "github");
+    }
+    if (project.issue_provider === "jira") {
+        const jira = project.integrations?.jira;
+        const missing = ["api_base", "project_key", "email", "token_env"].filter((key) => !stringAt(jira, key));
+        if (missing.length > 0) {
+            return { name: "Issue provider", status: "fail", detail: `jira missing ${missing.join(", ")}` };
+        }
+        return envCheck("Issue provider", stringAt(jira, "token_env"), "jira");
+    }
+    return { name: "Issue provider", status: "fail", detail: `unsupported provider ${project.issue_provider}` };
+}
+function telemetryIntegration(project) {
+    const integrations = project.integrations ?? {};
+    const telemetry = integrations.telemetry;
+    if (telemetry && typeof telemetry === "object" && !Array.isArray(telemetry)) {
+        return telemetry;
+    }
+    const sentry = integrations.sentry;
+    if (sentry && typeof sentry === "object" && !Array.isArray(sentry)) {
+        return sentry;
+    }
+    return undefined;
+}
+function envCheck(name, envName, label = "optional") {
+    if (!envName)
+        return { name, status: "pass", detail: `${label}: not configured` };
+    return process.env[envName]
+        ? { name, status: "pass", detail: envName }
+        : { name, status: "fail", detail: `${envName} is not set` };
+}
+function stringAt(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const found = value[key];
+    return typeof found === "string" && found.length > 0 ? found : undefined;
+}
+function artifactPathFor(store, kind, id) {
+    if (kind === "issues") {
+        const issue = store.state.issues[id];
+        const pathValue = issue?.integration?.path;
+        const project = issue ? store.state.projects[issue.project_key] : undefined;
+        return project && typeof pathValue === "string" ? { project, path: pathValue } : undefined;
+    }
+    if (kind === "prs") {
+        const issue = Object.values(store.state.issues).find((candidate) => {
+            return candidate.fix?.draft_pr && candidate.fix.draft_pr.external_id === id;
+        });
+        const pathValue = issue?.fix?.draft_pr?.path;
+        const project = issue ? store.state.projects[issue.project_key] : undefined;
+        return project && typeof pathValue === "string" ? { project, path: pathValue } : undefined;
+    }
+    return undefined;
+}
+function isPathInside(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function cleanupProjectRetention(store, projectKey) {
+    const project = store.state.projects[projectKey];
+    if (!project)
+        throw Object.assign(new Error(`Unknown project: ${projectKey}`), { status: 404 });
+    if (project.retention_days == null) {
+        return { project_key: project.project_key, retention_days: null, deleted: [] };
+    }
+    const root = path.resolve(project.artifact_dir);
+    const cutoff = Date.now() - project.retention_days * 24 * 60 * 60 * 1000;
+    const deleted = [];
+    if (fs.existsSync(root)) {
+        for (const filePath of listFiles(root)) {
+            const resolved = path.resolve(filePath);
+            if (!isPathInside(resolved, root))
+                continue;
+            const stat = fs.statSync(resolved);
+            if (stat.mtimeMs > cutoff)
+                continue;
+            fs.rmSync(resolved, { force: true });
+            deleted.push(resolved);
+        }
+        pruneEmptyDirs(root, root);
+    }
+    store.audit("artifacts.retention.cleaned", {
+        project_key: project.project_key,
+        retention_days: project.retention_days,
+        deleted_count: deleted.length,
+    });
+    return { project_key: project.project_key, retention_days: project.retention_days, deleted };
+}
+function listFiles(root) {
+    const output = [];
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory())
+            output.push(...listFiles(fullPath));
+        else if (entry.isFile())
+            output.push(fullPath);
+    }
+    return output;
+}
+function pruneEmptyDirs(root, preserveRoot) {
+    if (!fs.existsSync(root))
+        return;
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        pruneEmptyDirs(path.join(root, entry.name), preserveRoot);
+    }
+    if (root === preserveRoot)
+        return;
+    try {
+        if (fs.readdirSync(root).length === 0)
+            fs.rmdirSync(root);
+    }
+    catch {
+        // Directory may have been removed or refilled by another process.
+    }
+}
+function serveStatic(res, pathname) {
+    const filePath = pathname === "/" ? "public/index.html" : `public${pathname}`;
+    const resolved = path.resolve(rootDir, filePath);
+    if (!resolved.startsWith(path.resolve(rootDir, "public"))) {
+        return sendJson(res, 403, { error: "forbidden" });
+    }
+    if (!fs.existsSync(resolved) || fs.statSync(resolved).isDirectory()) {
+        return sendJson(res, 404, { error: "not found" });
+    }
+    const ext = path.extname(resolved);
+    const type = ext === ".html" ? "text/html" : ext === ".css" ? "text/css" : "application/javascript";
+    res.writeHead(200, { "content-type": `${type}; charset=utf-8` });
+    fs.createReadStream(resolved).pipe(res);
+}
+function sendJson(res, status, payload) {
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(payload, null, 2));
+}
+async function readJson(req) {
+    const raw = await readRaw(req);
+    if (!raw)
+        return {};
+    return parseJson(raw);
+}
+function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw Object.assign(new Error("Invalid JSON body"), { status: 400 });
+    }
+}
+async function readRaw(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    if (chunks.length === 0)
+        return "";
+    return Buffer.concat(chunks).toString("utf8");
+}
+function parseJsonParam(value) {
+    if (!value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function projectKeyForJob(store, jobId) {
+    return store.state.jobs[jobId]?.project_key ?? null;
+}
+function requireRunnerAuth(store, projectKey, req) {
+    if (!projectKey) {
+        throw Object.assign(new Error("Missing runner project"), { status: 404 });
+    }
+    const project = store.state.projects[projectKey];
+    if (!project) {
+        throw Object.assign(new Error(`Unknown project: ${projectKey}`), { status: 404 });
+    }
+    const tokenEnv = project.runner?.token_env;
+    if (!tokenEnv)
+        return;
+    const expected = process.env[tokenEnv];
+    if (!expected) {
+        throw Object.assign(new Error(`Missing runner token env var: ${tokenEnv}`), { status: 500 });
+    }
+    if (req.headers.authorization !== `Bearer ${expected}`) {
+        throw Object.assign(new Error("Runner authorization failed"), { status: 401 });
+    }
+}
+function requireAdminAuth(req) {
+    const expected = process.env.NOYA_ADMIN_TOKEN;
+    if (!expected)
+        return;
+    if (req.headers.authorization !== `Bearer ${expected}`) {
+        throw Object.assign(new Error("Admin authorization failed"), { status: 401 });
+    }
+}
+function verifyWebhookAuth(store, payload, rawBody, req) {
+    const projectKey = webhookProjectKey(payload);
+    const project = projectKey ? store.state.projects[projectKey] : undefined;
+    if (!project)
+        return;
+    const signature = headerValue(req.headers["sentry-hook-signature"]) ??
+        headerValue(req.headers["x-noya-signature"]) ??
+        headerValue(req.headers["x-sentry-signature"]);
+    verifySentryWebhookSignature({ project, rawBody, signature });
+}
+function webhookProjectKey(payload) {
+    const direct = payload.project_key ?? payload.projectKey;
+    if (typeof direct === "string")
+        return direct;
+    const project = payload.project;
+    if (project && typeof project === "object" && !Array.isArray(project)) {
+        const slug = project.slug;
+        if (typeof slug === "string")
+            return slug;
+    }
+    return undefined;
+}
+function headerValue(value) {
+    if (Array.isArray(value))
+        return value[0];
+    return value;
+}
+function defaultAgencyProject() {
+    return {
+        project_key: "agency-platform",
+        name: "Agency Platform",
+        environment: "local",
+        issue_provider: "local",
+        artifact_dir: defaultArtifactDir("agency-platform"),
+        retention_days: 30,
+        created_at: new Date().toISOString(),
+        telemetry: {
+            provider: "sentry",
+            org_slug: "yanolja",
+            project_slug: "agency-user-web",
+        },
+        runner: {
+            enabled: true,
+            repo_path: "/workspace/agency-platform",
+            collect: { enabled: true, auto: true },
+            fix: { enabled: true, auto: false, require_approval: true },
+            sources: [
+                { name: "api_logs_by_request", type: "fixture_logs", when: { has: "request_id" } },
+                { name: "trip_snapshot", type: "fixture_domain", when: { has: "trip_id" } },
+            ],
+        },
+    };
+}
+function sampleAgencyReport() {
+    return {
+        report_id: `agency-sample-${Date.now()}`,
+        project_key: "agency-platform",
+        environment: "local",
+        release: "agency-platform-local",
+        route: "/trips/TRIP-4242/proposal",
+        message: "Reservation button stays disabled after selecting booker nationality",
+        impact: "CS operator cannot complete booking from the proposal flow.",
+        request_id: "req_agency_4242",
+        telemetry: {
+            provider: "sentry",
+            event_id: "sentry-event-agency-4242",
+            replay_id: "replay-agency-4242",
+            feedback_id: "feedback-agency-4242",
+        },
+        context: {
+            tenant_id: "tenant_demo",
+            user_id: "user_demo",
+            trip_id: "TRIP-4242",
+            booking_id: "BOOK-4242",
+            customer_email: "traveler@example.com",
+        },
+        reproduction_steps: [
+            "Open the proposal detail page.",
+            "Select booker nationality.",
+            "Try to click Reserve.",
+        ],
+        expected_behavior: "Reserve becomes available once required booker fields are complete.",
+        actual_behavior: "Reserve remains disabled.",
+        suspected_area: "agency_user_web proposal reservation flow",
+        suspected_files: [
+            "product/agency_user_web/src/app/**/proposal*",
+            "product/agency_user_e2e/booker-nationality-reserve-voucher.spec.ts",
+        ],
+    };
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const port = Number(process.env.NOYA_PORT ?? process.env.PORT ?? 3456);
+    const server = createServer({ storePath: process.env.NOYA_STATE_PATH ?? ".noya/state.json" });
+    server.listen(port, () => {
+        console.log(`Noya listening on http://localhost:${port}`);
+    });
+}
+function defaultArtifactDir(projectKey) {
+    const root = process.env.NOYA_ARTIFACT_ROOT;
+    return root ? `${root.replace(/\/$/, "")}/${projectKey}` : `.noya/artifacts/${projectKey}`;
+}

package/dist/src/store.d.ts

@@ -0,0 +1,18 @@
+import type { AuditEntry, JsonObject, State } from "./types.js";
+export declare function createInitialState(): State;
+export declare class JsonStore {
+    filePath?: string;
+    state: State;
+    constructor(filePath?: string);
+    load(): void;
+    save(): void;
+    id(prefix: string): string;
+    audit(action: string, details?: JsonObject): AuditEntry;
+}
+export declare function publicState(state: State): {
+    projects: import("./types.js").Project[];
+    reports: import("./types.js").Report[];
+    issues: import("./types.js").Issue[];
+    jobs: import("./types.js").Job[];
+    audit: AuditEntry[];
+};