pi-cursor-sdk 0.1.16 → 0.1.18

package/scripts/isolated-cursor-smoke.sh

@@ -0,0 +1,226 @@
+#!/usr/bin/env bash
+# Isolated /tmp install + fail-fast live smoke for pi-cursor-sdk native replay.
+#
+# Validates packed extension load, plan-strip resync, and absence of "Tool * not found".
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+REAL_HOME="${REAL_HOME:-$HOME}"
+PI_AGENT_DIR="${PI_AGENT_DIR:-$REAL_HOME/.pi/agent}"
+AUTH_JSON="${AUTH_JSON:-$PI_AGENT_DIR/auth.json}"
+REPO="${REPO:-$ROOT}"
+ISOLATED="${ISOLATED:-/tmp/pi-cursor-sdk-isolated-$(date +%Y%m%dT%H%M%S)}"
+PI_LIVE_TIMEOUT="${PI_LIVE_TIMEOUT:-45}"
+SKIP_LIVE="${SKIP_LIVE:-0}"
+SKIP_UNIT="${SKIP_UNIT:-0}"
+PI_BIN="${PI_BIN:-pi}"
+PI_PATH="${PI_PATH:-/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin}"
+
+PACK_DIR="$ISOLATED/pack"
+EXTRACT_DIR="$ISOLATED/extract"
+PROJECT_DIR="$ISOLATED/project"
+SESSION_ROOT="$ISOLATED/sessions"
+SHIM_DIR="$ROOT/scripts/fixtures/plan-strip-shim"
+HOME_DIR="$ISOLATED/home"
+
+print_help() {
+	cat <<EOF
+Isolated /tmp install smoke for pi-cursor-sdk (native replay + plan-strip resync).
+
+Usage:
+  ./scripts/isolated-cursor-smoke.sh
+  SKIP_LIVE=1 ./scripts/isolated-cursor-smoke.sh
+  PI_LIVE_TIMEOUT=90 ./scripts/isolated-cursor-smoke.sh
+
+Environment:
+  REPO                          Repo under test (default: script parent directory).
+  ISOLATED                      Artifact root (default: /tmp/pi-cursor-sdk-isolated-<timestamp>).
+  REAL_HOME                     Source for auth.json (default: \$HOME).
+  AUTH_JSON                     Path to pi auth.json to seed isolated HOME (default: ~/.pi/agent/auth.json).
+  PI_LIVE_TIMEOUT               Per live pi check timeout in seconds (default: 45).
+  PI_BIN                        pi executable (default: pi on PATH).
+  PI_PATH                       PATH for isolated pi runs.
+  SKIP_LIVE=1                   Run unit tests + pack only; skip live Cursor calls.
+  SKIP_UNIT=1                   Skip repo unit tests (live checks only).
+  CURSOR_API_KEY                Optional fallback when auth.json lacks cursor provider.
+
+Prerequisites:
+  node, npm, pi, rg, python3 on PATH
+  ~/.pi/agent/auth.json with cursor provider OR CURSOR_API_KEY
+
+Exit codes:
+  0  all requested checks passed
+  1  prerequisite, unit, pack, live smoke, or JSONL replay validation failure
+EOF
+}
+
+log() {
+	printf '[isolated-smoke] %s\n' "$*"
+}
+
+fail() {
+	printf '[isolated-smoke] FAIL: %s\n' "$*" >&2
+	exit 1
+}
+
+seed_pi_agent_home() {
+	local home="$1"
+	mkdir -p "$home/.pi/agent"
+	if [[ -f "$AUTH_JSON" ]]; then
+		cp "$AUTH_JSON" "$home/.pi/agent/auth.json"
+		chmod 600 "$home/.pi/agent/auth.json"
+		log "seeded $home/.pi/agent/auth.json"
+	else
+		log "WARN: no auth.json at $AUTH_JSON"
+	fi
+	if [[ -f "$PI_AGENT_DIR/models.json" ]]; then
+		cp "$PI_AGENT_DIR/models.json" "$home/.pi/agent/models.json"
+	fi
+}
+
+has_auth_provider() {
+	local provider="$1"
+	python3 - "$provider" "$HOME_DIR/.pi/agent/auth.json" <<'PY'
+import json, sys
+provider, path = sys.argv[1], sys.argv[2]
+try:
+    data = json.load(open(path))
+except FileNotFoundError:
+    sys.exit(1)
+sys.exit(0 if provider in data and data[provider] else 1)
+PY
+}
+
+run_with_timeout() {
+	local label="$1"
+	local seconds="$2"
+	shift 2
+	log "$label (timeout ${seconds}s)"
+	if command -v timeout >/dev/null 2>&1; then
+		timeout --foreground "${seconds}s" "$@" || {
+			local rc=$?
+			[[ $rc -eq 124 ]] && fail "$label timed out after ${seconds}s"
+			fail "$label exited $rc"
+		}
+		return
+	fi
+	if command -v gtimeout >/dev/null 2>&1; then
+		gtimeout "${seconds}s" "$@" || {
+			local rc=$?
+			[[ $rc -eq 124 ]] && fail "$label timed out after ${seconds}s"
+			fail "$label exited $rc"
+		}
+		return
+	fi
+	"$@" &
+	local pid=$!
+	local waited=0
+	while kill -0 "$pid" 2>/dev/null; do
+		if (( waited >= seconds )); then
+			kill -TERM "$pid" 2>/dev/null || true
+			sleep 1
+			kill -KILL "$pid" 2>/dev/null || true
+			fail "$label timed out after ${seconds}s"
+		fi
+		sleep 1
+		waited=$((waited + 1))
+	done
+	wait "$pid" || fail "$label exited $?"
+}
+
+validate_replay_jsonl() {
+	local dir="$1"
+	node "$ROOT/scripts/validate-smoke-jsonl.mjs" --replay-errors-only "$dir"
+}
+
+if [[ "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+	print_help
+	exit 0
+fi
+
+if [[ -f "${SECRETS_FILE:-$REAL_HOME/.secrets}" ]]; then
+	set +u
+	# shellcheck disable=SC1090
+	source "${SECRETS_FILE:-$REAL_HOME/.secrets}"
+	set -u
+fi
+
+command -v node >/dev/null || fail "missing node"
+command -v npm >/dev/null || fail "missing npm"
+command -v rg >/dev/null || fail "missing rg"
+command -v python3 >/dev/null || fail "missing python3"
+
+mkdir -p "$PACK_DIR" "$EXTRACT_DIR" "$PROJECT_DIR" "$SESSION_ROOT" "$HOME_DIR"
+seed_pi_agent_home "$HOME_DIR"
+
+log "isolated root: $ISOLATED"
+log "HOME=$HOME_DIR"
+
+if [[ "$SKIP_UNIT" != "1" ]]; then
+	log "preflight: repo unit tests"
+	run_with_timeout "npm test" 120 bash -lc "cd '$REPO' && npm test"
+fi
+
+if [[ "$SKIP_LIVE" == "1" ]]; then
+	log "SKIP_LIVE=1 — skipping live pi checks"
+	exit 0
+fi
+
+if ! has_auth_provider cursor && [[ -z "${CURSOR_API_KEY:-}" ]]; then
+	fail "no cursor auth in $HOME_DIR/.pi/agent/auth.json and CURSOR_API_KEY unset"
+fi
+
+command -v "$PI_BIN" >/dev/null || fail "PI_BIN not found: $PI_BIN"
+
+log "npm pack from $REPO"
+(cd "$REPO" && npm pack --pack-destination "$PACK_DIR" >/dev/null 2>&1)
+PACK_TGZ="$(ls -t "$PACK_DIR"/*.tgz | head -1)"
+[[ -f "$PACK_TGZ" ]] || fail "missing pack tarball"
+tar -xzf "$PACK_TGZ" -C "$EXTRACT_DIR"
+[[ -d "$EXTRACT_DIR/package" ]] || fail "extract missing package/ dir"
+
+log "npm install packed extension deps"
+run_with_timeout "npm install --omit=dev" 120 bash -lc "cd '$EXTRACT_DIR/package' && npm install --omit=dev >/dev/null 2>&1"
+
+log "pi install -l (clean HOME)"
+cp "$REPO/README.md" "$PROJECT_DIR/README.md"
+run_with_timeout "pi install" 30 env -i HOME="$HOME_DIR" PATH="$PI_PATH" MISE_DISABLE=1 \
+	bash -c "cd '$PROJECT_DIR' && '$PI_BIN' install -l '$EXTRACT_DIR/package' >/dev/null"
+
+run_with_timeout "pi list" 15 env -i HOME="$HOME_DIR" PATH="$PI_PATH" MISE_DISABLE=1 \
+	bash -c "cd '$PROJECT_DIR' && '$PI_BIN' list" | rg -q "extract/package" || fail "packed extension not installed"
+
+PI_ENV=(HOME="$HOME_DIR" PATH="$PI_PATH" MISE_DISABLE=1 PI_CURSOR_SETTING_SOURCES=none)
+if [[ -n "${CURSOR_API_KEY:-}" ]]; then
+	PI_ENV+=(CURSOR_API_KEY="$CURSOR_API_KEY")
+fi
+
+log "check: list-models"
+LIST_OUT="$ISOLATED/list-models.txt"
+run_with_timeout "list-models" 30 env -i "${PI_ENV[@]}" \
+	bash -c "cd '$PROJECT_DIR' && '$PI_BIN' --cursor-no-fast --list-models cursor > '$LIST_OUT' 2>&1"
+rg -q "composer-2\\.5|composer-2-5" "$LIST_OUT" || fail "composer-2.5 not listed (see $LIST_OUT)"
+
+log "check: basic provider prompt"
+BASIC_DIR="$SESSION_ROOT/basic"
+mkdir -p "$BASIC_DIR"
+run_with_timeout "basic prompt" "$PI_LIVE_TIMEOUT" env -i "${PI_ENV[@]}" \
+	bash -c "cd '$PROJECT_DIR' && '$PI_BIN' --cursor-no-fast --model cursor/composer-2.5 --session-dir '$BASIC_DIR' --no-tools -p 'Reply exactly: PI_CURSOR_ISOLATED_OK' > '$ISOLATED/basic.stdout.txt' 2> '$ISOLATED/basic.stderr.txt'"
+rg -q "PI_CURSOR_ISOLATED_OK" "$ISOLATED/basic.stdout.txt" || fail "basic prompt missing PI_CURSOR_ISOLATED_OK"
+validate_replay_jsonl "$BASIC_DIR"
+
+log "check: native replay"
+REPLAY_DIR="$SESSION_ROOT/native-replay"
+mkdir -p "$REPLAY_DIR"
+run_with_timeout "native replay" "$PI_LIVE_TIMEOUT" env -i "${PI_ENV[@]}" PI_CURSOR_NATIVE_TOOL_DISPLAY=1 \
+	bash -c "cd '$PROJECT_DIR' && '$PI_BIN' --cursor-no-fast --model cursor/composer-2.5 --session-dir '$REPLAY_DIR' -p 'Read ./README.md briefly, then answer README_SEEN=yes if it mentions pi-cursor-sdk.' > '$ISOLATED/replay.stdout.txt' 2> '$ISOLATED/replay.stderr.txt'"
+validate_replay_jsonl "$REPLAY_DIR"
+
+log "check: plan-strip shim (plan-mode execute reset)"
+PLAN_DIR="$SESSION_ROOT/plan-strip"
+mkdir -p "$PLAN_DIR"
+run_with_timeout "plan-strip replay" "$PI_LIVE_TIMEOUT" env -i "${PI_ENV[@]}" PI_CURSOR_NATIVE_TOOL_DISPLAY=1 \
+	bash -c "cd '$PROJECT_DIR' && '$PI_BIN' -e '$SHIM_DIR' --cursor-no-fast --model cursor/composer-2.5 --session-dir '$PLAN_DIR' -p 'After reset, read README.md and answer PLAN_STRIP_OK=yes.' > '$ISOLATED/plan.stdout.txt' 2> '$ISOLATED/plan.stderr.txt'"
+validate_replay_jsonl "$PLAN_DIR"
+
+log "PASS isolated install smoke: $ISOLATED"

package/scripts/steering-rpc-smoke.mjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * RPC steering smoke: queue steer after a native-replay tool-use turn completes execution.
+ */
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const CHILD_SHUTDOWN_GRACE_MS = 2_000;
+
+function printHelp() {
+	console.log(`RPC steering smoke for pi-cursor-sdk live runs.
+
+Usage:
+  node scripts/steering-rpc-smoke.mjs
+
+Environment:
+  SMOKE_SESSION_DIR            Session directory for the RPC pi run. Defaults to /tmp/pi-cursor-steer-smoke-<timestamp>.
+  CURSOR_API_KEY               Required Cursor API key for live pi runs.
+
+Options:
+  -h, --help                   Show this help.
+
+Exit codes:
+  0  steering scenario completed without AgentBusyError; STEER_OK and STEER_CHAIN present
+  1  validation failure, timeout, AgentBusyError, or non-zero pi exit
+
+Notes:
+  - Runs pi in RPC mode with native tool replay enabled and the pi bridge disabled.
+  - Sends steer after the replayed bash tool finishes execution (post toolResult boundary).
+  - Prints a single JSON result line on success; errors go to stderr.`);
+}
+
+function fail(message) {
+	throw new Error(message);
+}
+
+function parseEvents(stdout) {
+	const events = [];
+	for (const line of stdout.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			events.push(JSON.parse(line));
+		} catch {
+			// ignore partial lines
+		}
+	}
+	return events;
+}
+
+function assistantText(events) {
+	return events
+		.filter((event) => event.type === "message_end" && event.message?.role === "assistant")
+		.map((event) =>
+			(event.message.content ?? [])
+				.filter((block) => block.type === "text")
+				.map((block) => block.text)
+				.join("\n"),
+		)
+		.join("\n");
+}
+
+function hasToolUseTurn(events) {
+	return events.some(
+		(event) =>
+			event.type === "message_end" &&
+			event.message?.role === "assistant" &&
+			event.message?.stopReason === "toolUse",
+	);
+}
+
+function hasToolExecutionEnd(events) {
+	return events.some((event) => event.type === "tool_execution_end");
+}
+
+function waitFor(getStdout, predicate, timeoutMs = 300_000) {
+	const start = Date.now();
+	return new Promise((resolve, reject) => {
+		const tick = () => {
+			const events = parseEvents(getStdout());
+			if (predicate(events)) {
+				resolve(events);
+				return;
+			}
+			if (Date.now() - start > timeoutMs) {
+				reject(
+					new Error(
+						`timeout after ${timeoutMs}ms\nassistantText=${assistantText(events)}\nstdoutTail=${getStdout().slice(-4000)}`,
+					),
+				);
+				return;
+			}
+			setTimeout(tick, 500);
+		};
+		tick();
+	});
+}
+
+function waitForChildClose(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(child.exitCode ?? 1);
+	return new Promise((resolve) => {
+		child.once("close", (code) => resolve(code ?? 1));
+	});
+}
+
+function signalChild(child, signal) {
+	if (!child.pid) return;
+	try {
+		if (process.platform === "win32") {
+			child.kill(signal);
+		} else {
+			process.kill(-child.pid, signal);
+		}
+	} catch {
+		try {
+			child.kill(signal);
+		} catch {
+			// child already exited
+		}
+	}
+}
+
+async function terminateChild(child) {
+	child.stdin.destroy();
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	signalChild(child, "SIGTERM");
+	const killTimer = setTimeout(() => signalChild(child, "SIGKILL"), CHILD_SHUTDOWN_GRACE_MS);
+	try {
+		await waitForChildClose(child);
+	} finally {
+		clearTimeout(killTimer);
+	}
+}
+
+async function runPiRpcSmoke(sessionDir) {
+	const args = ["-e", root, "--cursor-no-fast", "--model", "cursor/composer-2.5", "--mode", "rpc", "--session-dir", sessionDir];
+	const env = {
+		...process.env,
+		PI_CURSOR_SETTING_SOURCES: "none",
+		PI_CURSOR_NATIVE_TOOL_DISPLAY: "1",
+		PI_CURSOR_PI_TOOL_BRIDGE: "0",
+	};
+
+	const child = spawn("pi", args, { cwd: root, env, stdio: ["pipe", "pipe", "pipe"], detached: process.platform !== "win32" });
+	let closed = false;
+	let stdout = "";
+	let stderr = "";
+	child.stdout.on("data", (chunk) => {
+		stdout += chunk.toString();
+	});
+	child.stderr.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+
+	const send = (obj) => {
+		if (!child.stdin.writable) fail("pi stdin closed before smoke command could be sent");
+		child.stdin.write(`${JSON.stringify(obj)}\n`);
+	};
+
+	try {
+		send({
+			type: "prompt",
+			message:
+				"Steering smoke. Use bash once to run: git status --short. Do not answer until after the tool completes. Final answer must include STEER_OK=yes.",
+		});
+
+		await waitFor(
+			() => stdout,
+			(events) => hasToolUseTurn(events),
+		);
+
+		await waitFor(
+			() => stdout,
+			(events) => hasToolExecutionEnd(events),
+		);
+
+		send({ type: "steer", message: "and also include STEER_CHAIN=ok in the final answer" });
+
+		await waitFor(
+			() => stdout,
+			(events) => {
+				const text = assistantText(events);
+				return text.includes("STEER_OK=yes") && text.includes("STEER_CHAIN=ok") && events.some((event) => event.type === "agent_end");
+			},
+		);
+
+		const combined = stdout + stderr;
+		if (/already has active run|AgentBusyError/i.test(combined)) {
+			fail("AgentBusyError detected in smoke output");
+		}
+
+		const text = assistantText(parseEvents(stdout));
+		if (!text.includes("STEER_OK=yes")) {
+			fail(`missing STEER_OK=yes in assistant output: ${text.slice(0, 500)}`);
+		}
+		if (!text.includes("STEER_CHAIN=ok")) {
+			fail(`missing STEER_CHAIN=ok in assistant output: ${text.slice(0, 500)}`);
+		}
+
+		child.stdin.end();
+		const exitCode = await waitForChildClose(child);
+		closed = true;
+		if (exitCode !== 0) {
+			fail(`pi exited ${exitCode}\nstderr=${stderr.slice(-2000)}`);
+		}
+
+		return {
+			ok: true,
+			sessionDir,
+			steerOk: true,
+			steerChain: true,
+		};
+	} finally {
+		if (!closed) await terminateChild(child);
+	}
+}
+
+async function main() {
+	if (process.argv.includes("-h") || process.argv.includes("--help")) {
+		printHelp();
+		return;
+	}
+
+	if (!process.env.CURSOR_API_KEY) {
+		fail("steering-rpc-smoke: CURSOR_API_KEY is required");
+	}
+
+	const sessionDir = process.env.SMOKE_SESSION_DIR ?? join("/tmp", `pi-cursor-steer-smoke-${Date.now()}`);
+	mkdirSync(sessionDir, { recursive: true });
+	console.log(JSON.stringify(await runPiRpcSmoke(sessionDir)));
+}
+
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});