@kynver-app/runtime 0.1.157 → 0.1.168

package/dist/bounded-build/exec.d.ts

@@ -1,5 +1,6 @@
 import { type HeavyVerificationGateVerdict, type WorkerCommandGateOutcome } from "../heavy-verification/index.js";
 import { type BuildAdmissionVerdict } from "./admission.js";
+export declare function isSystemdScopeError(stderr: string): boolean;
 export interface BoundedBuildExecResult {
     ok: boolean;
     exitCode: number;
@@ -7,6 +8,8 @@ export interface BoundedBuildExecResult {
     stderr: string;
     admitted: boolean;
     wrappedWithSystemd: boolean;
+    /** True when systemd scope creation failed and the command was retried via plain shell. */
+    systemdScopeFallback?: boolean;
     nodeOptionsFlag: string;
     admission: BuildAdmissionVerdict;
     /** Cross-process heavy-verification lease (typecheck/build throttle). */

package/dist/bounded-build/index.d.ts

@@ -3,4 +3,4 @@ export { readMemAvailableBytes } from "./meminfo.js";
 export { formatNodeOptionsFlag, mergeNodeOptionsForBuildCheck, resolveNodeOldSpaceSizeMb, } from "./node-options.js";
 export { buildSystemdRunArgv, isSystemdRunAvailable, type SystemdWrapOptions, } from "./systemd-wrap.js";
 export { assessBuildAdmission, getActiveBuildCount, registerBuildEnd, registerBuildStart, resetActiveBuildCountForTests, resolveBuildAdmissionConfig, waitForBuildAdmission, type BuildAdmissionConfig, type BuildAdmissionVerdict, } from "./admission.js";
-export { runBoundedBuildCheck, type BoundedBuildExecResult, type RunBoundedBuildCheckInput } from "./exec.js";
+export { runBoundedBuildCheck, isSystemdScopeError, type BoundedBuildExecResult, type RunBoundedBuildCheckInput } from "./exec.js";

package/dist/byoc/context-hydration.d.ts

@@ -0,0 +1,54 @@
+/**
+ * BYOC M0.6 — context hydration.
+ *
+ * Takes a validated job envelope (jobId + agentOsId + taskId) and resolves
+ * the local config needed to run the job: repo path, worktree base, API URL.
+ *
+ * Pure: reads env/config but makes no network calls and writes nothing.
+ * Fail-closed: any missing required field returns a typed error code.
+ * No secrets in the returned object.
+ */
+import type { LocalCodexJobEnvelope } from "./job-envelope.js";
+export interface HydratedJobContext {
+    /** From the job envelope — unchanged. */
+    jobId: string;
+    agentOsId: string;
+    taskId: string;
+    /** Absolute path to the default repo on this host. null when not configured. */
+    repoPath: string | null;
+    /** Absolute path where worktrees for this job will be created. null = unresolved. */
+    worktreeBase: string | null;
+    /** Kynver API base URL (no trailing slash). */
+    apiBaseUrl: string;
+    /** ISO timestamp when hydration ran. */
+    hydratedAt: string;
+}
+export type ContextHydrationErrorCode = 
+/** No API base URL in env or config. */
+"missing_api_base_url"
+/** Workspace ID in envelope does not match locally configured agentOsId. */
+ | "workspace_mismatch";
+export type ContextHydrationResult = {
+    ok: true;
+    context: HydratedJobContext;
+} | {
+    ok: false;
+    code: ContextHydrationErrorCode;
+    detail: string;
+};
+export interface ContextHydrationOptions {
+    env?: NodeJS.ProcessEnv;
+    nowMs?: number;
+    /** Override config values for tests. */
+    config?: {
+        agentOsId?: string;
+        defaultRepo?: string;
+        harnessRoot?: string;
+        apiBaseUrl?: string;
+    };
+}
+/**
+ * Hydrate a validated job envelope with local runner config.
+ * Call after `validateJobEnvelope` and `verifyLocalCodexGoldenPath` pass.
+ */
+export declare function hydrateJobContext(envelope: LocalCodexJobEnvelope, options?: ContextHydrationOptions): ContextHydrationResult;

package/dist/byoc/execution-proof.d.ts

@@ -0,0 +1,46 @@
+/**
+ * BYOC M0.6 — execution readiness proof.
+ *
+ * Verifies that the local Codex execution plane and target repo are accessible
+ * enough to run a task. Does NOT spawn a Codex process — it probes fs
+ * accessibility and binary location only.
+ *
+ * Fail-closed on unexpected errors; returns a typed result, never throws.
+ * No secrets in the returned object.
+ */
+import type { HydratedJobContext } from "./context-hydration.js";
+import type { CodexOrchestrationPath } from "../orchestration-providers/codex-orchestration-adapter.js";
+import { resolveCodexOrchestrationAdapter } from "../orchestration-providers/codex-orchestration-adapter.js";
+export interface ExecutionProofResult {
+    /** Whether a Codex binary or Hermes OpenAI-Codex path was resolved on this host. */
+    codexReachable: boolean;
+    /** Which orchestration path was resolved (codex_cli | hermes_openai_codex | none). */
+    codexPath: CodexOrchestrationPath;
+    /** Absolute path to the codex binary, or null when using Hermes or unavailable. */
+    codexBinaryPath: string | null;
+    /** Whether the configured repo path exists on disk. */
+    repoAccessible: boolean;
+    /** Absolute repo path that was probed, or null when not configured. */
+    repoPath: string | null;
+    /** Whether a worktree base directory exists and is accessible. */
+    worktreeBaseAccessible: boolean;
+    /** Absolute worktree base path that was probed, or null when not configured. */
+    worktreeBase: string | null;
+    /** ISO timestamp when the proof ran. */
+    probedAt: string;
+    /** Wall-clock probe duration. */
+    durationMs: number;
+    /** First error encountered, or null on full pass. */
+    error: string | null;
+}
+export interface ExecutionProofOptions {
+    env?: NodeJS.ProcessEnv;
+    nowMs?: number;
+    /** Injectable codex adapter for tests. */
+    codexAdapter?: ReturnType<typeof resolveCodexOrchestrationAdapter>;
+}
+/**
+ * Probe execution readiness for the given hydrated job context.
+ * All checks are local — no network calls.
+ */
+export declare function probeExecutionReadiness(context: HydratedJobContext, options?: ExecutionProofOptions): ExecutionProofResult;

package/dist/byoc/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./job-envelope.js";
+export * from "./m6-golden-path.js";
+export * from "./context-hydration.js";
+export * from "./execution-proof.js";
+export * from "./mcp-tool-proof.js";

package/dist/byoc/job-envelope.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Local Codex job envelope — the typed payload Kynver cloud sends to the
+ * user's local runner for BYO-compute execution. Contains no secrets.
+ *
+ * The envelope is opaque to the cloud after dispatch; the local runner
+ * validates it against local state (workspace, runner identity, expiry,
+ * tool policy) before spawning a Codex worker.
+ */
+export interface LocalCodexJobToolPolicy {
+    /** Toolsets the local Codex agent may activate (e.g. ["hermes-cli"]). */
+    allowedToolsets: string[];
+    /** Whether privileged platform actions (DB writes, deploy, secrets) are permitted. */
+    allowPrivilegedPlatformActions: boolean;
+}
+/** Envelope from the Kynver control plane. Never contains secrets or tokens. */
+export interface LocalCodexJobEnvelope {
+    jobId: string;
+    agentOsId: string;
+    taskId: string;
+    issuedAt: string;
+    expiresAt: string;
+    toolPolicy: LocalCodexJobToolPolicy;
+    /** Optional runner identity hint — reject if present and mismatched. */
+    runnerIdHint?: string | null;
+}
+export type JobEnvelopeValidationError = "missing_job_id" | "missing_agent_os_id" | "missing_task_id" | "missing_issued_at" | "missing_expires_at" | "missing_tool_policy" | "malformed_dates" | "job_expired";
+export type JobEnvelopeValidationResult = {
+    ok: true;
+    envelope: LocalCodexJobEnvelope;
+} | {
+    ok: false;
+    code: JobEnvelopeValidationError;
+    detail: string;
+};
+/**
+ * Validate an envelope from the cloud. Fail closed on any structural or
+ * temporal problem — never return partially-valid state.
+ */
+export declare function validateJobEnvelope(input: unknown, nowMs?: number): JobEnvelopeValidationResult;

package/dist/byoc/m6-golden-path.d.ts

@@ -0,0 +1,86 @@
+/**
+ * M6 first-run local Codex golden path verifier.
+ *
+ * Validates a signed Kynver cloud job envelope against local runner state:
+ * workspace binding, runner presence, Codex/Hermes auth, BYO entitlement,
+ * and tool policy. Fails closed — any missing or mismatched prerequisite
+ * returns a typed failure code rather than proceeding to execution.
+ *
+ * Secrets and tokens are never returned. Session fingerprints are sha256
+ * prefixes of non-secret binding metadata (see oauth-binding-utils).
+ */
+import { resolveCodexOrchestrationAdapter, type CodexOrchestrationPath } from "../orchestration-providers/codex-orchestration-adapter.js";
+import type { LocalCodexJobEnvelope } from "./job-envelope.js";
+/**
+ * Failure codes for the M6 golden path. Each maps to an operator-visible
+ * remediation action — never expose secret material in messages.
+ */
+export type GoldenPathCheckCode = 
+/** Runner not configured or identity cannot be resolved. */
+"missing_runner"
+/** Codex CLI and Hermes openai-codex are both unavailable on this host. */
+ | "missing_codex_auth"
+/** Job's agentOsId does not match the runner's configured workspace. */
+ | "wrong_workspace"
+/**
+ * Job envelope is structurally invalid (missing/blank required field or
+ * malformed dates). Indicates a control-plane/serialization problem, not a
+ * runner-config problem — distinct from `wrong_workspace`.
+ */
+ | "malformed_envelope"
+/** Job envelope has expired (expiresAt in the past). */
+ | "job_expired"
+/**
+ * BYO compute entitlement is not active for this runner.
+ * Set KYNVER_BYOC_ENTITLED=1 or complete the workspace entitlement flow.
+ */
+ | "missing_entitlement"
+/**
+ * Job requests a tool or toolset not permitted on local BYO runners, or
+ * requests privileged platform actions (DB writes, deploy, secrets).
+ */
+ | "unauthorized_tool_policy";
+/** Non-secret audit evidence written back to the control plane. */
+export interface GoldenPathAuditEvidence {
+    jobId: string;
+    agentOsId: string;
+    taskId: string;
+    runnerId: string;
+    runnerIdHint: string | null;
+    codexPath: CodexOrchestrationPath;
+    codexReady: boolean;
+    sessionFingerprint: string | undefined;
+    toolsetsRequested: string[];
+    privilegedRequested: boolean;
+    checkedAt: string;
+}
+export type GoldenPathResult = {
+    passed: true;
+    envelope: LocalCodexJobEnvelope;
+    evidence: GoldenPathAuditEvidence;
+} | {
+    passed: false;
+    code: GoldenPathCheckCode;
+    detail: string;
+    evidence: GoldenPathAuditEvidence;
+};
+export interface GoldenPathOptions {
+    /** Override current time (ms) for testing. */
+    nowMs?: number;
+    /** Override process.env for testing. */
+    env?: NodeJS.ProcessEnv;
+    /** Injectable for tests — skips live Codex probe. */
+    codexAdapter?: ReturnType<typeof resolveCodexOrchestrationAdapter>;
+}
+/**
+ * Run the M6 golden path checks in order. The first failure short-circuits
+ * and returns the error code — callers must not proceed to execution.
+ */
+export declare function verifyLocalCodexGoldenPath(rawEnvelope: unknown, options?: GoldenPathOptions): GoldenPathResult;
+/**
+ * Format a human-readable remediation notice for a golden path failure.
+ * Safe to log — contains no secrets or tokens.
+ */
+export declare function formatGoldenPathFailureNotice(result: Extract<GoldenPathResult, {
+    passed: false;
+}>): string;

package/dist/byoc/mcp-tool-proof.d.ts

@@ -0,0 +1,42 @@
+/**
+ * BYOC M0.6 — MCP tool reachability proof.
+ *
+ * Proves the runner-credential auth pathway to the Kynver server works by making
+ * a lightweight HTTP probe (GET /api/agent-os/runner-token/verify) using the
+ * scoped runner token. Does not invoke any destructive MCP tools.
+ *
+ * Fail-closed on network errors — returns a typed result, never throws.
+ * No secrets in the returned object.
+ */
+import type { HydratedJobContext } from "./context-hydration.js";
+export type McpAuthSource = "runner_token" | "api_key" | "none";
+export interface McpToolProofResult {
+    /** Whether the MCP endpoint replied with a non-error HTTP status. */
+    reachable: boolean;
+    /** Which credential was used to probe. */
+    authSource: McpAuthSource;
+    /** The probe endpoint URL (no path secrets). */
+    endpoint: string | null;
+    /** HTTP status code returned, or null on network error. */
+    httpStatus: number | null;
+    /** Round-trip duration in ms, or null on failure. */
+    responseMs: number | null;
+    /** ISO timestamp when the probe ran. */
+    probedAt: string;
+    /** Error message if the probe failed, or null on success. */
+    error: string | null;
+}
+export interface McpToolProofOptions {
+    env?: NodeJS.ProcessEnv;
+    nowMs?: number;
+    /** Timeout for the HTTP probe. Default 8 000 ms. */
+    timeoutMs?: number;
+    /** Injectable fetch for tests — defaults to global fetch. */
+    fetcher?: typeof fetch;
+}
+/**
+ * Probe MCP/API reachability using the runner credential.
+ * Uses `GET /api/agent-os/runner-token/verify` — a read-only identity endpoint
+ * added in M0.4 that requires only the runner token and returns the workspace ID.
+ */
+export declare function probeMcpToolReachability(context: HydratedJobContext, options?: McpToolProofOptions): Promise<McpToolProofResult>;