promptlayer 1.2.0 → 1.2.2

package/vendor/claude-agents/trace/hooks/lib.sh

@@ -47,531 +47,13 @@ tracing_enabled() {
 }
 
 check_requirements() {
-	local cmd
-	for cmd in jq curl uuidgen python3; do
-		if ! command -v "$cmd" >/dev/null 2>&1; then
-			log "ERROR" "Missing required command: $cmd"
-			return 1
-		fi
-	done
-	if [[ -z "$PL_API_KEY" ]]; then
-		log "ERROR" "PROMPTLAYER_API_KEY is not set"
-		return 1
-	fi
-	return 0
-}
-
-generate_trace_id() {
-	uuidgen | tr -d '-' | tr '[:upper:]' '[:lower:]'
-}
-
-generate_span_id() {
-	uuidgen | tr -d '-' | tr '[:upper:]' '[:lower:]' | cut -c1-16
-}
-
-parse_traceparent() {
-	local raw="${1:-}"
-	[[ -z "$raw" ]] && return 1
-
-	raw="$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]')"
-
-	if [[ ! "$raw" =~ ^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(-.+)?$ ]]; then
-		return 1
-	fi
-
-	local version="${BASH_REMATCH[1]}"
-	local trace_id="${BASH_REMATCH[2]}"
-	local parent_span_id="${BASH_REMATCH[3]}"
-	local trace_flags="${BASH_REMATCH[4]}"
-	local suffix="${BASH_REMATCH[5]:-}"
-
-	if [[ "$version" == "ff" ]]; then
-		return 1
-	fi
-	if [[ "$version" == "00" && -n "$suffix" ]]; then
-		return 1
-	fi
-	if [[ "$trace_id" == "00000000000000000000000000000000" ]]; then
-		return 1
-	fi
-	if [[ "$parent_span_id" == "0000000000000000" ]]; then
-		return 1
-	fi
-
-	printf '%s %s %s %s\n' "$version" "$trace_id" "$parent_span_id" "$trace_flags"
-}
-
-load_initial_trace_context() {
-	PL_INITIAL_TRACEPARENT_VERSION=""
-	PL_INITIAL_TRACE_ID=""
-	PL_INITIAL_PARENT_SPAN_ID=""
-	PL_INITIAL_TRACE_FLAGS=""
-	PL_INITIAL_TRACE_CONTEXT_SOURCE="generated"
-
-	local raw="${PROMPTLAYER_TRACEPARENT:-}"
-	if [[ -z "$raw" ]]; then
-		return 0
-	fi
-
-	local parsed
-	if ! parsed="$(parse_traceparent "$raw")"; then
-		log "WARN" "Ignoring invalid PROMPTLAYER_TRACEPARENT"
+	if ! command -v python3 >/dev/null 2>&1; then
+		log "ERROR" "Missing required command: python3"
 		return 1
 	fi
-
-	read -r PL_INITIAL_TRACEPARENT_VERSION PL_INITIAL_TRACE_ID PL_INITIAL_PARENT_SPAN_ID PL_INITIAL_TRACE_FLAGS <<<"$parsed"
-	PL_INITIAL_TRACE_CONTEXT_SOURCE="external_traceparent"
-	return 0
-}
-
-normalize_hex_id() {
-	local raw="$1"
-	local expected_len="$2"
-	local fallback="$3"
-	local label="$4"
-
-	local clean
-	clean="$(echo "$raw" | tr -cd '[:xdigit:]' | tr '[:upper:]' '[:lower:]')"
-	if [[ -z "$clean" ]]; then
-		clean="$fallback"
-	fi
-
-	if ((${#clean} > expected_len)); then
-		clean="${clean:0:expected_len}"
-	elif ((${#clean} < expected_len)); then
-		clean="$(printf "%-${expected_len}s" "$clean" | tr ' ' '0')"
-	fi
-
-	if [[ "$clean" != "$raw" ]]; then
-		log "WARN" "Normalized $label from '$raw' to '$clean'"
-	fi
-
-	echo "$clean"
-}
-
-hex_to_base64() {
-	local hex="$1"
-	python3 "$PL_HOOKS_DIR/hook_utils.py" hex_to_base64 "$hex"
-}
-
-now_ns() {
-	python3 "$PL_HOOKS_DIR/hook_utils.py" now_ns
-}
-
-session_state_file() {
-	echo "$PL_SESSION_STATE_DIR/$1.json"
-}
-
-acquire_session_lock() {
-	local sid="$1"
-	[[ -z "$sid" ]] && return 1
-
-	local lock_dir="$PL_LOCK_DIR/$sid.lock"
-	local attempts=0
-	while ! mkdir "$lock_dir" 2>/dev/null; do
-		attempts=$((attempts + 1))
-		if ((attempts >= 250)); then
-			log "ERROR" "Timed out waiting for session lock session_id=$sid"
-			return 1
-		fi
-		sleep 0.02
-	done
-
-	export PL_HELD_SESSION_LOCK="$lock_dir"
-	return 0
-}
-
-release_session_lock() {
-	local lock_dir="${PL_HELD_SESSION_LOCK:-}"
-	if [[ -n "$lock_dir" ]]; then
-		rmdir "$lock_dir" 2>/dev/null || rm -rf "$lock_dir"
-		unset PL_HELD_SESSION_LOCK
-	fi
-	return 0
-}
-
-acquire_queue_lock() {
-	local lock_dir="$PL_LOCK_DIR/queue.lock"
-	local attempts=0
-	while ! mkdir "$lock_dir" 2>/dev/null; do
-		attempts=$((attempts + 1))
-		if ((attempts >= 250)); then
-			log "ERROR" "Timed out waiting for queue lock"
-			return 1
-		fi
-		sleep 0.02
-	done
-
-	export PL_HELD_QUEUE_LOCK="$lock_dir"
-	return 0
-}
-
-release_queue_lock() {
-	local lock_dir="${PL_HELD_QUEUE_LOCK:-}"
-	if [[ -n "$lock_dir" ]]; then
-		rmdir "$lock_dir" 2>/dev/null || rm -rf "$lock_dir"
-		unset PL_HELD_QUEUE_LOCK
-	fi
-	return 0
-}
-
-get_session_state() {
-	local sid="$1"
-	local key="$2"
-	local f
-	f="$(session_state_file "$sid")"
-	if [[ -f "$f" ]]; then
-		jq -r ".${key} // empty" "$f" 2>/dev/null || true
-	fi
-}
-
-set_session_state() {
-	local sid="$1"
-	local key="$2"
-	local val="$3"
-	local f
-	f="$(session_state_file "$sid")"
-	local current
-	current='{}'
-	if [[ -f "$f" ]]; then
-		current="$(cat "$f")"
-	fi
-	echo "$current" | jq --arg k "$key" --arg v "$val" '.[$k] = $v' >"$f"
-}
-
-ensure_session_initialized() {
-	local sid="$1"
-	local requested_start_ns="${2:-}"
-	[[ -z "$sid" ]] && return 1
-
-	local trace_id session_span_id session_parent_span_id session_start_ns init_source pending_tool_calls
-	trace_id="$(get_session_state "$sid" trace_id)"
-	session_span_id="$(get_session_state "$sid" session_span_id)"
-	session_parent_span_id="$(get_session_state "$sid" session_parent_span_id)"
-	session_start_ns="$(get_session_state "$sid" session_start_ns)"
-	init_source="$(get_session_state "$sid" session_init_source)"
-	pending_tool_calls="$(get_session_state "$sid" pending_tool_calls)"
-
-	# Normal path: SessionStart already created state.
-	if [[ -n "$trace_id" && -n "$session_span_id" ]]; then
-		if [[ -z "$session_start_ns" ]]; then
-			[[ -z "$requested_start_ns" ]] && requested_start_ns="$(now_ns)"
-			set_session_state "$sid" session_start_ns "$requested_start_ns"
-		fi
-		if [[ -z "$init_source" ]]; then
-			set_session_state "$sid" session_init_source "unknown"
-		fi
-		if [[ -z "$pending_tool_calls" ]]; then
-			set_session_state "$sid" pending_tool_calls "[]"
-		fi
-		if [[ -z "$session_parent_span_id" ]]; then
-			set_session_state "$sid" session_parent_span_id ""
-		fi
-		if [[ -z "$(get_session_state "$sid" session_traceparent_version)" ]]; then
-			set_session_state "$sid" session_traceparent_version ""
-		fi
-		if [[ -z "$(get_session_state "$sid" session_trace_flags)" ]]; then
-			set_session_state "$sid" session_trace_flags ""
-		fi
-		if [[ -z "$(get_session_state "$sid" trace_context_source)" ]]; then
-			set_session_state "$sid" trace_context_source "generated"
-		fi
-		return 0
-	fi
-
-	# Fallback path for SDK environments that do not surface SessionStart.
-	[[ -z "$requested_start_ns" ]] && requested_start_ns="$(now_ns)"
-	load_initial_trace_context || true
-	[[ -z "$trace_id" ]] && trace_id="${PL_INITIAL_TRACE_ID:-}"
-	[[ -z "$trace_id" ]] && trace_id="$(generate_trace_id)"
-	[[ -z "$session_span_id" ]] && session_span_id="$(generate_span_id)"
-
-	set_session_state "$sid" trace_id "$trace_id"
-	set_session_state "$sid" session_span_id "$session_span_id"
-	set_session_state "$sid" session_parent_span_id "${PL_INITIAL_PARENT_SPAN_ID:-}"
-	set_session_state "$sid" session_start_ns "$requested_start_ns"
-	set_session_state "$sid" current_turn_start_ns ""
-	set_session_state "$sid" pending_tool_calls "[]"
-	set_session_state "$sid" session_init_source "lazy_init"
-	set_session_state "$sid" session_traceparent_version "${PL_INITIAL_TRACEPARENT_VERSION:-}"
-	set_session_state "$sid" session_trace_flags "${PL_INITIAL_TRACE_FLAGS:-}"
-	set_session_state "$sid" trace_context_source "${PL_INITIAL_TRACE_CONTEXT_SOURCE:-generated}"
-
-	log "INFO" "Session initialized lazily session_id=$sid trace_id=$trace_id"
-}
-
-post_otlp_payload_file() {
-	local payload_file="$1"
-	local status response_file
-	response_file="$(mktemp "${TMPDIR:-/tmp}/pl-otlp-response.XXXXXX")"
-	status="$(curl -sS -o "$response_file" -w "%{http_code}" -X POST \
-		-H "Content-Type: application/json" \
-		-H "X-Api-Key: $PL_API_KEY" \
-		-H "User-Agent: $PL_USER_AGENT" \
-		--connect-timeout "$PL_OTLP_CONNECT_TIMEOUT" \
-		--max-time "$PL_OTLP_MAX_TIME" \
-		"$PL_OTLP_ENDPOINT" \
-		-d @"$payload_file" || true)"
-
-	if [[ "$status" != "200" ]]; then
-		log "ERROR" "Failed OTLP export status=$status"
-		rm -f "$response_file"
+	if [[ -z "$PL_API_KEY" ]]; then
+		log "ERROR" "PROMPTLAYER_API_KEY is not set"
 		return 1
 	fi
-
-	# OTLP JSON can return 200 with partialSuccess and rejected spans.
-	# Treat this as non-retryable (same payload is likely to be rejected again).
-	if command -v jq >/dev/null 2>&1; then
-		local rejected
-		rejected="$(jq -r '.partialSuccess.rejectedSpans // 0' "$response_file" 2>/dev/null || echo 0)"
-		if [[ "$rejected" != "0" ]]; then
-			local message
-			message="$(jq -r '.partialSuccess.errorMessage // "Unknown rejection"' "$response_file" 2>/dev/null || true)"
-			log "ERROR" "OTLP partial success: rejected_spans=$rejected message=$message"
-			rm -f "$response_file"
-			return 2
-		fi
-	fi
-
-	rm -f "$response_file"
-	return 0
-}
-
-append_to_otlp_queue_file() {
-	local payload_file="$1"
-	acquire_queue_lock || return 1
-	# Compact to single line to preserve ndjson format
-	jq -c '.' "$payload_file" >>"$PL_QUEUE_FILE"
-	chmod 600 "$PL_QUEUE_FILE" 2>/dev/null || true
-	release_queue_lock
 	return 0
 }
-
-drain_otlp_queue() {
-	if [[ ! -s "$PL_QUEUE_FILE" ]]; then
-		return 0
-	fi
-
-	local drain_limit="$PL_QUEUE_DRAIN_LIMIT"
-	if [[ ! "$drain_limit" =~ ^[0-9]+$ ]]; then
-		drain_limit=10
-	fi
-	if ((drain_limit <= 0)); then
-		return 0
-	fi
-
-	acquire_queue_lock || return 0
-
-	local -a queue_payloads
-	mapfile -t queue_payloads <"$PL_QUEUE_FILE" || true
-
-	local total max_attempts i rc replayed dropped retryable_fail fail_index
-	total="${#queue_payloads[@]}"
-	if ((total == 0)); then
-		release_queue_lock
-		return 0
-	fi
-
-	max_attempts=$((total < drain_limit ? total : drain_limit))
-	replayed=0
-	dropped=0
-	retryable_fail=0
-	fail_index=-1
-
-	local queued_tmp
-	queued_tmp="$(mktemp "${TMPDIR:-/tmp}/pl-otlp-queued.XXXXXX")"
-
-	for ((i = 0; i < max_attempts; i++)); do
-		if [[ -z "${queue_payloads[$i]}" ]]; then
-			continue
-		fi
-
-		printf '%s' "${queue_payloads[$i]}" >"$queued_tmp"
-
-		if post_otlp_payload_file "$queued_tmp"; then
-			replayed=$((replayed + 1))
-			continue
-		else
-			rc=$?
-		fi
-
-		if [[ "$rc" == "2" ]]; then
-			dropped=$((dropped + 1))
-			continue
-		fi
-
-		retryable_fail=1
-		fail_index="$i"
-		break
-	done
-
-	rm -f "$queued_tmp"
-
-	local tmp remaining_start
-	tmp="$(mktemp "${TMPDIR:-/tmp}/pl-otlp-queue.XXXXXX")"
-	if ((retryable_fail == 1)); then
-		remaining_start="$fail_index"
-	else
-		remaining_start="$max_attempts"
-	fi
-
-	for ((i = remaining_start; i < total; i++)); do
-		printf '%s\n' "${queue_payloads[$i]}" >>"$tmp"
-	done
-
-	mv "$tmp" "$PL_QUEUE_FILE"
-	chmod 600 "$PL_QUEUE_FILE" 2>/dev/null || true
-	release_queue_lock
-
-	if ((replayed > 0)); then
-		log "INFO" "Drained queued OTLP payloads count=$replayed"
-	fi
-	if ((dropped > 0)); then
-		log "WARN" "Dropped non-retryable queued OTLP payloads count=$dropped"
-	fi
-
-	return 0
-}
-
-send_otlp_payload_file() {
-	local payload_file="$1"
-	local rc
-
-	drain_otlp_queue || true
-
-	if post_otlp_payload_file "$payload_file"; then
-		return 0
-	else
-		rc=$?
-	fi
-
-	if [[ "$rc" == "1" ]]; then
-		append_to_otlp_queue_file "$payload_file" || log "ERROR" "Failed to append OTLP payload to queue"
-	fi
-	return 1
-}
-
-kind_int_to_string() {
-	case "$1" in
-	0) echo "SPAN_KIND_UNSPECIFIED" ;;
-	1) echo "SPAN_KIND_INTERNAL" ;;
-	2) echo "SPAN_KIND_SERVER" ;;
-	3) echo "SPAN_KIND_CLIENT" ;;
-	4) echo "SPAN_KIND_PRODUCER" ;;
-	5) echo "SPAN_KIND_CONSUMER" ;;
-	*) echo "SPAN_KIND_UNSPECIFIED" ;;
-	esac
-}
-
-build_span_json() {
-	local trace_id="$1"
-	local span_id="$2"
-	local parent_span_id="$3"
-	local name="$4"
-	local kind="$5"
-	local start_ns="$6"
-	local end_ns="$7"
-	local attrs_json="$8"
-
-	# Convert integer kind to protobuf JSON enum string if needed
-	if [[ "$kind" =~ ^[0-9]+$ ]]; then
-		kind="$(kind_int_to_string "$kind")"
-	fi
-
-	trace_id="$(normalize_hex_id "$trace_id" 32 "$(generate_trace_id)" "trace_id")"
-	span_id="$(normalize_hex_id "$span_id" 16 "$(generate_span_id)" "span_id")"
-	if [[ -n "$parent_span_id" ]]; then
-		parent_span_id="$(normalize_hex_id "$parent_span_id" 16 "$(generate_span_id)" "parent_span_id")"
-	fi
-
-	local trace_id_b64 span_id_b64 parent_span_id_b64
-	trace_id_b64="$(hex_to_base64 "$trace_id")"
-	span_id_b64="$(hex_to_base64 "$span_id")"
-	parent_span_id_b64=""
-	if [[ -n "$parent_span_id" ]]; then
-		parent_span_id_b64="$(hex_to_base64 "$parent_span_id")"
-	fi
-
-	local span_json
-	span_json="$(jq -cn \
-		--arg trace_id "$trace_id_b64" \
-		--arg span_id "$span_id_b64" \
-		--arg parent_span_id "$parent_span_id_b64" \
-		--arg name "$name" \
-		--arg kind "$kind" \
-		--arg start "$start_ns" \
-		--arg end "$end_ns" \
-		--argjson attributes "$attrs_json" \
-		'{
-      traceId: $trace_id,
-      spanId: $span_id,
-      parentSpanId: (if $parent_span_id == "" then null else $parent_span_id end),
-      name: $name,
-      kind: $kind,
-      startTimeUnixNano: $start,
-      endTimeUnixNano: $end,
-      attributes: (
-        $attributes
-        | to_entries
-        | map(select(.value != null))
-        | map(
-            . as $kv
-            | {
-                key: $kv.key,
-                value: (
-                  if ($kv.value | type) == "string" then
-                    {stringValue: $kv.value}
-                  elif ($kv.value | type) == "boolean" then
-                    {boolValue: $kv.value}
-                  elif ($kv.value | type) == "number" then
-                    if ($kv.value | floor) == $kv.value then
-                      {intValue: ($kv.value | tostring)}
-                    else
-                      {doubleValue: $kv.value}
-                    end
-                  else
-                    {stringValue: ($kv.value | tojson)}
-                  end
-                )
-              }
-          )
-      )
-    }')"
-
-	echo "$span_json"
-}
-
-emit_spans_batch_file() {
-	local spans_file="$1"
-	if [[ ! -s "$spans_file" ]]; then
-		return 0
-	fi
-
-	local payload_file
-	payload_file="$(mktemp "${TMPDIR:-/tmp}/pl-otlp-batch.XXXXXX")"
-	jq -cs '{resourceSpans:[{resource:{attributes:[{key:"service.name",value:{stringValue:"claude-code"}}]},scopeSpans:[{spans:.}]}]}' "$spans_file" >"$payload_file"
-	send_otlp_payload_file "$payload_file"
-	local rc=$?
-	rm -f "$payload_file"
-	return $rc
-}
-
-emit_span() {
-	local trace_id="$1"
-	local span_id="$2"
-	local parent_span_id="$3"
-	local name="$4"
-	local kind="$5"
-	local start_ns="$6"
-	local end_ns="$7"
-	local attrs_json="$8"
-
-	local span_json spans_file
-	span_json="$(build_span_json "$trace_id" "$span_id" "$parent_span_id" "$name" "$kind" "$start_ns" "$end_ns" "$attrs_json")" || return 1
-	spans_file="$(mktemp "${TMPDIR:-/tmp}/pl-otlp-span.XXXXXX")"
-	printf '%s\n' "$span_json" >"$spans_file"
-	emit_spans_batch_file "$spans_file"
-	local rc=$?
-	rm -f "$spans_file"
-	return $rc
-}

