dsh-codex-connect 0.1.0-alpha.4.21 → 0.1.0-alpha.4.23

package/lib/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { B as DSH_PLUGIN_API_PACKAGES, Dt as logoutOpenAICodex, Et as loginOpenAICodex, J as readInstalledPackageVersion, Mt as OpenAICodexCredentialStore, Nt as openAICodexAuthPath, Ot as openAICodexAuthStatus, St as normalizeTrustedOrigin, c as migrateOpenAICodexSearchHistory, j as CODEX_CONNECT_VERSION, jt as OPENAI_CODEX_PROVIDER, k as diagnoseOpenAICodex, kt as openAICodexModelCatalog, l as OPENAI_CODEX_BASE_URL, pt as normalizeOpenAICodexProxyUrl, q as evaluateCompatibility, xt as OpenAICodexTrustedOriginsStore } from "./src-Cxq99TvF.js";
+import { At as openAICodexModelCatalog, B as DSH_PLUGIN_API_PACKAGES, Ct as normalizeTrustedOrigin, Dt as loginOpenAICodex, J as readInstalledPackageVersion, Mt as OPENAI_CODEX_PROVIDER, Nt as OpenAICodexCredentialStore, Ot as logoutOpenAICodex, Pt as openAICodexAuthPath, St as OpenAICodexTrustedOriginsStore, c as migrateOpenAICodexSearchHistory, j as CODEX_CONNECT_VERSION, k as diagnoseOpenAICodex, kt as openAICodexAuthStatus, l as OPENAI_CODEX_BASE_URL, mt as normalizeOpenAICodexProxyUrl, q as evaluateCompatibility } from "./src-ByKP_wn9.js";
 import { createHash } from "node:crypto";
 import { Agent, ProxyAgent, fetch } from "undici";
 import { fileURLToPath } from "node:url";
@@ -9,17 +9,17 @@ import { createInterface } from "node:readline/promises";
 //#region src/capability-probe.ts
 /** Bounded, standalone Responses probe; never used by conversation routing. */
 /** A security limit, not a model output-token setting. */
