@evident-ai/runner-cdk 0.1.1-dev.6ca48ee → 0.1.1-dev.7802262

package/README.md

@@ -151,6 +151,8 @@ new EvidentMicrovmConstruct(this, 'Runner', {
   baseImageArn,
   baseImageVersion,
   doorbellSecret,
+  runnerSecret,
+  runnerOpencodeConfigPath: 'opencode.runner.jsonc',
 });
 ```
 
@@ -158,6 +160,12 @@ Your repo does not have to be a pnpm workspace. If it commits a `pnpm-lock.yaml`
 pre-installs dependencies at build time (a faster first boot); if not, that step is skipped
 and the agent installs on first use.
 
+| MicroVM prop | Omitted behavior |
+| --- | --- |
+| `runnerSecret` | No GitHub or MCP credentials are exported at `/run`. |
+| `runnerOpencodeConfigPath` | OpenCode uses the baked project configuration. Relative paths resolve from the workspace; absolute paths resolve in the image. |
+| `gitUserName` / `gitUserEmail` | The hook uses the Evident bot defaults for git identity. |
+
 ## Status / limitations
 
 - **Published to npm** as `@evident-ai/runner-cdk` (MIT). Install the `@dev` tag —

package/dist/microvm/construct.d.ts

@@ -41,6 +41,20 @@ export interface EvidentMicrovmConstructProps {
      * in its own scope, and passes the result in either case.
      */
     readonly doorbellSecret: secretsmanager.ISecret;
+    /**
+     * Optional runner secret whose JSON values are exported by `/run`. Omitting it
+     * leaves GitHub and MCP credentials unavailable to a generic consumer.
+     */
+    readonly runnerSecret?: secretsmanager.ISecret;
+    /**
+     * Optional runner OpenCode overlay. Absolute paths are image paths; relative
+     * paths are resolved from the baked workspace by the `/run` hook.
+     */
+    readonly runnerOpencodeConfigPath?: string;
+    /** Optional git identity the `/run` hook configures for agent commits. */
+    readonly gitUserName?: string;
+    /** Optional git email the `/run` hook configures for agent commits. */
+    readonly gitUserEmail?: string;
     /**
      * TCP port the image's hook server listens on, baked into both the image
      * (`HOOKS_PORT` env var) and the `MicrovmImage`'s `hooks.port` — a mismatch

package/dist/microvm/construct.js

@@ -121,6 +121,12 @@ class EvidentMicrovmConstruct extends constructs_1.Construct {
             // already bakes in for its own runners (evident-scale-to-zero-construct.ts:191).
             // Safe to bake: identical for every VM from this image version.
             EVIDENT_SESSION_CLEANUP_MAX_AGE: '24h',
+            ...(props.runnerOpencodeConfigPath
+                ? { RUNNER_OPENCODE_CONFIG: props.runnerOpencodeConfigPath }
+                : {}),
+            ...(props.runnerSecret ? { RUNNER_SECRET_ARN: props.runnerSecret.secretArn } : {}),
+            ...(props.gitUserName ? { GIT_USER_NAME: props.gitUserName } : {}),
+            ...(props.gitUserEmail ? { GIT_USER_EMAIL: props.gitUserEmail } : {}),
         };
         // ...and the hooks configuration every shape's image is built with.
         const imageHooks = {
@@ -179,6 +185,8 @@ class EvidentMicrovmConstruct extends constructs_1.Construct {
         // customer account, and what Phase 4 (#263) has to tighten when this goes
         // multi-tenant.
         durableState.grantReadWrite(defaultImage.executionRole);
+        // The image receives only an ARN; `/run` reads the secret value at runtime.
+        props.runnerSecret?.grantRead(defaultImage.executionRole);
         // The shape catalogue the controller resolves a doorbell's `shape` field
         // against, and advertises over the describe channel (#723). One JSON
         // array, built with `Stack.toJsonString` — not `JSON.stringify` — because

package/dist/microvm-image-context/hooks/common.sh

@@ -211,13 +211,13 @@ load_state_config() {
 # `model-auth-ready` therefore stays a boot-time diagnostic: its only output is
 # a log line, since the runtime forwards no hook stderr to the doorbell caller.
 
-# How long restore_credentials' shared step budget is, covering all THREE of
-# its synchroniser calls (restore claude, restore opencode, model-auth-ready)
-# as one window rather than a timeout apiece — a fixed per-call cap at the same
+# How long restore_credentials' shared step budget is, covering the runner-secret
+# fetch plus its three synchroniser calls (restore claude, restore opencode,
+# model-auth-ready) as one window rather than a timeout apiece — a fixed per-call cap at the same
 # total would false-fire on the ordinary case of one slow call (a slow S3 GET),
 # which is precisely the boot this exists to keep healthy. From #930's 3-boot
-# sample: the step measured ~3-5s total (~1.2s per call, three node cold
-# starts of a 1.8 MB bundle) — a WEAK estimate this file's own
+# sample: the step measured ~3-5s total (~1.2s per synchroniser call, three
+# node cold starts of a 1.8 MB bundle) — a WEAK estimate this file's own
 # SYNCHRONISER-TIMING lines are what will sharpen for real. Too tight and a
 # routine slow call boots this VM with no model credentials until an operator
 # reconnects it; too loose and a hung call burns more of the hook's own
@@ -229,6 +229,7 @@ CREDENTIAL_RESTORE_DEADLINE_SECONDS="${EVIDENT_CREDENTIAL_RESTORE_DEADLINE_SECON
 # and a call that ignored it would be unbounded again). Hard ceiling on the
 # step: DEADLINE + this = 10s, once — not per call.
 CREDENTIAL_RESTORE_KILL_GRACE_SECONDS=2
+GITHUB_PROBE_DEADLINE_SECONDS="${EVIDENT_GITHUB_PROBE_DEADLINE_SECONDS:-10}"
 
 # What is left of the shared step budget, in whole seconds, `step_started_s`
 # seconds after it began. `SECONDS` (a bash builtin with no failure mode,
@@ -268,12 +269,66 @@ bounded_restore_call() {
   return 0
 }
 
+fetch_runner_secret() {
+  local step_started_s="$1" remaining rc=0 payload value stderr_file started_ms populated=0 missing=0
+  if [ -z "${RUNNER_SECRET_ARN:-}" ]; then
+    log "runner secret is not configured; continuing without GitHub and MCP credentials"
+    return 0
+  fi
+  remaining="$(remaining_credential_budget "${step_started_s}")"
+  if [ "${remaining}" -lt 1 ]; then
+    warn "CREDENTIAL-RESTORE-SKIPPED: runner-secret skipped; the ${CREDENTIAL_RESTORE_DEADLINE_SECONDS}s credential-restore budget is exhausted"
+    return 0
+  fi
+  if ! stderr_file="$(mktemp /dev/shm/runner-secret-stderr.XXXXXX)"; then
+    warn "RUNNER-SECRET-STDERR-UNAVAILABLE: could not allocate diagnostic storage; continuing without runner credentials"
+    return 0
+  fi
+  started_ms="$(now_ms)"
+  payload="$(timeout -k "${CREDENTIAL_RESTORE_KILL_GRACE_SECONDS}" "${remaining}" aws secretsmanager get-secret-value --secret-id "${RUNNER_SECRET_ARN}" --query SecretString --output text 2>"${stderr_file}")" || rc=$?
+  log_elapsed_since runner-secret-fetch "${started_ms}" "${rc}"
+  if [ "${rc}" -eq 124 ] || [ "${rc}" -eq 137 ]; then
+    warn "CREDENTIAL-RESTORE-TIMEOUT: runner-secret did not finish within its ${remaining}s share of the ${CREDENTIAL_RESTORE_DEADLINE_SECONDS}s credential-restore deadline; continuing without it"
+    rm -f "${stderr_file}"
+    return 0
+  fi
+  if [ "${rc}" -ne 0 ]; then
+    warn "RUNNER-SECRET-UNREADABLE: $(<"${stderr_file}")"
+    rm -f "${stderr_file}"
+    return 0
+  fi
+  rm -f "${stderr_file}"
+  if ! jq -e 'type == "object"' >/dev/null 2>&1 <<<"${payload}"; then
+    warn "RUNNER-SECRET-UNPARSEABLE: secret value is not a JSON object"
+    return 0
+  fi
+  local -a populated_keys=()
+  for key in GH_TOKEN BRAVE_API_KEY CLOUDFLARE_API_TOKEN NEON_API_KEY; do
+    value="$(jq -r --arg k "${key}" '.[$k] // empty' <<<"${payload}")"
+    if [ -n "${value}" ]; then
+      export "${key}=${value}"
+      populated=$((populated + 1))
+      populated_keys+=("${key}")
+    else
+      missing=$((missing + 1))
+    fi
+  done
+  if [ "${populated}" -eq 0 ]; then
+    warn "RUNNER-SECRET-UNPOPULATED: populate the runner secret as documented in infrastructure/evident-microvm/README.md"
+  else
+    log "RUNNER-SECRET-OK: populated ${populated_keys[*]}; ${missing} allow-listed keys empty or absent"
+  fi
+  return 0
+}
+
 restore_credentials() {
   local step_started_ms step_started_s
   step_started_ms="$(now_ms)"
   step_started_s="${SECONDS}"
 
   load_state_config || return 1
+  # This shares the existing bounded window so /run's worst-case duration does not grow.
+  fetch_runner_secret "${step_started_s}"
   bounded_restore_call restore-claude "${step_started_s}" restore claude || return 1
   bounded_restore_call restore-opencode "${step_started_s}" restore opencode || return 1
 
@@ -313,7 +368,7 @@ infrastructure/evident-microvm/README.md."
   fi
   # The step total, in the SAME greppable shape as the per-call lines above, so
   # one query answers both "what does credential restore cost?" and "which of
-  # its three calls cost it". Bounded now by CREDENTIAL_RESTORE_DEADLINE_SECONDS
+  # its four operations cost it". Bounded now by CREDENTIAL_RESTORE_DEADLINE_SECONDS
   # + CREDENTIAL_RESTORE_KILL_GRACE_SECONDS as one shared window (see the
   # comment above that constant) rather than per call. `rc=0` is deliberate
   # here, not an absence of failure modes: a timed-out call already warned by
@@ -323,6 +378,55 @@ infrastructure/evident-microvm/README.md."
   return 0
 }
 
+apply_runner_opencode_config() {
+  if [ -z "${RUNNER_OPENCODE_CONFIG:-}" ]; then
+    log "runner OpenCode config is not configured; using the baked project config"
+    return 0
+  fi
+  local source="${RUNNER_OPENCODE_CONFIG}" target="opencode.json"
+  [[ "${source}" = /* ]] || source="${WORKSPACE}/${source}"
+  [ -f "${WORKSPACE}/opencode.jsonc" ] && target="opencode.jsonc"
+  if [ ! -f "${source}" ]; then
+    error "RUNNER-OPENCODE-CONFIG-MISSING: ${source} is not a file; headless turns will wedge on the first external-directory permission prompt (#563)"
+    return 0
+  fi
+  cp "${source}" "${WORKSPACE}/${target}"
+  git -C "${WORKSPACE}" update-index --skip-worktree "${target}" 2>/dev/null \
+    || warn "could not mark ${target} skip-worktree; it may show as a local change"
+  log "Applied runner OpenCode config ${source} to ${WORKSPACE}/${target}"
+}
+
+configure_github_access() {
+  if [ -z "${GH_TOKEN:-}" ]; then
+    warn "GITHUB-CREDENTIALS-MISSING: GH_TOKEN is unavailable; see RUNNER-SECRET-* above"
+    return 0
+  fi
+  export GIT_CONFIG_GLOBAL=/tmp/gitconfig
+  if ! : >"${GIT_CONFIG_GLOBAL}" ||
+    ! git config --global user.name "${GIT_USER_NAME:-evident-bot}" ||
+    ! git config --global user.email "${GIT_USER_EMAIL:-evident-bot@users.noreply.github.com}" ||
+    ! git config --global init.defaultBranch main ||
+    ! printf '%s\n' '#!/usr/bin/env bash' '[ "$1" = get ] || exit 0' 'echo username=x-access-token' 'echo "password=${GH_TOKEN}"' >/tmp/git-credential-helper.sh ||
+    ! chmod 0700 /tmp/git-credential-helper.sh ||
+    ! git config --global credential."https://github.com".helper /tmp/git-credential-helper.sh; then
+    warn "GITHUB-SETUP-FAILED: could not configure local git credentials; continuing without GitHub access"
+    return 0
+  fi
+  (
+    local output rc=0 login repo_url repo
+    output="$(timeout -k 1 "${GITHUB_PROBE_DEADLINE_SECONDS}" gh api user --jq .login 2>&1)" || rc=$?
+    if [ "${rc}" -eq 124 ] || [ "${rc}" -eq 137 ]; then warn "GITHUB-PROBE-TIMEOUT: auth probe exceeded ${GITHUB_PROBE_DEADLINE_SECONDS}s"; return; fi
+    if [ "${rc}" -ne 0 ]; then warn "GITHUB-AUTH-REJECTED: ${output}"; return; fi
+    log "GITHUB-AUTH-OK: ${output}"
+    repo_url="$(git -C "${WORKSPACE}" remote get-url origin 2>/dev/null || true)"
+    repo="$(printf '%s' "${repo_url}" | sed -E 's#(https://github.com/|git@github.com:)##; s#\.git$##')"
+    [ -n "${repo}" ] || return
+    output="$(timeout -k 1 "${GITHUB_PROBE_DEADLINE_SECONDS}" gh api "repos/${repo}" --jq .full_name 2>&1)" || rc=$?
+    if [ "${rc}" -eq 124 ] || [ "${rc}" -eq 137 ]; then warn "GITHUB-PROBE-TIMEOUT: repository probe for ${repo} exceeded ${GITHUB_PROBE_DEADLINE_SECONDS}s"; return; fi
+    [ "${rc}" -eq 0 ] || warn "GITHUB-REPO-INACCESSIBLE: ${repo}: ${output}"
+  ) &
+}
+
 # Best-effort by design: /suspend must still drop the tunnel and /terminate must
 # still clean up, so a flush that cannot happen is loud but never fatal.
 sync_credentials() {
@@ -577,7 +681,7 @@ restore_session_db() {
   esac
 
   local classify_rc=0
-  run_synchroniser session-db-classify "${restore_rc}" 1 --on-unusable-replica=leave || classify_rc=$?
+  run_synchroniser session-db-classify "${restore_rc}" 1 --on-unusable-replica=leave --fresh-db-fallback || classify_rc=$?
   case "${classify_rc}" in
     0) ;; # restored, or no replica yet — the CLI already logged which
     31)

package/dist/microvm-image-context/hooks/run

@@ -79,7 +79,13 @@ check_runner_key "${runner_key}" "${api_url}" || exit 1
 restore_session_db
 log "session DB restore done ${SECONDS}s into the hook"
 
-# 7 — opencode. Started here, not at build time: a warm process in the shared
+# 7 — apply the overlay before OpenCode resolves its project configuration.
+apply_runner_opencode_config
+
+# 8 — configure git after credentials are restored and before agent shells start.
+configure_github_access
+
+# 9 — opencode. Started here, not at build time: a warm process in the shared
 # snapshot would carry its installation id and database into every VM. Not
 # waited on: a slow opencode boot is not a reason to fail /run (the tunnel CLI
 # auto-starts opencode when it finds none healthy,
@@ -87,14 +93,14 @@ log "session DB restore done ${SECONDS}s into the hook"
 # reclaims a runner that never comes online).
 start_opencode
 
-# 8 — begin replicating the session DB (#812 WI-3), now that opencode has
+# 10 — begin replicating the session DB (#812 WI-3), now that opencode has
 # opened it and before any work can arrive over the tunnel. Bare, like
 # restore_session_db above: start_litestream never returns non-zero (every
 # guard inside it is its own `return 0`), so there is nothing here for
 # `set -e` to abort on.
 start_litestream
 
-# 9 — the first per-VM identity on the wire. The subshell's umask makes the file
+# 11 — the first per-VM identity on the wire. The subshell's umask makes the file
 # unreadable to anyone else from the moment it exists, before the key is in it.
 (
   umask 077

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evident-ai/runner-cdk",
-  "version": "0.1.1-dev.6ca48ee",
+  "version": "0.1.1-dev.7802262",
   "description": "Reusable CDK constructs for an Evident agent runner: a single scale-to-zero Fargate runner (task + service + per-agent self-stop role + waker Lambda), or a per-session AWS Lambda MicroVM that boots on demand and suspends between messages. Instantiate once per agent from your own stack.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",