package/vendor/claude-agents/trace/hooks/post_tool_use.sh

@@ -9,33 +9,8 @@ tracing_enabled || exit 0
 check_requirements || exit 0
 
 input="$(cat)"
-session_id="$(echo "$input" | jq -r '.session_id // empty')"
-tool_name="$(echo "$input" | jq -r '.tool_name // empty')"
-tool_input="$(echo "$input" | jq -c '.tool_input // {}')"
-tool_output="$(echo "$input" | jq -c '.tool_response // .output // {}')"
+result="$(printf '%s' "$input" | python3 "$SCRIPT_DIR/py/cli.py" post-tool-use)"
+IFS=$'\t' read -r session_id tool_name <<<"$result"
 [[ -z "$session_id" || -z "$tool_name" ]] && exit 0
 
-ensure_session_initialized "$session_id"
-
-trace_id="$(get_session_state "$session_id" trace_id)"
-[[ -z "$trace_id" ]] && exit 0
-turn_start_ns="$(get_session_state "$session_id" current_turn_start_ns)"
-if [[ -z "$turn_start_ns" ]]; then
-	set_session_state "$session_id" current_turn_start_ns "$(now_ns)"
-fi
-
-attrs="$(jq -nc \
-	--arg source claude-code \
-	--arg hook PostToolUse \
-	--arg tool_name "$tool_name" \
-	--argjson function_input "$tool_input" \
-	--argjson function_output "$tool_output" \
-	'{source:$source,hook:$hook,tool_name:$tool_name,node_type:"CODE_EXECUTION",function_input:$function_input,function_output:$function_output}')"
-
-pending_tool_calls="$(get_session_state "$session_id" pending_tool_calls)"
-[[ -z "$pending_tool_calls" ]] && pending_tool_calls='[]'
-
-pending_tool_calls="$(echo "$pending_tool_calls" | jq -c --argjson attrs "$attrs" '. + [$attrs]')"
-set_session_state "$session_id" pending_tool_calls "$pending_tool_calls"
-
 log "INFO" "PostToolUse captured session_id=$session_id tool=$tool_name"