-const MAX_PROBE_RESPONSE_BYTES = 65536;
-function record(value) {
+const MAX_PROBE_RESPONSE_BYTES$1 = 65536;
+function record$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function completedResponse(value, model) {
-	if (!record(value) || value["status"] !== "completed" || !Array.isArray(value["output"])) return false;
+function completedResponse$1(value, model) {
+	if (!record$1(value) || value["status"] !== "completed" || !Array.isArray(value["output"])) return false;
 	if (value["model"] !== model) return false;
-	return value["output"].some((item) => record(item) && item["type"] === "message" && item["role"] === "assistant" && Array.isArray(item["content"]) && item["content"].some((part) => record(part) && part["type"] === "output_text" && typeof part["text"] === "string" && part["text"].trim().length > 0));
+	return value["output"].some((item) => record$1(item) && item["type"] === "message" && item["role"] === "assistant" && Array.isArray(item["content"]) && item["content"].some((part) => record$1(part) && part["type"] === "output_text" && typeof part["text"] === "string" && part["text"].trim().length > 0));
 }
 /** Inspect complete SSE frames, not substrings inside error text or schema errors. */
-function completedStream(text, model) {
+function completedStream$1(text, model) {
 	let completed = false;
 	let data = [];
 	for (const line of text.split(/\r\n|\r|\n/u)) if (line === "") {
@@ -33,10 +33,10 @@ function completedStream(text, model) {
 		} catch {
 			return false;
 		}
-		if (!record(event)) return false;
+		if (!record$1(event)) return false;
 		if (event["type"] === "error" || event["type"] === "response.failed" || event["type"] === "response.incomplete") return false;
 		if (event["type"] === "response.completed" || event["type"] === "response.done") {
-			if (completed || !completedResponse(event["response"], model)) return false;
+			if (completed || !completedResponse$1(event["response"], model)) return false;
 			completed = true;
 		}
 	} else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /u, ""));
@@ -112,7 +112,7 @@ async function probeCodexResponses(request, createDispatcher = (proxyUrl) => pro
 				const { value, done } = await reader.read();
 				if (done) break;
 				size += value.byteLength;
-				if (size > MAX_PROBE_RESPONSE_BYTES) {
+				if (size > MAX_PROBE_RESPONSE_BYTES$1) {
 					await reader.cancel();
 					return {
 						outcome: "incomplete",
@@ -125,7 +125,7 @@ async function probeCodexResponses(request, createDispatcher = (proxyUrl) => pro
 			reader.releaseLock();
 		}
 		return {
-			outcome: completedStream(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)), request.model) ? "completed" : "incomplete",
+			outcome: completedStream$1(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)), request.model) ? "completed" : "incomplete",
 			httpStatus
 		};
 	} catch {
@@ -151,7 +151,7 @@ function result(status, reason, action) {
 function safeVersion(value) {
 	return value !== null && value !== void 0 && /^v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.test(value) ? value : null;
 }
-function observed(evidence) {
+function observed$1(evidence) {
 	switch (evidence.outcome) {
 		case "completed": return result("supported", "completed-response-for-selected-model", "This proves only the fixed standalone prompt; test the active Harness profile separately.");
 		case "http-rejected": switch (evidence.httpStatus) {
@@ -208,7 +208,7 @@ var CodexCapabilityDiagnostics = class {
 			packageVersions: versions
 		});
 		const missing = Object.values(versions).some((value) => value === null) || !/^v?\d+\.\d+\.\d+$/u.test(versions["node"] ?? "");
-		const runtime = DSH_PLUGIN_API_PACKAGES.some((name) => versions[name] !== null && versions[name] !== "0.1.1-rc.2") || compatibility.status === "incompatible" ? result("rejected", "declared-version-mismatch", "Use DSH API 0.1.1-rc.2 and pi-ai 0.82.1 together. DSH 0.1.0-rc.7 requires Codex Connect 0.1.0-alpha.4.14.") : missing || compatibility.status === "unknown" ? result("unknown", "version-metadata-unavailable", "Run this command from the plugin installation in the intended profile.") : result("supported", "declared-host-versions-match", "Host package versions satisfy the declared requirements; this is not a live profile or browser compatibility test.");
+		const runtime = DSH_PLUGIN_API_PACKAGES.some((name) => versions[name] !== null && versions[name] !== "0.1.2-alpha.2") || compatibility.status === "incompatible" ? result("rejected", "declared-version-mismatch", "Use DSH API 0.1.2-alpha.2 and pi-ai ^0.84.2 together. DSH 0.1.0-rc.7 requires Codex Connect 0.1.0-alpha.4.14.") : missing || compatibility.status === "unknown" ? result("unknown", "version-metadata-unavailable", "Run this command from the plugin installation in the intended profile.") : result("supported", "declared-host-versions-match", "Host package versions satisfy the declared requirements; this is not a live profile or browser compatibility test.");
 		const model = this.deps.catalog().find((item) => item.id === request.model)?.id ?? null;
 		const unknownNetwork = result("unknown", "not-probed", "Run capabilities --model <catalog-id> --probe explicitly; this sends a fixed short request and may consume quota.");
 		const checks = {
@@ -295,7 +295,7 @@ var CodexCapabilityDiagnostics = class {
 			};
 		}
 		if (evidence.httpStatus !== void 0) report.probe.httpStatus = evidence.httpStatus;
-		checks.responses = observed(evidence);
+		checks.responses = observed$1(evidence);
 		checks.transport = { ...checks.responses };
 		if (evidence.outcome === "completed") {
 			checks.oauth = result("supported", "authorized-completed-response", "Authorization succeeded for this model and fixed request at the recorded time only.");
@@ -369,6 +369,349 @@ async function runCapabilityCommand(args) {
 	}
 }
 //#endregion
+//#region src/auto-review-probe.ts
+/** Fixed, standalone probe for the hidden Codex approval reviewer. */
+/** Hidden reviewer route selected by the first-party Codex catalog. */
+const CODEX_AUTO_REVIEW_MODEL = "codex-auto-review";
+/** A response-reading limit, not a model output-token setting. */
+const MAX_PROBE_RESPONSE_BYTES = 65536;
+const instructions = "This is a capability diagnostic. Do not call tools or execute any action. Return one strict JSON assessment for the supplied synthetic approval request, including risk_level, user_authorization, outcome, and rationale.";
+const input = "Synthetic approval request only; nothing will be executed. Planned action JSON: {\"type\":\"diagnostic-no-op\",\"sideEffects\":false}";
+const assessmentSchema = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		risk_level: {
+			type: "string",
+			enum: [
+				"low",
+				"medium",
+				"high",
+				"critical"
+			]
+		},
+		user_authorization: {
+			type: "string",
+			enum: [
+				"unknown",
+				"low",
+				"medium",
+				"high"
+			]
+		},
+		outcome: {
+			type: "string",
+			enum: ["allow", "deny"]
+		},
+		rationale: { type: "string" }
+	},
+	required: [
+		"risk_level",
+		"user_authorization",
+		"outcome",
+		"rationale"
+	]
+};
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assessment(text) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		return false;
+	}
+	if (!record(value)) return false;
+	if (Object.keys(value).some((key) => ![
+		"risk_level",
+		"user_authorization",
+		"outcome",
+		"rationale"
+	].includes(key))) return false;
+	if (![
+		"low",
+		"medium",
+		"high",
+		"critical"
+	].includes(String(value["risk_level"]))) return false;
+	if (![
+		"unknown",
+		"low",
+		"medium",
+		"high"
+	].includes(String(value["user_authorization"]))) return false;
+	if (!["allow", "deny"].includes(String(value["outcome"]))) return false;
+	return typeof value["rationale"] === "string";
+}
+function completedResponse(value) {
+	if (!record(value) || value["status"] !== "completed" || typeof value["model"] !== "string" || !Array.isArray(value["output"])) return void 0;
+	return value["output"].flatMap((item) => record(item) && item["type"] === "message" && item["role"] === "assistant" && Array.isArray(item["content"]) ? item["content"].flatMap((part) => record(part) && part["type"] === "output_text" && typeof part["text"] === "string" ? [part["text"]] : []) : []);
+}
+/** Inspect complete SSE frames and accept exactly one matching terminal response. */
+function completedStream(text) {
+	let completed = false;
+	let terminalTexts;
+	const streamedTexts = [];
+	let data = [];
+	for (const line of text.split(/\r\n|\r|\n/u)) if (line === "") {
+		if (data.length === 0) continue;
+		const payload = data.join("\n");
+		data = [];
+		if (payload === "[DONE]") continue;
+		let event;
+		try {
+			event = JSON.parse(payload);
+		} catch {
+			return false;
+		}
+		if (!record(event) || event["type"] === "error" || event["type"] === "response.failed" || event["type"] === "response.incomplete") return false;
+		if (event["type"] === "response.output_text.done") {
+			if (typeof event["text"] !== "string") return false;
+			streamedTexts.push(event["text"]);
+		}
+		if (event["type"] === "response.completed" || event["type"] === "response.done") {
+			terminalTexts = completedResponse(event["response"]);
+			if (completed || terminalTexts === void 0) return false;
+			completed = true;
+		}
+	} else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /u, ""));
+	if (!completed || data.length !== 0) return false;
+	const texts = terminalTexts.length > 0 ? terminalTexts : streamedTexts;
+	return texts.length === 1 && assessment(texts[0]);
+}
+/**
+* Send one secret-free synthetic approval to the hidden reviewer model.
+* The result is evidence only and never authorizes or executes an action.
+* @param request - OAuth credential, explicit network policy, deadline, and optional cancellation.
+* @param createDispatcher - owned connection factory; tests use an offline dispatcher.
+* @returns bounded evidence without model-generated or provider error text.
+*/
+async function probeCodexAutoReview(request, createDispatcher = (proxyUrl) => proxyUrl === void 0 ? new Agent() : new ProxyAgent(proxyUrl)) {
+	const dispatcher = createDispatcher(request.proxyUrl);
+	const controller = new AbortController();
+	let timedOut = false;
+	let cancelled = request.signal?.aborted ?? false;
+	const cancel = () => {
+		cancelled = true;
+		controller.abort();
+	};
+	request.signal?.addEventListener("abort", cancel, { once: true });
+	if (cancelled) controller.abort();
+	const timer = setTimeout(() => {
+		timedOut = true;
+		controller.abort();
+	}, request.timeoutMs);
+	let httpStatus;
+	try {
+		const response = await fetch(`${OPENAI_CODEX_BASE_URL}/responses`, {
+			dispatcher,
+			method: "POST",
+			redirect: "manual",
+			signal: controller.signal,
+			headers: {
+				authorization: `Bearer ${request.access}`,
+				"chatgpt-account-id": request.accountId,
+				"content-type": "application/json",
+				accept: "text/event-stream",
+				originator: "deepseek-harness"
+			},
+			body: JSON.stringify({
+				model: CODEX_AUTO_REVIEW_MODEL,
+				instructions,
+				input: [{
+					role: "user",
+					content: [{
+						type: "input_text",
+						text: input
+					}]
+				}],
+				text: { format: {
+					type: "json_schema",
+					name: "codex_auto_review_assessment",
+					strict: true,
+					schema: assessmentSchema
+				} },
+				stream: true,
+				store: false
+			})
+		});
+		httpStatus = response.status;
+		if (!response.ok) {
+			await response.body?.cancel();
+			return {
+				outcome: [
+					400,
+					401,
+					403,
+					404,
+					405,
+					422
+				].includes(httpStatus) ? "http-rejected" : "transient",
+				httpStatus
+			};
+		}
+		const contentType = response.headers.get("content-type");
+		if (httpStatus !== 200 || contentType !== null && !contentType.toLowerCase().startsWith("text/event-stream") || response.body === null) {
+			await response.body?.cancel();
+			return {
+				outcome: "incomplete",
+				httpStatus
+			};
+		}
+		const reader = response.body.getReader();
+		const chunks = [];
+		let size = 0;
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (done) break;
+				size += value.byteLength;
+				if (size > MAX_PROBE_RESPONSE_BYTES) {
+					await reader.cancel();
+					return {
+						outcome: "incomplete",
+						httpStatus
+					};
+				}
+				chunks.push(value);
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		return {
+			outcome: completedStream(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks))) ? "completed" : "incomplete",
+			httpStatus
+		};
+	} catch {
+		return {
+			outcome: cancelled ? "cancelled" : timedOut ? "timeout" : "network-error",
+			...httpStatus === void 0 ? {} : { httpStatus }
+		};
+	} finally {
+		clearTimeout(timer);
+		request.signal?.removeEventListener("abort", cancel);
+		await dispatcher.destroy();
+	}
+}
+//#endregion
+//#region src/auto-review-cli.ts
+/** Opt-in diagnostic for the hidden Codex approval reviewer. */
+function check(status, reason, action) {
+	return {
+		status,
+		reason,
+		action
+	};
+}
+function observed(evidence) {
+	switch (evidence.outcome) {
+		case "completed": return check("supported", "completed-structured-review", "The OAuth route accepted the hidden reviewer and returned its approval schema; this does not enable DSH approval integration.");
+		case "http-rejected": return check("rejected", `http-${String(evidence.httpStatus ?? "rejected")}`, "The supported OAuth route rejected this hidden reviewer request; keep automatic approval disabled.");
+		case "transient": return check("unknown", "transient-or-redirect-response", "Check network, quota, or service availability before explicitly retrying.");
+		case "incomplete": return check("unknown", "no-complete-structured-review", "HTTP success without one matching structured assessment is not capability evidence.");
+		case "timeout": return check("unknown", "probe-deadline", "The diagnostic exceeded its deadline; no approval capability was established.");
+		case "cancelled": return check("unknown", "probe-cancelled", "The diagnostic was cancelled; no approval capability was established.");
+		case "network-error": return check("unknown", "network-or-stream-error", "Check the network or pass an explicit --proxy; no server decision was confirmed.");
+	}
+}
+/** Run the standalone reviewer probe without booting Harness or changing settings. */
+async function runAutoReviewProbeCommand(args, deps = {
+	diagnose: diagnoseOpenAICodex,
+	credentials: new OpenAICodexCredentialStore(),
+	probe: probeCodexAutoReview,
+	now: Date.now
+}) {
+	let json = false;
+	let proxyUrl;
+	let timeoutMs = 3e4;
+	const seen = /* @__PURE__ */ new Set();
+	const invalid = () => {
+		process.stderr.write("Usage: dsh-codex-connect auto-review-probe [--proxy <http(s)-origin>] [--timeout-ms <1..60000>] [--json]\n");
+		return 2;
+	};
+	for (let index = 0; index < args.length; index += 1) {
+		const flag = args[index];
+		if (seen.has(flag)) return invalid();
+		seen.add(flag);
+		if (flag === "--json") json = true;
+		else if (flag === "--proxy" || flag === "--timeout-ms") {
+			const value = args[++index];
+			if (value === void 0 || value.startsWith("--")) return invalid();
+			if (flag === "--proxy") {
+				proxyUrl = normalizeOpenAICodexProxyUrl(value);
+				if (proxyUrl === void 0) return invalid();
+			} else {
+				if (!/^\d+$/u.test(value) || Number(value) < 1 || Number(value) > 6e4) return invalid();
+				timeoutMs = Number(value);
+			}
+		} else return invalid();
+	}
+	const local = await deps.diagnose();
+	const runtime = local.compatibility.status === "compatible" ? check("supported", "declared-host-versions-match", "Installed package versions satisfy the probe prerequisites; this is not active-profile validation.") : check(local.compatibility.status === "incompatible" ? "rejected" : "unknown", "runtime-compatibility-unavailable", "Install the supported Codex Connect and DSH package set before probing.");
+	let oauth = local.credentialFile.state === "owner-only" ? check("unknown", "credential-metadata-only", "An owner-only file does not prove authorization; the explicit probe reads its unexpired stored credential.") : check("rejected", "credential-file-unusable", "Sign in or repair the owner-only credential file before probing.");
+	let reviewer = check("unknown", "not-probed", "Run this command explicitly only when one fixed diagnostic request is acceptable.");
+	let probe = { state: "skipped" };
+	if (runtime.status === "supported" && oauth.status !== "rejected") {
+		let credential;
+		try {
+			credential = await deps.credentials.read(OPENAI_CODEX_PROVIDER);
+		} catch {
+			oauth = check("rejected", "credential-unreadable", "Repair the credential file or sign in again; diagnostic output omits parser details.");
+		}
+		if (credential?.type !== "oauth" || typeof credential.accountId !== "string") {
+			if (oauth.reason !== "credential-unreadable") oauth = check("rejected", "credential-missing", "Sign in before explicitly probing the hidden reviewer.");
+		} else if (credential.expires <= deps.now()) oauth = check("unknown", "access-token-expired", "Use the normal sign-in or refresh flow, then repeat the probe; diagnostics never refresh credentials.");
+		else {
+			let evidence;
+			try {
+				evidence = await deps.probe({
+					access: credential.access,
+					accountId: credential.accountId,
+					proxyUrl,
+					timeoutMs
+				});
+			} catch {
+				evidence = { outcome: "network-error" };
+			}
+			probe = {
+				state: "fresh",
+				...evidence.httpStatus === void 0 ? {} : { httpStatus: evidence.httpStatus }
+			};
+			reviewer = observed(evidence);
+			if (evidence.outcome === "completed") oauth = check("supported", "authorized-completed-review", "Authorization succeeded for this fixed reviewer request at the recorded time only.");
+			else if (evidence.httpStatus === 401) oauth = check("rejected", "http-401", "Sign in again, then explicitly repeat the probe.");
+		}
+	}
+	const report = {
+		schemaVersion: 1,
+		package: "dsh-codex-connect",
+		version: CODEX_CONNECT_VERSION,
+		scope: "auto-review-route-only",
+		model: CODEX_AUTO_REVIEW_MODEL,
+		network: proxyUrl === void 0 ? "direct" : "explicit-proxy",
+		checks: {
+			runtime,
+			oauth,
+			reviewer
+		},
+		probe
+	};
+	process.stdout.write(json ? `${JSON.stringify(report)}\n` : [
+		`Codex Connect ${report.version}: hidden approval-review capability probe`,
+		"Scope: one synthetic no-op; no command is executed and no approval integration is enabled.",
+		`Model: ${report.model}; network: ${report.network}; probe: ${report.probe.state}`,
+		...Object.entries(report.checks).map(([id, value]) => `${id}: ${value.status} (${value.reason})\n  ${value.action}`),
+		""
+	].join("\n"));
+	const primary = [
+		runtime,
+		oauth,
+		reviewer
+	];
+	return primary.some((value) => value.status === "rejected") ? 1 : primary.some((value) => value.status === "unknown") ? 2 : 0;
+}
+//#endregion
 //#region src/bin.ts
 /** Standalone credential CLI for the optional OpenAI Codex bundle. */
 const JSON_SCHEMA_VERSION = 1;
