agenthub-multiagent-mcp 1.51.0 → 1.53.0

package/dist/session-capture.sh

@@ -0,0 +1,410 @@
+#!/bin/bash
+# AgentHub Rich Session Capture Hook
+#
+# Captures full tool_input + tool_response from PostToolUse hook,
+# plus assistant/user messages from the transcript file.
+# Posts structured events to /api/sessions/{id}/events.
+#
+# Two callers, two ways of learning which session to record into:
+#
+#   1. Agent/daemon shifts (add-multiplayer-sessions §1.5). The daemon opens the
+#      session and stamps AGENTHUB_SESSION_ID into the child environment. This
+#      path is unchanged.
+#
+#   2. Human interactive sessions (§3.2). There is no daemon, so nothing stamps
+#      AGENTHUB_SESSION_ID — the hook has to obtain one itself. It does that by
+#      asking the server to resolve a session for Claude Code's own session id,
+#      and the server refuses unless the person has consented.
+#
+# The interactive path is off unless a consent grant file exists locally, which
+# the MCP writes only after the server confirms that *this user* consented. With
+# no grant file the hook makes no network call at all and exits — so a person
+# who has not consented pays nothing and is recorded nowhere.
+
+INPUT=$(cat)
+
+SESSION_ID="${AGENTHUB_SESSION_ID:-}"
+API_KEY="${AGENTHUB_API_KEY:-}"
+API_URL="${AGENTHUB_URL:-https://agenthub.contetial.com}"
+CONNECT_TOKEN=""
+
+# Resolve a python interpreter. Debian/Ubuntu (the employee-daemon hosts) ship
+# `python3` only — the unqualified `python` this used to call does not exist
+# there, and because the whole substitution is 2>/dev/null the hook produced
+# nothing, silently. `python` is tried first so Windows/Git-Bash checkouts keep
+# using the interpreter that is actually on PATH there.
+PY=$(command -v python || command -v python3)
+[ -z "$PY" ] && exit 0
+
+# --- Interactive (human) path: resolve a session id, consent permitting -------
+#
+# Emits four lines: session id, api url, connect token, and the notice JSON to
+# print (empty when it is not time to re-announce). Prints nothing at all when
+# capture is not authorized, which is the common case.
+if [ -z "$SESSION_ID" ]; then
+  BOOTSTRAP=$(echo "$INPUT" | "$PY" -c "
+import sys, json, os, time
+
+# The grant file is written by the AgentHub MCP *only* after the server confirms
+# this user's capture consent, and removed when consent is withdrawn. Its absence
+# is the fast, offline, fail-closed answer: no consent on record here, so do
+# nothing and talk to nobody.
+grant_path = os.environ.get('AGENTHUB_CAPTURE_GRANT') or os.path.join(
+    os.path.expanduser('~'), '.claude', 'agenthub-capture.json')
+try:
+    with open(grant_path, 'r') as f:
+        grant = json.load(f)
+except Exception:
+    sys.exit(0)
+
+api_url = (grant.get('api_url') or '').rstrip('/')
+token = grant.get('connect_token') or os.environ.get('AGENTHUB_CONNECT_TOKEN') or ''
+if not api_url or not token:
+    sys.exit(0)
+
+try:
+    data = json.load(sys.stdin)
+except Exception:
+    sys.exit(0)
+
+claude_sid = data.get('session_id') or ''
+if not claude_sid:
+    sys.exit(0)
+
+# Per-Claude-session cache, kept beside the grant rather than in /tmp so it
+# behaves the same on the Windows workstations this path exists to serve.
+state_dir = os.path.join(os.path.dirname(grant_path), 'agenthub-capture-state')
+state_file = os.path.join(state_dir, claude_sid.replace(os.sep, '_') + '.json')
+state = {}
+try:
+    with open(state_file, 'r') as f:
+        state = json.load(f)
+except Exception:
+    state = {}
+
+# A refusal is remembered for the rest of the session. Without this the hook
+# would re-ask the server on every single tool use of a session it has already
+# been told it may not record.
+if state.get('denied'):
+    sys.exit(0)
+
+notice_text = state.get('notice_text') or ''
+session_id = state.get('session_id') or ''
+created = False
+
+if not session_id:
+    import urllib.request, urllib.error
+    body = json.dumps({
+        'claude_session_id': claude_sid,
+        'title': (data.get('cwd') or '').replace('\\\\', '/').rstrip('/').split('/')[-1] or 'interactive session',
+        'working_directory': data.get('cwd') or '',
+    }).encode()
+    req = urllib.request.Request(
+        api_url + '/api/session-capture/sessions',
+        data=body,
+        headers={'Content-Type': 'application/json', 'X-Connect-Token': token},
+        method='POST')
+    try:
+        with urllib.request.urlopen(req, timeout=4) as resp:
+            payload = json.loads(resp.read().decode())
+        session_id = payload.get('session_id') or ''
+        notice_text = payload.get('capture_notice') or ''
+        created = True
+    except urllib.error.HTTPError:
+        # The server declined: consent absent or withdrawn, streaming off, or
+        # the credential does not identify a person. Remember it and stay quiet.
+        try:
+            os.makedirs(state_dir, exist_ok=True)
+            with open(state_file, 'w') as f:
+                json.dump({'denied': True}, f)
+        except Exception:
+            pass
+        sys.exit(0)
+    except Exception:
+        # Network trouble is transient — do not record a denial for it, and do
+        # not capture this tool call either.
+        sys.exit(0)
+
+if not session_id:
+    sys.exit(0)
+
+# --- Visible capture indicator (§3.3) ---------------------------------------
+# A person must never be recorded without an obvious signal that it is
+# happening. The notice is printed when capture starts and re-printed on an
+# interval, so it stays visible in a long session rather than scrolling away
+# once. The wording comes from the server so a client cannot soften or drop it.
+try:
+    interval = int(grant.get('notice_interval_sec') or 900)
+except Exception:
+    interval = 900
+# Clamped, not merely defaulted. The interval is read from a local file, and an
+# indicator that a local setting can push out to 'never' is not an indicator.
+# The floor keeps a long session from being all banner.
+interval = max(60, min(interval, 1800))
+now = int(time.time())
+last = int(state.get('last_notice') or 0)
+show = created or (now - last) >= interval
+
+state_out = {'session_id': session_id, 'notice_text': notice_text,
+             'last_notice': now if show else last}
+try:
+    os.makedirs(state_dir, exist_ok=True)
+    with open(state_file, 'w') as f:
+        json.dump(state_out, f)
+except Exception:
+    pass
+
+notice_json = ''
+if show:
+    msg = ('● RECORDING - AgentHub session capture is ON for this session (' + session_id + ') '
+           'and is sending it to ' + api_url + '. ' + notice_text +
+           ' Turn it off any time: set capture consent to off in AgentHub.')
+    notice_json = json.dumps({'systemMessage': msg})
+
+# Write through the binary buffer, not print(). On Windows, text-mode stdout
+# translates \n to \r\n, and the shell read strips only the \n — the \r would
+# survive into the URL and the session id, producing a request to a host that
+# does not exist. Nothing reports an error; capture just silently never posts.
+#
+# NOTE for anyone editing this file: this Python source is a bash double-quoted
+# string, so a backtick anywhere in it (even inside a comment) is a command
+# substitution that bash runs before Python ever sees the script. One in a
+# comment here consumed the hook's stdin and made capture silently do nothing.
+# Never use a backtick in these blocks; the same goes for a bare dollar sign.
+# sessionCaptureScript.test.ts enforces both.
+out = '\n'.join([session_id, api_url, token, notice_json]) + '\n'
+sys.stdout.buffer.write(out.encode('utf-8'))
+" 2>/dev/null)
+
+  { read -r BS_SESSION; read -r BS_URL; read -r BS_TOKEN; read -r BS_NOTICE; } <<EOF
+$BOOTSTRAP
+EOF
+
+  # Belt and braces against the \r above: a stray carriage return in the URL or
+  # the session id is invisible in logs and turns every subsequent POST into a
+  # request to a nonexistent host, so strip it here too rather than trusting the
+  # producer to have got its newlines right.
+  BS_SESSION="${BS_SESSION%$'\r'}"
+  BS_URL="${BS_URL%$'\r'}"
+  BS_TOKEN="${BS_TOKEN%$'\r'}"
+  BS_NOTICE="${BS_NOTICE%$'\r'}"
+
+  SESSION_ID="$BS_SESSION"
+  [ -n "$BS_URL" ] && API_URL="$BS_URL"
+  CONNECT_TOKEN="$BS_TOKEN"
+
+  # The indicator is the only thing this hook ever writes to stdout. Claude Code
+  # surfaces `systemMessage` to the person in the session.
+  [ -n "$BS_NOTICE" ] && echo "$BS_NOTICE"
+fi
+
+# No session to record into (unset on the daemon path, or consent absent on the
+# interactive one), or no credential — either way, capture nothing.
+[ -z "$SESSION_ID" ] && exit 0
+[ -z "$API_KEY" ] && [ -z "$CONNECT_TOKEN" ] && exit 0
+
+# Re-export so the event-building block below sees the resolved values on both
+# paths. On the daemon path these are already what they were.
+export AGENTHUB_SESSION_ID="$SESSION_ID"
+export AGENTHUB_URL="$API_URL"
+export AGENTHUB_CAPTURE_CONNECT_TOKEN="$CONNECT_TOKEN"
+
+# Use python to parse JSON and build rich event payload
+EVENTS_JSON=$(echo "$INPUT" | "$PY" -c "
+import sys, json, os, re
+
+TRUNC = 8000  # 8KB max per field (captures full assistant responses)
+TRUNC_SHORT = 1000
+
+# Secret patterns to redact
+SECRET_RE = re.compile(r'(api[_-]?key|token|password|secret|authorization|credential)[=:\s]*[^\s,}\"]{8,}', re.IGNORECASE)
+
+def redact(s):
+    if not s: return s
+    return SECRET_RE.sub(lambda m: m.group().split('=')[0] + '=[REDACTED]' if '=' in m.group() else m.group().split(':')[0] + ':[REDACTED]', str(s))
+
+def trunc(s, limit=TRUNC):
+    s = str(s) if s else ''
+    return s[:limit] + '...' if len(s) > limit else s
+
+try:
+    data = json.load(sys.stdin)
+except:
+    sys.exit(0)
+
+tool_name = data.get('tool_name', '')
+tool_input = data.get('tool_input', {})
+tool_response = data.get('tool_response', {})
+transcript_path = data.get('transcript_path', '')
+session_id = data.get('session_id', '')
+
+if not tool_name:
+    sys.exit(0)
+
+events = []
+
+# --- Report Claude's session_id to server (once per session) ---
+claude_id_file = '/tmp/agenthub-claude-sid-' + os.environ.get('AGENTHUB_SESSION_ID', 'none')
+if session_id and not os.path.exists(claude_id_file):
+    try:
+        import urllib.request
+        req = urllib.request.Request(
+            os.environ.get('AGENTHUB_URL', 'https://agenthub.contetial.com') + '/api/sessions/' + os.environ['AGENTHUB_SESSION_ID'] + '/claude-session-id',
+            data=json.dumps({'claude_session_id': session_id}).encode(),
+            headers={'Content-Type': 'application/json',
+                     'X-API-Key': os.environ.get('AGENTHUB_API_KEY', ''),
+                     'X-Connect-Token': os.environ.get('AGENTHUB_CAPTURE_CONNECT_TOKEN', '')},
+            method='PATCH'
+        )
+        urllib.request.urlopen(req, timeout=2)
+        with open(claude_id_file, 'w') as f:
+            f.write(session_id)
+    except:
+        pass
+
+# --- Read transcript for new assistant/user messages ---
+offset_file = '/tmp/agenthub-transcript-offset-' + os.environ.get('AGENTHUB_SESSION_ID', 'none')
+last_offset = 0
+try:
+    with open(offset_file, 'r') as f:
+        last_offset = int(f.read().strip())
+except:
+    pass
+
+if transcript_path and os.path.exists(transcript_path):
+    try:
+        with open(transcript_path, 'r') as f:
+            f.seek(last_offset)
+            new_lines = f.readlines()
+            new_offset = f.tell()
+
+        for line in new_lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+                entry_type = entry.get('type', '')
+
+                # Skip non-message entries (progress, queue-operation, etc.)
+                if entry_type not in ('user', 'assistant'):
+                    continue
+
+                # Content is nested: entry.message.role and entry.message.content
+                msg = entry.get('message', {})
+                role = msg.get('role', entry_type)
+                raw_content = msg.get('content', entry.get('content', ''))
+                content = ''
+
+                # Extract text content from various formats
+                if isinstance(raw_content, str):
+                    content = raw_content
+                elif isinstance(raw_content, list):
+                    parts = []
+                    for block in raw_content:
+                        if isinstance(block, dict) and block.get('type') == 'text':
+                            parts.append(block.get('text', ''))
+                    content = '\n'.join(parts)
+
+                if not content or len(content.strip()) < 2:
+                    continue
+
+                if role == 'assistant':
+                    events.append({
+                        'event_type': 'assistant_message',
+                        'payload': json.dumps({'content': redact(trunc(content))}),
+                        'token_count': 0
+                    })
+                elif role == 'user':
+                    events.append({
+                        'event_type': 'user_message',
+                        'payload': json.dumps({'content': redact(trunc(content)), 'source': 'prompt'}),
+                        'token_count': 0
+                    })
+            except:
+                continue
+
+        # Save offset
+        with open(offset_file, 'w') as f:
+            f.write(str(new_offset))
+    except:
+        pass
+
+# --- Build tool-specific event ---
+tn = tool_name.lower()
+ti = tool_input if isinstance(tool_input, dict) else {}
+tr = tool_response if isinstance(tool_response, dict) else {}
+
+if tn == 'bash':
+    payload = {
+        'tool_name': 'Bash',
+        'command': redact(trunc(ti.get('command', ''), TRUNC_SHORT)),
+        'exit_code': tr.get('exit_code', tr.get('exitCode')),
+        'stdout': redact(trunc(tr.get('stdout', tr.get('output', str(tr)[:TRUNC])))),
+    }
+    events.append({'event_type': 'command_exec', 'payload': json.dumps(payload), 'token_count': 0})
+
+elif tn == 'read':
+    payload = {
+        'tool_name': 'Read',
+        'file_path': ti.get('file_path', ''),
+        'lines_read': ti.get('limit', 0),
+        'content_preview': redact(trunc(str(tr)[:TRUNC_SHORT], TRUNC_SHORT)),
+    }
+    events.append({'event_type': 'file_read', 'payload': json.dumps(payload), 'token_count': 0})
+
+elif tn == 'edit':
+    payload = {
+        'tool_name': 'Edit',
+        'file_path': ti.get('file_path', ''),
+        'old_string': redact(trunc(ti.get('old_string', ''), TRUNC_SHORT)),
+        'new_string': redact(trunc(ti.get('new_string', ''), TRUNC_SHORT)),
+    }
+    events.append({'event_type': 'file_edit', 'payload': json.dumps(payload), 'token_count': 0})
+
+elif tn == 'write':
+    content = ti.get('content', '')
+    payload = {
+        'tool_name': 'Write',
+        'file_path': ti.get('file_path', ''),
+        'content_preview': redact(trunc(content, TRUNC_SHORT)),
+    }
+    events.append({'event_type': 'file_write', 'payload': json.dumps(payload), 'token_count': 0})
+
+elif tn in ('glob', 'grep'):
+    payload = {
+        'tool_name': tool_name,
+        'pattern': ti.get('pattern', ''),
+        'path': ti.get('path', ''),
+        'result_summary': redact(trunc(str(tr), TRUNC_SHORT)),
+    }
+    events.append({'event_type': 'tool_call', 'payload': json.dumps(payload), 'token_count': 0})
+
+else:
+    # Generic tool call
+    payload = {
+        'tool_name': tool_name,
+        'input_summary': redact(trunc(json.dumps(ti), TRUNC_SHORT)),
+        'result_summary': redact(trunc(str(tr), TRUNC_SHORT)),
+    }
+    events.append({'event_type': 'tool_call', 'payload': json.dumps(payload), 'token_count': 0})
+
+# Output JSON for curl
+if events:
+    print(json.dumps({'events': events}))
+" 2>/dev/null)
+
+# POST events if any. Both credential headers are sent; the empty one reads as
+# absent server-side, so one curl serves the daemon path (API key) and the
+# interactive path (connect token) without branching.
+if [ -n "$EVENTS_JSON" ] && [ "$EVENTS_JSON" != "null" ]; then
+  curl -s --max-time 3 \
+    -X POST \
+    -H "Content-Type: application/json" \
+    -H "X-API-Key: $API_KEY" \
+    -H "X-Connect-Token: $CONNECT_TOKEN" \
+    -d "$EVENTS_JSON" \
+    "${API_URL}/api/sessions/${SESSION_ID}/events" > /dev/null 2>&1 &
+fi
+
+exit 0

package/dist/sessionCapture.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Session-capture wiring for daemon shifts (add-multiplayer-sessions §1.5).
+ *
+ * The capture hook (`session-capture.sh`) has always existed but has never
+ * produced anything for the live fleet, because two halves were missing:
+ *
+ *  1. Nothing created a coding session, so `AGENTHUB_SESSION_ID` was never set
+ *     and the hook exited at its first guard (`session-capture.sh:14`).
+ *  2. Nothing registered the hook for the spawned Claude process — the MCP
+ *     installers cover only the inbox and activity hooks.
+ *
+ * This module supplies both, and is the single place the daemon touches for
+ * capture concerns. Everything here is **fail-soft**: a capture failure logs and
+ * returns a null/empty result so the shift still runs. A shift must never die
+ * for an observability reason.
+ *
+ * Gated on `AGENTHUB_SESSION_STREAMING_ENABLED` (default off, matching the
+ * server-side flag added in §1.2). With the flag off, `beginShiftCapture`
+ * performs no network call, no filesystem access, and returns `null`, and
+ * `applyCaptureEnv` leaves the child env untouched — the shift is byte-for-byte
+ * what it is today.
+ */
+/** Minimal structural view of the parts of `fetch` this module uses. */
+export interface CaptureResponse {
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}
+export type FetchLike = (url: string, init: RequestInit) => Promise<CaptureResponse>;
+/** Default bound on every capture HTTP call. Shift startup must not block on it. */
+export declare const CAPTURE_TIMEOUT_MS = 5000;
+/**
+ * Identifies our PostToolUse entry inside a settings object so repeated merges
+ * never duplicate it (same marker discipline as activityHookInstall.ts /
+ * inboxHookInstall.ts, which key off the CLI filename in the command string).
+ */
+export declare const CAPTURE_HOOK_MARKER = "session-capture.sh";
+/** Reason recorded on the session when a shift ends. */
+export type ShiftOutcome = "completed" | "failed" | "spawn_error" | "daemon_shutdown";
+/**
+ * Live session streaming kill switch. Default **off** — an unset, empty, or
+ * unrecognised value means disabled, so the producer stays silent unless an
+ * operator deliberately turns it on.
+ */
+export declare function sessionStreamingEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Merge the capture PostToolUse hook into a settings object **without**
+ * discarding anything already there: other hook events, other PostToolUse
+ * entries, and every non-`hooks` key are preserved. Idempotent — a settings
+ * object that already carries the capture hook is returned unchanged.
+ *
+ * Returns a new object; the input is never mutated.
+ */
+export declare function mergeCaptureHook(base: Record<string, unknown>, command: string, timeoutSeconds?: number): Record<string, unknown>;
+/**
+ * Locate `session-capture.sh` relative to the compiled module directory.
+ * Ordered most-specific first:
+ *   1. `dist/session-capture.sh`      — the published npm package (build copies it)
+ *   2. `mcp-server/session-capture.sh` — running from a source checkout's dist/
+ *   3. `<repo>/.claude/hooks/session-capture.sh` — repo checkout fallback
+ * Returns `null` when the script cannot be found; the caller then runs the shift
+ * without capture rather than inventing a degraded inline copy.
+ */
+export declare function resolveCaptureHookScript(moduleDir: string, exists?: (p: string) => boolean): string | null;
+/** Shell command Claude Code runs for the PostToolUse capture hook. */
+export declare function captureHookCommand(scriptPath: string): string;
+export interface CaptureSettingsDeps {
+    exists?: (p: string) => boolean;
+    writeFile?: (p: string, data: string) => void;
+    log?: (msg: string) => void;
+}
+/**
+ * Build a memoised factory that materialises the per-daemon-process settings
+ * file registering the capture hook, and returns its path ("" when the hook
+ * script is unavailable or the write fails).
+ *
+ * **Why a dedicated file rather than editing `~/.claude/settings.json`:** the
+ * daemon already passes a settings file to `run-claude.sh` (arg 4 → `claude
+ * --settings`). Writing a fresh file scoped to the spawned process means no
+ * user-owned or workspace-owned settings file is ever rewritten, so there is
+ * nothing to clobber — a strictly stronger guarantee than merging in place. The
+ * file contains only our hook, so hook entries from the user's own settings
+ * sources are neither dropped nor double-registered. `mergeCaptureHook` is used
+ * (rather than a literal) so the same non-destructive merge is exercised here
+ * and reusable by the in-place installer Phase 3 will need for human sessions.
+ */
+export declare function createCaptureSettingsFactory(moduleDir: string, settingsPath: string, deps?: CaptureSettingsDeps): () => string;
+export interface SessionApiOptions {
+    apiUrl: string;
+    apiKey: string;
+    timeoutMs?: number;
+    fetchImpl?: FetchLike;
+    log?: (msg: string) => void;
+}
+export interface OpenSessionOptions extends SessionApiOptions {
+    agentId: string;
+    title?: string;
+    workingDirectory?: string;
+    projectId?: string;
+}
+/**
+ * Create the coding session that a shift will be captured under.
+ *
+ * Uses `POST /api/sessions` (`handleCreateSession`) — the plain record-creating
+ * endpoint. Deliberately **not** `POST /api/sessions/start`: that one also calls
+ * `Orchestrator().DispatchSession`, i.e. it asks a daemon to start a shift. The
+ * daemon calling it would dispatch a second shift for work it is already doing.
+ *
+ * Never throws and never blocks beyond `timeoutMs`. Returns the session id, or
+ * `null` when the session could not be created — the caller then runs the shift
+ * uncaptured.
+ */
+export declare function openCaptureSession(opts: OpenSessionOptions): Promise<string | null>;
+/**
+ * Close a captured session. Uses `POST /api/sessions/{id}/terminate`, the only
+ * endpoint that moves a session to a terminal state and stamps a reason.
+ * Never throws — a shift that already finished must not fail on cleanup.
+ */
+export declare function closeCaptureSession(sessionId: string, reason: ShiftOutcome, opts: SessionApiOptions): Promise<boolean>;
+/**
+ * Remove the hook's per-session scratch markers.
+ *
+ * `session-capture.sh` keys both of its markers by `AGENTHUB_SESSION_ID`
+ * (`/tmp/agenthub-transcript-offset-<id>`, `/tmp/agenthub-claude-sid-<id>`), so
+ * concurrent shifts on one host never collide — each shift gets its own session
+ * id. They are, however, never cleaned up by the script itself, so the daemon
+ * removes them when the session closes. Best-effort: absent files are fine.
+ */
+export declare function cleanupCaptureMarkers(sessionId: string, tmpDir?: string, removeFile?: (p: string) => void): void;
+/** A shift's live capture wiring. `settingsFile` is "" when no hook was registered. */
+export interface ShiftCapture {
+    sessionId: string;
+    settingsFile: string;
+}
+export interface BeginShiftCaptureOptions extends OpenSessionOptions {
+    env?: NodeJS.ProcessEnv;
+    /** Memoised factory from `createCaptureSettingsFactory`. */
+    ensureSettingsFile: () => string;
+}
+/**
+ * Open a session and register the capture hook for one shift.
+ *
+ * Returns `null` — meaning "run the shift uncaptured" — when streaming is
+ * disabled or the session could not be created. With streaming disabled this
+ * returns before any I/O of any kind.
+ */
+export declare function beginShiftCapture(opts: BeginShiftCaptureOptions): Promise<ShiftCapture | null>;
+/** Close a shift's session and clean up its hook markers. Never throws. */
+export declare function endShiftCapture(capture: ShiftCapture | null, outcome: ShiftOutcome, opts: SessionApiOptions & {
+    tmpDir?: string;
+}): Promise<void>;
+/**
+ * Stamp the capture variables onto a shift's child environment.
+ *
+ * `AGENTHUB_SESSION_ID` is what un-gates `session-capture.sh`; the URL and key
+ * are re-asserted because the hook reads them from its own environment and
+ * would otherwise silently fall back to the compiled-in default host.
+ *
+ * With `capture === null` the env object is returned untouched — this is the
+ * off-path guarantee, expressed as a single early return.
+ */
+export declare function applyCaptureEnv(env: Record<string, string>, capture: ShiftCapture | null, apiUrl: string, apiKey: string): Record<string, string>;
+//# sourceMappingURL=sessionCapture.d.ts.map

package/dist/sessionCapture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionCapture.d.ts","sourceRoot":"","sources":["../src/sessionCapture.ts"],"names":[],"mappings":"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"}