package/vendor/claude-agents/trace/hooks/py/__init__.py

@@ -0,0 +1 @@
+# Python runtime package for trace plugin hooks.

package/vendor/claude-agents/trace/hooks/py/cli.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+
+import os
+import pathlib
+import sys
+
+
+THIS_DIR = pathlib.Path(__file__).resolve().parent
+if str(THIS_DIR) not in sys.path:
+    sys.path.insert(0, str(THIS_DIR))
+
+from context import load_context
+from handlers import (
+    handle_parse_stop_transcript,
+    handle_post_tool_use,
+    handle_session_end,
+    handle_session_start,
+    handle_stop_hook,
+    handle_user_prompt_submit,
+)
+from otlp import generate_session_id, generate_span_id, generate_trace_id, probe_endpoint
+from settings import write_settings_env
+
+
+def read_stdin() -> str:
+    return sys.stdin.read()
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        raise SystemExit("usage: cli.py <command> [args]")
+
+    command = sys.argv[1]
+    if command in {"session-start", "user-prompt-submit", "post-tool-use", "session-end", "stop-hook"}:
+        ctx = load_context()
+        raw_input = read_stdin()
+        if command == "session-start":
+            output = handle_session_start(ctx, raw_input)
+        elif command == "user-prompt-submit":
+            output = handle_user_prompt_submit(ctx, raw_input)
+        elif command == "post-tool-use":
+            output = handle_post_tool_use(ctx, raw_input)
+        elif command == "session-end":
+            output = handle_session_end(ctx, raw_input)
+        else:
+            output = handle_stop_hook(ctx, raw_input)
+        if output:
+            print(output)
+        return 0
+
+    if command == "generate-trace-id":
+        print(generate_trace_id())
+        return 0
+    if command == "generate-span-id":
+        print(generate_span_id())
+        return 0
+    if command == "generate-session-id":
+        print(generate_session_id())
+        return 0
+    if command == "write-settings-env":
+        if len(sys.argv) != 6:
+            raise SystemExit("usage: cli.py write-settings-env <settings_file> <api_key> <endpoint> <debug>")
+        print(write_settings_env(sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5]))
+        return 0
+    if command == "probe-endpoint":
+        if len(sys.argv) != 4:
+            raise SystemExit("usage: cli.py probe-endpoint <endpoint> <api_key>")
+        print(probe_endpoint(sys.argv[2], sys.argv[3]))
+        return 0
+    if command == "parse-stop-transcript":
+        if len(sys.argv) not in {4, 5}:
+            raise SystemExit("usage: cli.py parse-stop-transcript <transcript_path> <turn_start_ns> [session_id]")
+        expected_session_id = sys.argv[4] if len(sys.argv) == 5 else None
+        print(handle_parse_stop_transcript(sys.argv[2], sys.argv[3], expected_session_id))
+        return 0
+
+    raise SystemExit(f"unknown command: {command}")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())