@@ -435,8 +778,10 @@ function printHelp() {
 		"       dsh-codex-connect trusted-origins [--json]",
 		"       dsh-codex-connect untrust-origin <origin>",
 		"       dsh-codex-connect capabilities [--model <catalog-id>] [--probe] [--proxy <http(s)-origin>] [--timeout-ms <1..60000>] [--json]",
+		"       dsh-codex-connect auto-review-probe [--proxy <http(s)-origin>] [--timeout-ms <1..60000>] [--json]",
 		"",
 		"  doctor         inspect secret-free runtime and OAuth file metadata",
+		"  auto-review-probe test the hidden approval reviewer with one synthetic no-op",
 		"  login          sign in with a separate ChatGPT OAuth session",
 		"  logout         remove the dsh credential without changing ~/.codex",
 		"  migrate-history find or repair Alpha 4.10 private search events (dry-run by default)",
@@ -445,7 +790,7 @@ function printHelp() {
 		"  trusted-origins list the currently allowed browser origins",
 		"  untrust-origin remove one exact browser origin from the allowlist",
 		"  --device-code  use headless device-code login (login only)",
-		"  --json         emit one JSON document (doctor/status/trusted-origins/migrate-history)",
+		"  --json         emit one JSON document (doctor/status/capabilities/auto-review-probe/trusted-origins/migrate-history)",
 		""
 	].join("\n"));
 }
@@ -483,6 +828,7 @@ async function run(argv) {
 	}
 	const [rawAction, ...flags] = argv;
 	if (rawAction === "capabilities") return runCapabilityCommand(flags);
+	if (rawAction === "auto-review-probe") return runAutoReviewProbeCommand(flags);
 	if (![
 		"doctor",
 		"login",