@yanolja-next/noya-sdk 0.1.0

package/dist/src/orchestrator.js

@@ -0,0 +1,594 @@
+import { compileIssue } from "./issueCompiler.js";
+import { createLocalDraftPr, createProviderIssue, updateProviderIssueAfterFix } from "./adapters.js";
+import { collectHints, redactValue } from "./redaction.js";
+import { fetchSentryEventContext } from "./sentry.js";
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export async function receiveSentryWebhook(store, payload) {
+    const projectKey = stringAt(payload, "project_key") ??
+        stringAt(payload, "projectKey") ??
+        stringAt(payload, "project.slug") ??
+        "agency-platform";
+    const event = objectAt(payload, "event") ?? payload;
+    const user = objectAt(event, "user");
+    const tags = objectAt(event, "tags");
+    const request = objectAt(event, "request");
+    const contexts = objectAt(event, "contexts");
+    const replayId = stringAt(event, "replay_id") ??
+        stringAt(event, "replayId") ??
+        stringAt(contexts, "replay.replay_id");
+    const eventId = stringAt(event, "event_id") ?? stringAt(event, "eventID") ?? stringAt(event, "id");
+    return receiveReport(store, {
+        report_id: stringAt(payload, "report_id") ?? (eventId ? `sentry-${eventId}` : undefined),
+        project_key: projectKey,
+        environment: stringAt(event, "environment"),
+        release: stringAt(event, "release"),
+        route: stringAt(request, "url"),
+        message: stringAt(event, "title") ?? stringAt(event, "message"),
+        request_id: stringAt(tags, "request_id") ?? stringAt(event, "request_id"),
+        telemetry: {
+            provider: "sentry",
+            event_id: eventId,
+            replay_id: replayId,
+            feedback_id: stringAt(event, "feedback_id"),
+            event_url: stringAt(event, "web_url"),
+        },
+        context: {
+            user_id: stringAt(user, "id"),
+            email: stringAt(user, "email"),
+            tenant_id: stringAt(tags, "tenant_id"),
+            trace_id: stringAt(tags, "trace_id"),
+        },
+    });
+}
+export function upsertProject(store, input) {
+    if (!input || typeof input.project_key !== "string" || input.project_key.length === 0) {
+        throw new HttpError(400, "project_key is required");
+    }
+    if (input.issue_provider && !["local", "github", "jira"].includes(input.issue_provider)) {
+        throw new HttpError(400, `Unsupported issue_provider: ${input.issue_provider}`);
+    }
+    if (input.retention_days != null &&
+        (typeof input.retention_days !== "number" || input.retention_days < 0 || !Number.isFinite(input.retention_days))) {
+        throw new HttpError(400, "retention_days must be a non-negative number");
+    }
+    validateNoInlineCredentials(input.integrations);
+    const existing = store.state.projects[input.project_key];
+    const runner = mergeRunnerConfig(input.runner);
+    const telemetry = input.telemetry ?? legacyProjectTelemetry(input.sentry) ?? existing?.telemetry;
+    const project = {
+        project_key: input.project_key,
+        name: input.name ?? input.project_key,
+        environment: input.environment ?? "local",
+        issue_provider: input.issue_provider ?? "local",
+        artifact_dir: input.artifact_dir ?? defaultArtifactDir(input.project_key),
+        retention_days: input.retention_days ?? existing?.retention_days,
+        runner,
+        telemetry,
+        sentry: input.sentry ?? {},
+        integrations: input.integrations ?? {},
+        created_at: existing?.created_at ?? input.created_at ?? new Date().toISOString(),
+    };
+    store.state.projects[project.project_key] = project;
+    store.save();
+    store.audit("project.upserted", { project_key: project.project_key });
+    return project;
+}
+function defaultArtifactDir(projectKey) {
+    const root = process.env.NOYA_ARTIFACT_ROOT;
+    return root ? `${root.replace(/\/$/, "")}/${projectKey}` : ".noya/artifacts";
+}
+function legacyProjectTelemetry(sentry) {
+    if (!sentry)
+        return undefined;
+    return {
+        provider: "sentry",
+        org_slug: sentry.org_slug,
+        project_slug: sentry.project_slug,
+    };
+}
+function validateNoInlineCredentials(value, path = "integrations") {
+    if (!value || typeof value !== "object")
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((child, index) => validateNoInlineCredentials(child, `${path}[${index}]`));
+        return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = `${path}.${key}`;
+        if (isInlineCredentialKey(key)) {
+            throw new HttpError(400, `Inline credential is not allowed at ${childPath}; use an *_env setting instead`);
+        }
+        validateNoInlineCredentials(child, childPath);
+    }
+}
+function isInlineCredentialKey(key) {
+    if (/_env$/i.test(key))
+        return false;
+    return /^(authorization|bearer|password|secret|token|api[_-]?key|client[_-]?secret)$/i.test(key);
+}
+export async function receiveReport(store, envelope) {
+    const project = store.state.projects[envelope.project_key];
+    if (!project) {
+        throw new HttpError(404, `Unknown project_key: ${envelope.project_key}`);
+    }
+    const id = envelope.report_id || store.id("rep");
+    const redacted = redactValue(envelope, { mode: "strict" });
+    const telemetry = enrichTelemetry(project, {
+        ...(redacted.telemetry ?? {}),
+        ...(redacted.sentry ? legacySentryToTelemetry(redacted.sentry) : {}),
+    });
+    const sentry = telemetryToSentry(project, telemetry);
+    const sentryContext = redactValue(await fetchSentryEventContext(project, sentry), {
+        mode: "strict",
+    });
+    const contextTelemetry = enrichTelemetry(project, {
+        ...telemetry,
+        ...(sentryContext.telemetry ?? {}),
+        ...(sentryContext.sentry ? legacySentryToTelemetry(sentryContext.sentry) : {}),
+    });
+    const report = {
+        id,
+        project_key: envelope.project_key,
+        message: redacted.message ?? sentryContext.message,
+        impact: redacted.impact,
+        environment: redacted.environment ?? sentryContext.environment ?? project.environment,
+        release: redacted.release ?? sentryContext.release,
+        route: redacted.route ?? sentryContext.route,
+        browser: redacted.browser,
+        request_id: redacted.request_id ?? sentryContext.request_id,
+        screenshot_url: redacted.screenshot_url ?? sentryContext.screenshot_url,
+        feedback: redacted.feedback,
+        telemetry: contextTelemetry,
+        sentry: telemetryToSentry(project, contextTelemetry),
+        context: mergeObjects(sentryContext.context, redacted.context),
+        reproduction_steps: redacted.reproduction_steps ?? inferReproSteps(redacted),
+        expected_behavior: redacted.expected_behavior,
+        actual_behavior: redacted.actual_behavior,
+        suspected_area: redacted.suspected_area,
+        suspected_files: redacted.suspected_files ?? [],
+        hints: collectHints(redacted),
+        status: "received",
+        created_at: new Date().toISOString(),
+    };
+    report.hints = { ...collectHints(sentryContext), ...report.hints };
+    store.state.reports[id] = report;
+    store.audit("report.received", { project_key: project.project_key, report_id: id });
+    if (runnerCollectEnabled(project)) {
+        const job = createJob(store, {
+            type: "collect",
+            project_key: project.project_key,
+            report_id: id,
+            payload: {
+                report,
+                collector_plan: buildCollectorPlan(project, report),
+            },
+        });
+        report.status = "collect_queued";
+        store.save();
+        return { report, job, issue: null };
+    }
+    const issue = await createIssueFromReport(store, project, report);
+    return { report, job: null, issue };
+}
+export function nextRunnerJob(store, { projectKey, runnerId, capabilities, }) {
+    requeueStaleRunnerJobs(store, projectKey);
+    const project = projectKey ? store.state.projects[projectKey] : undefined;
+    if (!project || project.runner?.enabled === false)
+        return null;
+    const job = Object.values(store.state.jobs).find((candidate) => {
+        if (candidate.project_key !== projectKey || candidate.status !== "queued")
+            return false;
+        if (candidate.type === "fix" && !capabilities?.fix?.enabled)
+            return false;
+        if (candidate.type === "collect" && !capabilities?.collect?.enabled)
+            return false;
+        return true;
+    });
+    if (!job)
+        return null;
+    job.status = "leased";
+    job.runner_id = runnerId;
+    job.leased_at = new Date().toISOString();
+    job.heartbeat_at = job.leased_at;
+    job.lease_count = (job.lease_count ?? 0) + 1;
+    store.save();
+    store.audit("runner.job.leased", { job_id: job.id, runner_id: runnerId });
+    return job;
+}
+export function heartbeatJob(store, jobId) {
+    const job = requireJob(store, jobId);
+    job.heartbeat_at = new Date().toISOString();
+    store.save();
+    store.audit("runner.job.heartbeat", { job_id: job.id });
+    return job;
+}
+export async function completeJob(store, jobId, result) {
+    const job = requireJob(store, jobId);
+    const project = store.state.projects[job.project_key];
+    const validatedResult = validateRunnerResult(job, result);
+    job.status = "completed";
+    job.completed_at = new Date().toISOString();
+    job.result = redactValue(validatedResult, { mode: "strict" });
+    store.audit("runner.job.completed", { job_id: job.id, type: job.type });
+    if (job.type === "collect") {
+        auditCollectorPolicy(store, job);
+        if (!job.report_id)
+            throw new HttpError(409, "Collect job is missing report_id");
+        const report = store.state.reports[job.report_id];
+        if (!report)
+            throw new HttpError(404, `Unknown report: ${job.report_id}`);
+        if (!project)
+            throw new HttpError(404, `Unknown project: ${job.project_key}`);
+        report.status = "issue_created";
+        const issue = await createIssueFromReport(store, project, report, job.result);
+        store.save();
+        return { job, issue };
+    }
+    if (job.type === "fix") {
+        auditFixAgent(store, job);
+        if (!project)
+            throw new HttpError(404, `Unknown project: ${job.project_key}`);
+        if (!job.issue_id)
+            throw new HttpError(409, "Fix job is missing issue_id");
+        const issue = store.state.issues[job.issue_id];
+        if (!issue)
+            throw new HttpError(404, `Unknown issue: ${job.issue_id}`);
+        const draftPr = createLocalDraftPr({ store, project, job, result: job.result ?? {} });
+        let providerUpdate = null;
+        let providerUpdateError;
+        try {
+            providerUpdate = await updateProviderIssueAfterFix({
+                store,
+                project,
+                issue,
+                draftPr,
+                result: job.result ?? {},
+            });
+        }
+        catch (error) {
+            providerUpdateError = error instanceof Error ? error.message : String(error);
+            store.audit("fix.provider_update.failed", {
+                project_key: project.project_key,
+                issue_id: issue.id,
+                error: providerUpdateError,
+            });
+        }
+        issue.status = "local_draft_pr_created";
+        issue.fix = {
+            job_id: job.id,
+            draft_pr: draftPr,
+            provider_update: providerUpdate,
+            provider_update_error: providerUpdateError,
+            result: job.result,
+        };
+        store.save();
+        return { job, issue };
+    }
+    store.save();
+    return { job };
+}
+function validateRunnerResult(job, result) {
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+        throw new HttpError(400, "Runner result must be a JSON object");
+    }
+    if (job.type === "collect") {
+        if (result.mode !== "collect")
+            throw new HttpError(400, "Collect result must have mode=collect");
+        if (result.context != null && !isObject(result.context)) {
+            throw new HttpError(400, "Collect result context must be an object");
+        }
+        if (result.policy != null && !Array.isArray(result.policy)) {
+            throw new HttpError(400, "Collect result policy must be an array");
+        }
+    }
+    if (job.type === "fix") {
+        if (result.mode !== "fix")
+            throw new HttpError(400, "Fix result must have mode=fix");
+        if (result.changed_files != null && !isStringArray(result.changed_files)) {
+            throw new HttpError(400, "Fix result changed_files must be a string array");
+        }
+        if (result.tests != null && !isStringArray(result.tests)) {
+            throw new HttpError(400, "Fix result tests must be a string array");
+        }
+        if (result.transcript != null && typeof result.transcript !== "string") {
+            throw new HttpError(400, "Fix result transcript must be a string");
+        }
+    }
+    return result;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function auditCollectorPolicy(store, job) {
+    const policy = job.result?.policy;
+    if (!Array.isArray(policy))
+        return;
+    for (const decision of policy) {
+        if (!decision || typeof decision !== "object")
+            continue;
+        store.audit("runner.collector.policy", {
+            job_id: job.id,
+            project_key: job.project_key,
+            source: String(decision.source ?? ""),
+            decision: String(decision.decision ?? ""),
+            reason: String(decision.reason ?? ""),
+        });
+    }
+}
+function auditFixAgent(store, job) {
+    const agent = job.result?.agent;
+    if (!agent || typeof agent !== "object" || Array.isArray(agent))
+        return;
+    store.audit("runner.fix.agent", {
+        job_id: job.id,
+        project_key: job.project_key,
+        issue_id: job.issue_id ?? "",
+        command_ref: String(agent.command_ref ?? ""),
+        exit_code: String(agent.exit_code ?? ""),
+        decision: String(agent.decision ?? ""),
+    });
+}
+export function failJob(store, jobId, error) {
+    const job = requireJob(store, jobId);
+    job.status = "failed";
+    job.failed_at = new Date().toISOString();
+    job.error = redactValue(error, { mode: "strict" });
+    store.save();
+    store.audit("runner.job.failed", { job_id: job.id });
+    return job;
+}
+export function approveFix(store, issueId) {
+    const issue = store.state.issues[issueId];
+    if (!issue) {
+        throw new HttpError(404, `Unknown issue: ${issueId}`);
+    }
+    const project = store.state.projects[issue.project_key];
+    if (!project)
+        throw new HttpError(404, `Unknown project: ${issue.project_key}`);
+    if (!runnerFixEnabled(project)) {
+        throw new HttpError(409, "Fix capability is disabled for this project");
+    }
+    if (issue.status === "local_draft_pr_created") {
+        throw new HttpError(409, "Fix already produced a local draft PR");
+    }
+    const existingJob = Object.values(store.state.jobs).find((job) => {
+        return (job.type === "fix" &&
+            job.issue_id === issue.id &&
+            ["queued", "leased", "completed"].includes(job.status));
+    });
+    if (existingJob) {
+        store.audit("fix.approval_reused", { issue_id: issue.id, job_id: existingJob.id });
+        return existingJob;
+    }
+    const job = createJob(store, {
+        type: "fix",
+        project_key: issue.project_key,
+        issue_id: issue.id,
+        report_id: issue.report_id,
+        payload: {
+            issue,
+            context_markdown: issue.body,
+            policy: {
+                merge: false,
+                deploy: false,
+                production_writes: false,
+                push: false,
+            },
+        },
+    });
+    issue.status = "fix_queued";
+    issue.fix_job_id = job.id;
+    store.save();
+    store.audit("fix.approved", { issue_id: issue.id, job_id: job.id });
+    return job;
+}
+function runnerCollectEnabled(project) {
+    return project.runner?.enabled !== false && project.runner?.collect?.enabled === true;
+}
+function runnerFixEnabled(project) {
+    return project.runner?.enabled !== false && project.runner?.fix?.enabled === true;
+}
+async function createIssueFromReport(store, project, report, collectorResult = null) {
+    const fingerprint = [project.project_key, report.telemetry?.event_id ?? report.sentry?.event_id, report.route, report.message]
+        .filter(Boolean)
+        .join("|");
+    const duplicate = Object.values(store.state.issues).find((issue) => issue.project_key === project.project_key && issue.fingerprint === fingerprint);
+    if (duplicate) {
+        duplicate.duplicate_report_ids = [...new Set([...(duplicate.duplicate_report_ids ?? []), report.id])];
+        store.audit("issue.duplicate.linked", { issue_id: duplicate.id, report_id: report.id });
+        store.save();
+        return duplicate;
+    }
+    const compiled = compileIssue({ report, project, collectorResult });
+    const issue = {
+        id: store.id("iss"),
+        project_key: project.project_key,
+        report_id: report.id,
+        title: compiled.title,
+        body: compiled.body,
+        fingerprint,
+        status: "issue_created",
+        created_at: new Date().toISOString(),
+        integration: null,
+    };
+    issue.integration = await createProviderIssue({ store, project, issue });
+    store.state.issues[issue.id] = issue;
+    store.save();
+    return issue;
+}
+function createJob(store, input) {
+    const job = {
+        id: store.id("job"),
+        type: input.type,
+        project_key: input.project_key,
+        report_id: input.report_id,
+        issue_id: input.issue_id,
+        status: "queued",
+        payload: input.payload,
+        created_at: new Date().toISOString(),
+    };
+    store.state.jobs[job.id] = job;
+    store.save();
+    store.audit("runner.job.queued", { job_id: job.id, type: job.type });
+    return job;
+}
+function requireJob(store, jobId) {
+    const job = store.state.jobs[jobId];
+    if (!job) {
+        throw new HttpError(404, `Unknown job: ${jobId}`);
+    }
+    return job;
+}
+function enrichSentry(project, sentry = {}) {
+    return {
+        ...sentry,
+        event_url: sentry.event_url ??
+            (sentry.event_id && project.sentry?.org_slug && project.sentry?.project_slug
+                ? `https://sentry.io/organizations/${project.sentry.org_slug}/issues/?query=${sentry.event_id}`
+                : undefined),
+        replay_url: sentry.replay_url ??
+            (sentry.replay_id && project.sentry?.org_slug
+                ? `https://sentry.io/organizations/${project.sentry.org_slug}/replays/${sentry.replay_id}/`
+                : undefined),
+    };
+}
+function enrichTelemetry(project, telemetry = {}) {
+    const provider = telemetry.provider ?? project.telemetry?.provider ?? "sentry";
+    return {
+        ...telemetry,
+        provider,
+        event_url: telemetry.event_url ??
+            (provider === "sentry" && telemetry.event_id && project.telemetry?.org_slug && project.telemetry?.project_slug
+                ? `https://sentry.io/organizations/${project.telemetry.org_slug}/issues/?query=${telemetry.event_id}`
+                : undefined),
+        replay_url: telemetry.replay_url ??
+            (provider === "sentry" && telemetry.replay_id && project.telemetry?.org_slug
+                ? `https://sentry.io/organizations/${project.telemetry.org_slug}/replays/${telemetry.replay_id}/`
+                : undefined),
+    };
+}
+function legacySentryToTelemetry(sentry = {}) {
+    return {
+        provider: "sentry",
+        event_id: sentry.event_id,
+        replay_id: sentry.replay_id,
+        feedback_id: sentry.feedback_id,
+        event_url: sentry.event_url,
+        replay_url: sentry.replay_url,
+    };
+}
+function telemetryToSentry(project, telemetry = {}) {
+    if (telemetry.provider && telemetry.provider !== "sentry")
+        return {};
+    return enrichSentry(project, {
+        event_id: telemetry.event_id,
+        replay_id: telemetry.replay_id,
+        feedback_id: telemetry.feedback_id,
+        event_url: telemetry.event_url,
+        replay_url: telemetry.replay_url,
+    });
+}
+function inferReproSteps(envelope) {
+    return [
+        envelope.route ? `Open ${envelope.route}.` : "Open the affected page.",
+        "Follow the user action sequence captured by session replay or report metadata.",
+        "Observe the reported failure.",
+    ];
+}
+function buildCollectorPlan(project, report) {
+    return {
+        project_key: project.project_key,
+        repo_path: project.runner?.repo_path ?? null,
+        hints: report.hints ?? {},
+        sources: project.runner?.sources ?? [],
+    };
+}
+function mergeRunnerConfig(input) {
+    const defaults = {
+        enabled: true,
+        repo_path: "/workspace/agency-platform",
+        lease_timeout_seconds: 120,
+        collect: { enabled: true, auto: true },
+        fix: { enabled: true, auto: false, require_approval: true },
+        sources: defaultCollectorSources(),
+    };
+    if (!input)
+        return defaults;
+    return {
+        ...defaults,
+        ...input,
+        collect: { ...defaults.collect, ...input.collect },
+        fix: { ...defaults.fix, ...input.fix },
+        sources: input.sources ?? defaults.sources,
+    };
+}
+function defaultCollectorSources() {
+    return [
+        { name: "api_logs_by_request", type: "fixture_logs", when: { has: "request_id" }, max_entries: 100 },
+        { name: "trip_snapshot", type: "fixture_domain", when: { has: "trip_id" } },
+        { name: "workspace_manifest", type: "command_ref", command_ref: "workspace_manifest_v1" },
+    ];
+}
+function requeueStaleRunnerJobs(store, projectKey) {
+    const project = projectKey ? store.state.projects[projectKey] : undefined;
+    const timeoutSeconds = project?.runner?.lease_timeout_seconds ?? 120;
+    const now = Date.now();
+    let changed = false;
+    for (const job of Object.values(store.state.jobs)) {
+        if (job.project_key !== projectKey || job.status !== "leased")
+            continue;
+        const lastSeen = Date.parse(job.heartbeat_at ?? job.leased_at ?? job.created_at);
+        if (!Number.isFinite(lastSeen))
+            continue;
+        if (now - lastSeen < timeoutSeconds * 1000)
+            continue;
+        job.status = "queued";
+        job.runner_id = undefined;
+        job.leased_at = undefined;
+        job.heartbeat_at = undefined;
+        changed = true;
+        store.audit("runner.job.requeued_stale", {
+            job_id: job.id,
+            project_key: job.project_key,
+            timeout_seconds: timeoutSeconds,
+        });
+    }
+    if (changed)
+        store.save();
+}
+function objectAt(value, path) {
+    const found = valueAt(value, path);
+    if (!found || typeof found !== "object" || Array.isArray(found))
+        return undefined;
+    return found;
+}
+function stringAt(value, path) {
+    const found = valueAt(value, path);
+    return typeof found === "string" && found.length > 0 ? found : undefined;
+}
+function valueAt(value, path) {
+    return path.split(".").reduce((current, key) => {
+        if (!current || typeof current !== "object")
+            return undefined;
+        return current[key];
+    }, value);
+}
+function mergeObjects(left, right) {
+    const output = {};
+    if (left && typeof left === "object" && !Array.isArray(left)) {
+        Object.assign(output, left);
+    }
+    if (right && typeof right === "object" && !Array.isArray(right)) {
+        Object.assign(output, right);
+    }
+    return output;
+}

package/dist/src/redaction.d.ts

@@ -0,0 +1,6 @@
+type RedactOptions = {
+    mode?: "strict" | "none";
+};
+export declare function redactValue<T>(value: T, options?: RedactOptions): T;
+export declare function collectHints(input: unknown): Record<string, string>;
+export {};

package/dist/src/redaction.js

@@ -0,0 +1,53 @@
+const SENSITIVE_KEY_PATTERN = /(authorization|bearer|cookie|email|passport|password|phone|secret|ssn|token)/i;
+export function redactValue(value, options = {}) {
+    const mode = options.mode ?? "strict";
+    if (value == null)
+        return value;
+    if (typeof value === "string") {
+        let out = value;
+        out = out.replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[redacted:email]");
+        if (!containsUuidLike(out)) {
+            out = out.replace(/(?<![A-Za-z0-9/_-])\+?\d[\d\s().-]{7,}\d(?![A-Za-z0-9/_-])/g, "[redacted:phone]");
+        }
+        if (mode === "strict" && out.length > 300)
+            out = `${out.slice(0, 300)}...`;
+        return out;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redactValue(item, options));
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+            key,
+            SENSITIVE_KEY_PATTERN.test(key) ? "[redacted]" : redactValue(child, options),
+        ]));
+    }
+    return value;
+}
+function containsUuidLike(value) {
+    return /[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i.test(value);
+}
+export function collectHints(input) {
+    const hints = {};
+    const visit = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        for (const [key, child] of Object.entries(value)) {
+            if ([
+                "request_id",
+                "trace_id",
+                "tenant_id",
+                "user_id",
+                "trip_id",
+                "booking_id",
+                "proposal_id",
+            ].includes(key) &&
+                child != null) {
+                hints[key] = String(child);
+            }
+            if (typeof child === "object")
+                visit(child);
+        }
+    };
+    visit(input);
+    return hints;
+}

package/dist/src/runner.d.ts

@@ -0,0 +1,26 @@
+import type { Capabilities, JsonObject } from "./types.js";
+type RunnerConfig = {
+    server_url: string;
+    project_key: string;
+    runner_id?: string;
+    repo_path?: string;
+    artifact_dir?: string;
+    token_env?: string;
+    token?: string;
+    capabilities?: Capabilities;
+    agent?: {
+        fix?: {
+            command_ref?: string;
+            commands?: Record<string, {
+                bin: string;
+                args?: string[];
+                timeout_ms?: number;
+            }>;
+        };
+    };
+};
+type RunnerResult = {
+    idle: true;
+} | JsonObject;
+export declare function runOnce(config: RunnerConfig): Promise<RunnerResult>;
+export {};