youmd 0.12.0 → 0.13.0

package/dist/commands/connect.js

@@ -0,0 +1,849 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issueCodexStatusReceipt = issueCodexStatusReceipt;
+exports.listAgentAccessDeviceKeys = listAgentAccessDeviceKeys;
+exports.enrollAgentAccessDeviceKey = enrollAgentAccessDeviceKey;
+exports.revokeAgentAccessDeviceKey = revokeAgentAccessDeviceKey;
+exports.listAgentAccessApplications = listAgentAccessApplications;
+exports.registerAgentAccessApplication = registerAgentAccessApplication;
+exports.updateAgentAccessApplication = updateAgentAccessApplication;
+exports.revokeAgentAccessApplication = revokeAgentAccessApplication;
+exports.proveChatGPTConnectedAccess = proveChatGPTConnectedAccess;
+exports.listAgentAccessReceipts = listAgentAccessReceipts;
+exports.verifyAgentAccessReceipt = verifyAgentAccessReceipt;
+exports.revokeAgentAccessReceipt = revokeAgentAccessReceipt;
+exports.normalizeLocalHandoffBase = normalizeLocalHandoffBase;
+exports.normalizeHandoffAuthorizationUrl = normalizeHandoffAuthorizationUrl;
+exports.startLocalBrowserHandoff = startLocalBrowserHandoff;
+exports.connectCommand = connectCommand;
+const child_process_1 = require("child_process");
+const crypto = __importStar(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const render_1 = require("../lib/render");
+const config_1 = require("../lib/config");
+const machine_identity_1 = require("../lib/machine-identity");
+const connected_access_native_1 = require("../lib/connected-access-native");
+const codex_device_auth_1 = require("../lib/codex-device-auth");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const codex_job_control_plane_1 = require("../lib/codex-job-control-plane");
+const codex_readonly_job_1 = require("../lib/codex-readonly-job");
+const connected_context_1 = require("../lib/connected-context");
+const ACCENT = chalk_1.default.hex("#C46A3A");
+const HANDOFF_START_PATH = "/api/local/browser-session/start";
+const HANDOFF_AUTHORIZE_PATH = "/local-handoff/authorize";
+/**
+ * The local store needs stable manifest/artifact correlators to enforce
+ * rollback and perform an exact revoke. They are not a CLI receipt contract.
+ * Keep every routine bootstrap operation on this deliberately small shape so
+ * shell history, logs, and MCP-adjacent wrappers cannot collect them.
+ */
+function publicConnectedContextStatus(result) {
+    const receipt = {
+        connected: result.connected,
+        state: result.state,
+        authorityGranted: false,
+        secretValuesExposed: false,
+    };
+    if (typeof result.generation === "number")
+        receipt.generation = result.generation;
+    if (typeof result.expiresAt === "string")
+        receipt.expiresAt = result.expiresAt;
+    if (result.recovered === true)
+        receipt.recovered = true;
+    return receipt;
+}
+const CONNECTED_ACCESS = "/api/v1/me/agent-access";
+const CONNECTED_ACCESS_APPLICATION_ID = "app:youmd-connected-access-extension";
+const CODEX_ADAPTER_APPLICATION_ID = "app:youmd-local-codex-adapter";
+function declaredInputFiles(files) {
+    if (!files?.length)
+        throw new Error("codex_audit_file_required");
+    if (files.length > 64 || new Set(files).size !== files.length)
+        throw new Error("codex_audit_files_invalid");
+    return files.map((relative) => {
+        if (!/^(?!\/)(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._/-]{1,512}$/.test(relative))
+            throw new Error("codex_audit_files_invalid");
+        const parts = relative.toLowerCase().split("/");
+        if (parts.some((part) => /^(\.env(?:\..*)?|\.codex|\.claude|\.cursor|\.ssh|\.gnupg|\.git|node_modules|auth\.json|.*(?:credential|secret|token|cookie).*|keychains|chrome|application support)$/.test(part)))
+            throw new Error("codex_audit_files_invalid");
+        const target = path.resolve(process.cwd(), relative);
+        const stat = fs.lstatSync(target);
+        if (stat.isSymbolicLink() || !stat.isFile() || stat.size > 64 * 1024)
+            throw new Error("codex_audit_files_invalid");
+        const bytes = fs.readFileSync(target);
+        return { path: relative, digest: `sha256:${crypto.createHash("sha256").update(bytes).digest("hex")}` };
+    });
+}
+function codexAdapterRegistration() {
+    return { applicationId: CODEX_ADAPTER_APPLICATION_ID, runtime: "native_helper", runtimeBinding: "com.youmd.local-codex-adapter", allowedOrigins: ["https://www.you.md"] };
+}
+async function ensureCodexAdapterKeyAndApplication(nativeHostDeps) {
+    const key = await (0, connected_access_native_1.ensureNativeDevicePublicKey)(undefined, nativeHostDeps);
+    const deviceId = currentConnectedAccessDeviceId();
+    const enrolled = await ownerReceiptRequest(`${CONNECTED_ACCESS}/device-keys/enroll`, { method: "POST", body: JSON.stringify({ deviceId, publicJwk: key.publicJwk }) });
+    if (!enrolled.ok || typeof enrolled.data.deviceKey?.keyId !== "string")
+        throw new Error(`device_key_enroll_failed:${enrolled.status}`);
+    const application = await ownerReceiptRequest(`${CONNECTED_ACCESS}/applications/register`, { method: "POST", body: JSON.stringify(codexAdapterRegistration()) });
+    if (!application.ok || application.data.application?.applicationId !== CODEX_ADAPTER_APPLICATION_ID)
+        throw new Error(`application_register_failed:${application.status}`);
+    return { keyId: enrolled.data.deviceKey.keyId, publicKey: key.publicKey };
+}
+async function ownerReceiptRequest(path, init = {}) {
+    const token = (0, config_1.getAuthToken)();
+    if (!token)
+        throw new Error("authentication_required");
+    const response = await fetch(`${(0, config_1.getConvexSiteUrl)()}${path}`, {
+        ...init,
+        headers: { Accept: "application/json", "Content-Type": "application/json", Authorization: `Bearer ${token}`, ...(init.headers ?? {}) },
+        signal: AbortSignal.timeout(15000),
+    });
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch {
+        data = {};
+    }
+    return { ok: response.ok, status: response.status, data };
+}
+function asNonAuthoritative(value) {
+    return { ...value, authorityGranted: false, secretValuesExposed: false };
+}
+function currentConnectedAccessDeviceId() {
+    const machineKey = (0, machine_identity_1.getPhysicalMachineKey)();
+    if (!/^[A-Za-z0-9._-]{3,128}$/.test(machineKey))
+        throw new Error("invalid_local_machine_identity");
+    return `device:${machineKey}`;
+}
+function localWorkspaceRef(deviceId) {
+    // A deterministic opaque workspace ref avoids uploading a hostname or path.
+    return `workspace:${crypto.createHash("sha256").update(`youmd-connected-access/v1:${deviceId}`).digest("hex")}`;
+}
+function canonicalizeStatusReport(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalizeStatusReport).join(",")}]`;
+    if (!value || typeof value !== "object")
+        throw new Error("invalid_status_report");
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalizeStatusReport(record[key])}`).join(",")}}`;
+}
+function codexStatusProvenanceHash(status) {
+    return `sha256:${crypto.createHash("sha256").update(canonicalizeStatusReport(status)).digest("hex")}`;
+}
+/** Issue M1 evidence from an already-redacted, local Codex status enum only. */
+async function issueCodexStatusReceipt(status, providerStateChanged) {
+    // An API-key-local Codex session is a different authentication mode. Never
+    // relabel it as a ChatGPT-connected receipt or upload it as such.
+    if (status.authenticationKind !== "chatgpt")
+        throw new Error("codex_chatgpt_sign_in_required");
+    const deviceId = currentConnectedAccessDeviceId();
+    const challenge = await ownerReceiptRequest(`${CONNECTED_ACCESS}/challenges`, {
+        method: "POST",
+        body: JSON.stringify({
+            deviceId,
+            applicationId: CODEX_ADAPTER_APPLICATION_ID,
+            target: "openai_codex",
+            origin: "https://chatgpt.com",
+            audience: "youmd:personal",
+            workspaceRef: localWorkspaceRef(deviceId),
+        }),
+    });
+    if (!challenge.ok || typeof challenge.data.challenge !== "string")
+        throw new Error(`codex_challenge_failed:${challenge.status}`);
+    const confirmation = await ownerReceiptRequest(`${CONNECTED_ACCESS}/receipts/confirm`, {
+        method: "POST",
+        body: JSON.stringify({
+            challenge: challenge.data.challenge,
+            provenanceHash: codexStatusProvenanceHash(status),
+            observedAt: new Date().toISOString(),
+            expiresInMs: 60 * 60 * 1000,
+        }),
+    });
+    if (!confirmation.ok || !confirmation.data.receipt)
+        throw new Error(`codex_receipt_failed:${confirmation.status}`);
+    return asNonAuthoritative({
+        ...confirmation.data.receipt,
+        localStatus: status,
+        providerStateChanged: providerStateChanged === true,
+        providerCredentialsRead: false,
+        deviceCodeCaptured: false,
+    });
+}
+function hashFromApi(value) {
+    if (typeof value !== "string")
+        throw new Error("invalid_proof_hash");
+    const normalized = value.replace(/^sha256:/, "");
+    if (!/^[a-f0-9]{64}$/.test(normalized))
+        throw new Error("invalid_proof_hash");
+    return normalized;
+}
+function expiresAtMs(value) {
+    if (typeof value !== "string")
+        throw new Error("invalid_proof_expiry");
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp) || timestamp <= Date.now())
+        throw new Error("proof_expired");
+    return timestamp;
+}
+async function listAgentAccessDeviceKeys(includeInactive = false) {
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/device-keys${includeInactive ? "?includeInactive=1" : ""}`);
+    if (!result.ok || !Array.isArray(result.data.deviceKeys))
+        throw new Error(`device_key_list_failed:${result.status}`);
+    return result.data.deviceKeys.map((row) => asNonAuthoritative(row));
+}
+async function enrollAgentAccessDeviceKey(nativeHostDeps) {
+    const loaded = (0, connected_access_native_1.loadNativeHostConfig)(nativeHostDeps);
+    const key = await (0, connected_access_native_1.ensureNativeDevicePublicKey)(loaded, nativeHostDeps);
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/device-keys/enroll`, {
+        method: "POST",
+        body: JSON.stringify({ deviceId: currentConnectedAccessDeviceId(), publicJwk: key.publicJwk }),
+    });
+    if (!result.ok || !result.data.deviceKey || typeof result.data.deviceKey.keyId !== "string")
+        throw new Error(`device_key_enroll_failed:${result.status}`);
+    return asNonAuthoritative({ ...result.data.deviceKey, deviceId: currentConnectedAccessDeviceId(), bindingClass: loaded.config.bindingClass });
+}
+async function revokeAgentAccessDeviceKey(keyId) {
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/device-keys/revoke`, {
+        method: "POST", body: JSON.stringify({ keyId }),
+    });
+    if (!result.ok || !result.data.deviceKey)
+        throw new Error(`device_key_revoke_failed:${result.status}`);
+    return asNonAuthoritative(result.data.deviceKey);
+}
+async function listAgentAccessApplications(includeInactive = false) {
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/applications${includeInactive ? "?includeInactive=1" : ""}`);
+    if (!result.ok || !Array.isArray(result.data.applications))
+        throw new Error(`application_list_failed:${result.status}`);
+    return result.data.applications.map((row) => asNonAuthoritative(row));
+}
+function officialDevelopmentExtensionRegistration(extensionId) {
+    return {
+        applicationId: CONNECTED_ACCESS_APPLICATION_ID,
+        runtime: "chrome_extension",
+        runtimeBinding: extensionId,
+        allowedOrigins: ["https://chatgpt.com"],
+    };
+}
+async function registerAgentAccessApplication(nativeHostDeps) {
+    const loaded = (0, connected_access_native_1.loadNativeHostConfig)(nativeHostDeps);
+    const browser = (0, connected_access_native_1.requireBrowserNativeHostConfig)(loaded.config);
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/applications/register`, {
+        method: "POST",
+        body: JSON.stringify(officialDevelopmentExtensionRegistration(browser.extensionId)),
+    });
+    if (!result.ok || !result.data.application || typeof result.data.application.applicationId !== "string")
+        throw new Error(`application_register_failed:${result.status}`);
+    return asNonAuthoritative({ ...result.data.application, bindingClass: loaded.config.bindingClass });
+}
+/**
+ * Rotate the exact local extension binding only when the owner invokes this
+ * command. Register/prove are deliberately idempotent and never auto-update:
+ * changing a binding invalidates outstanding signed evidence server-side.
+ */
+async function updateAgentAccessApplication(nativeHostDeps) {
+    const loaded = (0, connected_access_native_1.loadNativeHostConfig)(nativeHostDeps);
+    const browser = (0, connected_access_native_1.requireBrowserNativeHostConfig)(loaded.config);
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/applications/update`, {
+        method: "POST",
+        body: JSON.stringify(officialDevelopmentExtensionRegistration(browser.extensionId)),
+    });
+    if (!result.ok || !result.data.application || typeof result.data.application.applicationId !== "string")
+        throw new Error(`application_update_failed:${result.status}`);
+    return asNonAuthoritative({ ...result.data.application, bindingClass: loaded.config.bindingClass });
+}
+async function revokeAgentAccessApplication(applicationId) {
+    const result = await ownerReceiptRequest(`${CONNECTED_ACCESS}/applications/revoke`, {
+        method: "POST", body: JSON.stringify({ applicationId }),
+    });
+    if (!result.ok || !result.data.application)
+        throw new Error(`application_revoke_failed:${result.status}`);
+    return asNonAuthoritative(result.data.application);
+}
+/**
+ * Complete a bounded signed observation proof. This reads a pre-existing,
+ * short-lived sanitized observation only; it never opens Chrome, installs an
+ * extension, reads provider storage, or copies a provider credential.
+ */
+async function proveChatGPTConnectedAccess(nativeHostDeps) {
+    const loaded = (0, connected_access_native_1.loadNativeHostConfig)(nativeHostDeps);
+    const browser = (0, connected_access_native_1.requireBrowserNativeHostConfig)(loaded.config);
+    const deviceId = currentConnectedAccessDeviceId();
+    const key = await (0, connected_access_native_1.ensureNativeDevicePublicKey)(loaded, nativeHostDeps);
+    const keyEnrollment = await ownerReceiptRequest(`${CONNECTED_ACCESS}/device-keys/enroll`, {
+        method: "POST", body: JSON.stringify({ deviceId, publicJwk: key.publicJwk }),
+    });
+    if (!keyEnrollment.ok || !keyEnrollment.data.deviceKey || typeof keyEnrollment.data.deviceKey.keyId !== "string")
+        throw new Error(`device_key_enroll_failed:${keyEnrollment.status}`);
+    const appRegistration = await ownerReceiptRequest(`${CONNECTED_ACCESS}/applications/register`, {
+        method: "POST",
+        body: JSON.stringify(officialDevelopmentExtensionRegistration(browser.extensionId)),
+    });
+    if (!appRegistration.ok || !appRegistration.data.application)
+        throw new Error(`application_register_failed:${appRegistration.status}`);
+    const observation = await (0, connected_access_native_1.readCachedNativeObservation)(loaded, nativeHostDeps);
+    if (observation.publicKey !== key.publicKey)
+        throw new Error("native_host_observation_key_mismatch");
+    const preparedResponse = await ownerReceiptRequest(`${CONNECTED_ACCESS}/proofs/prepare`, {
+        method: "POST",
+        body: JSON.stringify({
+            keyId: keyEnrollment.data.deviceKey.keyId,
+            deviceId,
+            applicationId: CONNECTED_ACCESS_APPLICATION_ID,
+            target: "chatgpt",
+            origin: "https://chatgpt.com",
+            audience: "youmd:personal",
+            workspaceRef: localWorkspaceRef(deviceId),
+            expiresInMs: 60 * 60 * 1000,
+            cachedObservationEnvelope: observation.envelope,
+            cachedObservationSignature: observation.signature,
+            cachedObservationPublicKey: observation.publicKey,
+        }),
+    });
+    if (!preparedResponse.ok || !preparedResponse.data.proof)
+        throw new Error(`proof_prepare_failed:${preparedResponse.status}`);
+    const prepared = preparedResponse.data.proof;
+    if (typeof prepared.proofDraftId !== "string" || typeof prepared.preparedCanonicalPayload !== "string")
+        throw new Error("invalid_prepared_proof");
+    const preparedPayload = Buffer.from(prepared.preparedCanonicalPayload, "base64url");
+    if (preparedPayload.length === 0 || (0, connected_access_native_1.sha256Hex)(preparedPayload) !== hashFromApi(prepared.payloadHash)
+        || hashFromApi(prepared.observationHash) !== observation.observationHash) {
+        throw new Error("prepared_proof_hash_mismatch");
+    }
+    const signed = await (0, connected_access_native_1.signPreparedNativeProof)({
+        preparedCanonicalPayload: prepared.preparedCanonicalPayload,
+        observationHash: observation.observationHash,
+        expiresAt: expiresAtMs(prepared.expiresAt),
+        expectedPublicKey: key.publicKey,
+    }, loaded, nativeHostDeps);
+    if (signed.payloadHash !== hashFromApi(prepared.payloadHash))
+        throw new Error("native_host_payload_hash_mismatch");
+    const complete = await ownerReceiptRequest(`${CONNECTED_ACCESS}/proofs/complete`, {
+        method: "POST", body: JSON.stringify({ proofDraftId: prepared.proofDraftId, signature: signed.signature }),
+    });
+    if (!complete.ok || !complete.data.receipt)
+        throw new Error(`proof_complete_failed:${complete.status}`);
+    return asNonAuthoritative({
+        ...complete.data.receipt,
+        target: "chatgpt",
+        assurance: "local_auth_ui_observed",
+        bindingClass: loaded.config.bindingClass,
+        providerCredentialsRead: false,
+        extensionInstalled: false,
+        chromeWebStoreClaimed: false,
+    });
+}
+async function listAgentAccessReceipts(includeInactive = false) {
+    const result = await ownerReceiptRequest(`/api/v1/me/agent-access/receipts${includeInactive ? "?includeInactive=1" : ""}`);
+    if (!result.ok || !Array.isArray(result.data.receipts))
+        throw new Error(`receipt_list_failed:${result.status}`);
+    return result.data.receipts;
+}
+async function verifyAgentAccessReceipt(receiptId) {
+    const rows = await listAgentAccessReceipts(true);
+    const receipt = rows.find((row) => row.receiptId === receiptId);
+    if (!receipt)
+        return { ok: false, reason: "receipt_not_found", authorityGranted: false };
+    const result = await ownerReceiptRequest("/api/v1/me/agent-access/receipts/verify", {
+        method: "POST",
+        body: JSON.stringify({ receiptId, deviceId: receipt.deviceId, applicationId: receipt.applicationId, audience: receipt.audience }),
+    });
+    if (!result.ok)
+        throw new Error(`receipt_verify_failed:${result.status}`);
+    return { ...result.data, authorityGranted: false };
+}
+async function revokeAgentAccessReceipt(receiptId) {
+    const result = await ownerReceiptRequest("/api/v1/me/agent-access/receipts/revoke", {
+        method: "POST", body: JSON.stringify({ receiptId }),
+    });
+    if (!result.ok)
+        throw new Error(`receipt_revoke_failed:${result.status}`);
+    return { ...result.data, providerLogoutPerformed: false };
+}
+/** Only IP-literal loopback is eligible. `localhost` is intentionally excluded. */
+function normalizeLocalHandoffBase(value) {
+    if (!value?.trim())
+        return null;
+    try {
+        const url = new URL(value.trim());
+        if (url.protocol !== "http:" || (url.hostname !== "127.0.0.1" && url.hostname !== "[::1]" && url.hostname !== "::1"))
+            return null;
+        if (!url.port || !/^[1-9]\d{0,4}$/.test(url.port))
+            return null;
+        const port = Number(url.port);
+        if (port > 65535 || url.username || url.password || url.search || url.hash)
+            return null;
+        if (url.pathname !== "/" && url.pathname !== "")
+            return null;
+        return url.origin;
+    }
+    catch {
+        return null;
+    }
+}
+/** Never open a URL supplied by the local listener unless it is You.md's handoff UI. */
+function normalizeHandoffAuthorizationUrl(value) {
+    if (typeof value !== "string")
+        return null;
+    try {
+        const url = new URL(value);
+        const host = url.hostname.toLowerCase();
+        if (url.protocol !== "https:" || host !== "www.you.md")
+            return null;
+        if (url.username || url.password || url.pathname !== HANDOFF_AUTHORIZE_PATH || url.hash)
+            return null;
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function openExternalUrl(url) {
+    const [command, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    (0, child_process_1.execFile)(command, args, { windowsHide: true }, () => {
+        // The URL is printed as a reliable manual fallback.
+    });
+}
+function resultForError(status, localOrigin) {
+    return { ok: false, status, localOrigin, secretValuesExposed: false };
+}
+/**
+ * Start a confirmed local browser handoff. This intentionally carries neither
+ * the You.md CLI token nor an API origin: the fixed loopback listener derives
+ * the exact current port, callback audience, and registered local identity.
+ */
+async function startLocalBrowserHandoff(options, deps = {}) {
+    const localOrigin = normalizeLocalHandoffBase(options.localBase);
+    if (!localOrigin)
+        return resultForError("unavailable");
+    const request = deps.fetch ?? fetch;
+    let response;
+    try {
+        response = await request(`${localOrigin}${HANDOFF_START_PATH}`, {
+            method: "POST",
+            headers: { Accept: "application/json", "Cache-Control": "no-store" },
+            redirect: "error",
+        });
+    }
+    catch {
+        return resultForError("unavailable", localOrigin);
+    }
+    if (response.status === 404 || response.status === 405 || response.status === 501) {
+        return resultForError("unsupported", localOrigin);
+    }
+    if (!response.ok)
+        return resultForError("rejected", localOrigin);
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return resultForError("rejected", localOrigin);
+    }
+    const authorizationUrl = normalizeHandoffAuthorizationUrl(payload.authorizationUrl);
+    const expiresAt = typeof payload.expiresAt === "number" && Number.isFinite(payload.expiresAt) && payload.expiresAt > Date.now()
+        ? payload.expiresAt
+        : null;
+    if (payload.ok !== true || !authorizationUrl || !expiresAt)
+        return resultForError("rejected", localOrigin);
+    return {
+        ok: true,
+        status: "started",
+        localOrigin,
+        authorizationUrl,
+        expiresAt,
+        secretValuesExposed: false,
+    };
+}
+async function connectCommand(action, value, argument, options = {}) {
+    const nestedAction = value?.toLowerCase();
+    const nestedArgument = argument;
+    const connectedDeps = options.connectedContextDeps ?? {
+        fetch,
+        native: (0, connected_context_1.createNativeConnectedContext)(options.nativeHostDeps),
+        authToken: config_1.getAuthToken,
+        apiUrl: config_1.getConvexSiteUrl,
+    };
+    const output = (result, label) => {
+        const safe = asNonAuthoritative(result);
+        if (options.json)
+            console.log(JSON.stringify(safe, null, 2));
+        else {
+            console.log(`  ${JSON.stringify(safe, null, 2).split("\n").join("\n  ")}`);
+            const providerStateCopy = safe.providerStateChanged === true
+                ? "Provider sign-in state may have changed through the provider's own interactive UI; no provider credential was read or copied."
+                : "No provider authority, credentials, or login state were changed.";
+            console.log(chalk_1.default.dim(`  ${label} ${providerStateCopy}`));
+        }
+    };
+    if (action === "bootstrap") {
+        const operation = nestedAction ?? "start";
+        const spinner = options.json ? null : new render_1.BrailleSpinner(operation === "start" ? "verifying and syncing your signed private context..." : `${operation}ing the local signed context snapshot...`);
+        spinner?.start();
+        try {
+            let result;
+            if (operation === "start") {
+                if (nestedArgument)
+                    throw new Error("bootstrap_usage");
+                result = await (0, connected_context_1.bootstrapConnectedContext)(connectedDeps, { trustCurrentGeneration: options.trustCurrentGeneration });
+            }
+            else if (operation === "status") {
+                if (nestedArgument)
+                    throw new Error("bootstrap_usage");
+                result = (0, connected_context_1.getConnectedContextStatus)(connectedDeps);
+            }
+            else if (operation === "verify") {
+                if (nestedArgument)
+                    throw new Error("bootstrap_usage");
+                result = await (0, connected_context_1.verifyConnectedContext)(connectedDeps);
+            }
+            else if (operation === "revoke") {
+                result = await (0, connected_context_1.revokeConnectedContext)(connectedDeps, { manifestId: nestedArgument, revokeApplication: options.revokeApplication, revokeKey: options.revokeKey });
+            }
+            else
+                throw new Error("bootstrap_usage");
+            spinner?.stop(operation === "start" ? "signed private context is ready for local agents" : `connected context ${result.state}`);
+            const receipt = publicConnectedContextStatus(result);
+            if (options.json)
+                console.log(JSON.stringify(receipt, null, 2));
+            else {
+                console.log(`  ${JSON.stringify(receipt, null, 2).split("\n").join("\n  ")}`);
+                console.log(chalk_1.default.dim("  The owner key and short-lived DPoP token were not stored or exposed to agents."));
+            }
+            return;
+        }
+        catch (error) {
+            spinner?.stop("connected context stopped safely");
+            const code = error instanceof Error ? error.message : "connected_context_failed";
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: code, authorityGranted: false, secretValuesExposed: false }, null, 2));
+            else
+                console.error(ACCENT(`  ${code.replaceAll("_", " ")}; no credential or partial snapshot was exposed`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (action === "codex") {
+        const spinner = options.json ? null : new render_1.BrailleSpinner("checking the local Codex sign-in state without reading credentials...");
+        spinner?.start();
+        try {
+            if (nestedAction === "status") {
+                const status = await (0, codex_device_auth_1.getCodexAuthenticationStatus)(options.codexDeps);
+                spinner?.stop(status.authenticated ? "local Codex authentication observed" : "local Codex authentication is not confirmed");
+                output({
+                    localStatus: status,
+                    providerStateChanged: false,
+                    providerCredentialsRead: false,
+                    deviceCodeCaptured: false,
+                }, "Only a strict local status enum was read.");
+            }
+            else if (nestedAction === "login") {
+                // Device auth prints the provider URL/code directly to the terminal.
+                // A JSON response cannot coexist safely with that inherited stream.
+                const before = await (0, codex_device_auth_1.getCodexAuthenticationStatus)(options.codexDeps);
+                if (options.json && before.authenticationKind !== "chatgpt")
+                    throw new Error("interactive_login_requires_tty");
+                const outcome = await (0, codex_device_auth_1.ensureCodexAuthentication)(options.codexDeps);
+                const receipt = await issueCodexStatusReceipt(outcome.status, outcome.providerStateChanged);
+                spinner?.stop(outcome.loginChildRan ? "Codex sign-in confirmed; non-authoritative receipt issued" : "existing Codex sign-in confirmed; non-authoritative receipt issued");
+                output(receipt, "The receipt is first-party client-reported evidence only; it cannot run a Codex job.");
+            }
+            else if (nestedAction === "audit") {
+                if (nestedArgument)
+                    throw new Error("codex_audit_usage");
+                const files = declaredInputFiles(options.files);
+                const bound = await (options.codexAuditBinding ?? (() => ensureCodexAdapterKeyAndApplication(options.nativeHostDeps)))();
+                const deviceId = currentConnectedAccessDeviceId();
+                const jobDeps = options.codexJobDeps ?? { fetch, openApproval: openExternalUrl, sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)), token: config_1.getAuthToken };
+                const job = await (0, codex_job_control_plane_1.prepareAndAwaitOwnerApproval)({ keyId: bound.keyId, workspaceRef: localWorkspaceRef(deviceId), deviceId, files, deadlineSeconds: 300 }, jobDeps, { waitForApproval: options.json !== true });
+                if (options.json) {
+                    spinner?.stop("audit is waiting for owner approval");
+                    output({ jobId: job.jobId, hostedApprovalUrl: job.hostedApprovalUrl, approvalState: "pending", contextDigest: codex_readonly_job_1.CODEX_READONLY_JOB_CONTEXT_DIGEST, declaredInputCount: files.length, authorityGranted: false, providerCredentialsRead: false, providerStateChanged: false, providerExecutionStarted: false }, "Approval is pending. Open hostedApprovalUrl in a signed-in browser, then rerun without --json.");
+                    return;
+                }
+                const lifecycle = options.codexAuditLifecycle ?? { run: async (claim, grant) => {
+                        const localGrant = { ...claim, ...grant, approvalState: grant.approvalState, approvalRef: grant.approvalRef, approvalExpiresAt: grant.approvalExpiresAt, keyId: grant.keyId, keyGeneration: grant.keyGeneration, applicationGeneration: grant.applicationGeneration };
+                        const executed = await (0, codex_readonly_job_1.executeApprovedReadonlyLocalCodexJob)(localGrant, process.cwd(), () => { });
+                        return { outcome: executed.status === "completed" ? "succeeded" : "failed", resultDigest: executed.resultHash, contextLoaded: executed.contextLoaded, modelStarted: executed.modelStarted };
+                    } };
+                const outcome = await (0, codex_job_control_plane_1.claimAndRunApprovedLocalCodexJob)(job, { ...jobDeps, ...lifecycle, publicKey: bound.publicKey });
+                spinner?.stop(`approved local audit ${outcome.outcome}`);
+                const lifecycleCopy = outcome.contextLoaded
+                    ? outcome.modelStarted
+                        ? "The declared snapshot was the working input. Codex read-only sandbox blocks writes and configured agent tools/network; this is not OS-level read isolation, and OpenAI handled provider inference transport."
+                        : "The declared snapshot was prepared, but Codex never started; no provider inference was attempted."
+                    : "The declared snapshot was not prepared and Codex never started; no provider inference was attempted.";
+                output({ jobId: job.jobId, outcome: outcome.outcome, declaredInputCount: files.length, authorityGranted: false, providerCredentialsRead: false, providerStateChanged: false, providerExecutionStarted: outcome.modelStarted }, lifecycleCopy);
+            }
+            else {
+                spinner?.stop("Codex command needs an action");
+                throw new Error("codex_usage");
+            }
+            return;
+        }
+        catch (error) {
+            spinner?.stop("Codex connection stopped safely");
+            const code = error instanceof Error ? error.message : "codex_connection_failed";
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: code, authorityGranted: false, providerCredentialsRead: false, deviceCodeCaptured: false }, null, 2));
+            else
+                console.error(ACCENT(`  ${code.replaceAll("_", " ")}; no provider credential was read or copied`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (action === "key") {
+        const spinner = options.json ? null : new render_1.BrailleSpinner("checking the local signed-helper key...");
+        spinner?.start();
+        try {
+            if (nestedAction === "list") {
+                const keys = await listAgentAccessDeviceKeys(options.includeInactive === true);
+                spinner?.stop(`${keys.length} device key${keys.length === 1 ? "" : "s"} found`);
+                output({ deviceKeys: keys }, "Device keys are public-key records only.");
+            }
+            else if (nestedAction === "enroll") {
+                const result = await enrollAgentAccessDeviceKey(options.nativeHostDeps);
+                spinner?.stop("dedicated public signing key enrolled");
+                output(result, "The private Ed25519 key remains in the local Keychain-backed helper.");
+            }
+            else if (nestedAction === "revoke" && nestedArgument) {
+                const result = await revokeAgentAccessDeviceKey(nestedArgument);
+                spinner?.stop("device key revoked");
+                output(result, "Existing signed evidence may now be invalidated.");
+            }
+            else {
+                spinner?.stop("key command needs an action");
+                throw new Error("key_usage");
+            }
+            return;
+        }
+        catch (error) {
+            spinner?.stop("key operation stopped safely");
+            const code = error instanceof Error ? error.message : "device_key_failed";
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: code, authorityGranted: false, secretValuesExposed: false }, null, 2));
+            else
+                console.error(ACCENT(`  ${code.replaceAll("_", " ")}; no provider state changed`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (action === "app") {
+        const spinner = options.json ? null : new render_1.BrailleSpinner("checking the exact local extension binding...");
+        spinner?.start();
+        try {
+            if (nestedAction === "list") {
+                const applications = await listAgentAccessApplications(options.includeInactive === true);
+                spinner?.stop(`${applications.length} application${applications.length === 1 ? "" : "s"} found`);
+                output({ applications }, "Application records bind local runtime metadata only.");
+            }
+            else if (nestedAction === "register") {
+                const result = await registerAgentAccessApplication(options.nativeHostDeps);
+                spinner?.stop("development extension binding registered");
+                output(result, "This is owner-registered development provenance, not a Chrome Web Store claim.");
+            }
+            else if (nestedAction === "update") {
+                const result = await updateAgentAccessApplication(options.nativeHostDeps);
+                spinner?.stop("development extension binding rotated explicitly");
+                output(result, "Binding rotation was explicit; register and prove never rotate it automatically.");
+            }
+            else if (nestedAction === "revoke" && nestedArgument) {
+                const result = await revokeAgentAccessApplication(nestedArgument);
+                spinner?.stop("application binding revoked");
+                output(result, "No Chrome extension or provider login was removed.");
+            }
+            else {
+                spinner?.stop("app command needs an action");
+                throw new Error("app_usage");
+            }
+            return;
+        }
+        catch (error) {
+            spinner?.stop("application operation stopped safely");
+            const code = error instanceof Error ? error.message : "application_failed";
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: code, authorityGranted: false, secretValuesExposed: false }, null, 2));
+            else
+                console.error(ACCENT(`  ${code.replaceAll("_", " ")}; no provider state changed`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (action === "prove") {
+        const spinner = options.json ? null : new render_1.BrailleSpinner("verifying a short-lived local ChatGPT UI observation...");
+        spinner?.start();
+        try {
+            if (value?.toLowerCase() !== "chatgpt" || argument)
+                throw new Error("prove_usage");
+            const result = await proveChatGPTConnectedAccess(options.nativeHostDeps);
+            spinner?.stop("signed local observation receipt issued");
+            output(result, "This is local UI evidence only; it cannot run a provider job or access an account.");
+            return;
+        }
+        catch (error) {
+            spinner?.stop("proof stopped safely");
+            const code = error instanceof Error ? error.message : "proof_failed";
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: code, authorityGranted: false, secretValuesExposed: false }, null, 2));
+            else
+                console.error(ACCENT(`  ${code.replaceAll("_", " ")}; no provider state changed`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (action === "status") {
+        const spinner = options.json ? null : new render_1.BrailleSpinner("checking non-secret connection receipts...");
+        spinner?.start();
+        try {
+            const receipts = await listAgentAccessReceipts(options.includeInactive === true);
+            spinner?.stop(`${receipts.length} receipt${receipts.length === 1 ? "" : "s"} found`);
+            if (options.json) {
+                console.log(JSON.stringify({ receipts, authorityGranted: false }, null, 2));
+                return;
+            }
+            if (receipts.length === 0) {
+                console.log(chalk_1.default.dim("  no active connection receipts"));
+                return;
+            }
+            for (const receipt of receipts) {
+                console.log(`  ${ACCENT(receipt.status.padEnd(7))} ${chalk_1.default.white(receipt.target.padEnd(18))} ${chalk_1.default.dim(receipt.assurance)}`);
+                console.log(chalk_1.default.dim(`           ${receipt.receiptId} · expires ${receipt.expiresAt}`));
+            }
+            console.log(chalk_1.default.dim("  receipts are evidence only; they cannot run an agent job"));
+            return;
+        }
+        catch (error) {
+            spinner?.stop("receipt status unavailable");
+            const message = error instanceof Error && error.message === "authentication_required" ? "run `you login` before reading private receipts" : "could not read connection receipts";
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: message, authorityGranted: false }, null, 2));
+            else
+                console.error(ACCENT(`  ${message}`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if ((action === "verify" || action === "revoke") && value) {
+        const spinner = options.json ? null : new render_1.BrailleSpinner(action === "verify" ? "verifying exact receipt bindings..." : "revoking receipt evidence only...");
+        spinner?.start();
+        try {
+            const result = action === "verify" ? await verifyAgentAccessReceipt(value) : await revokeAgentAccessReceipt(value);
+            spinner?.stop(action === "verify" ? "receipt verification complete" : "receipt revoked; provider login unchanged");
+            if (options.json)
+                console.log(JSON.stringify(result, null, 2));
+            else {
+                console.log(`  ${JSON.stringify(result, null, 2).split("\n").join("\n  ")}`);
+                console.log(chalk_1.default.dim(action === "verify" ? "  no execution authority was granted" : "  provider login state was not changed"));
+            }
+            return;
+        }
+        catch {
+            spinner?.stop(`receipt ${action} failed`);
+            if (options.json)
+                console.log(JSON.stringify({ ok: false, error: `receipt_${action}_failed`, authorityGranted: false }, null, 2));
+            else
+                console.error(ACCENT(`  receipt ${action} failed; no provider state was changed`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (action !== "browser") {
+        console.log("usage: you connect browser --local-base http://127.0.0.1:<port>");
+        console.log("       you connect status [--all] [--json]");
+        console.log("       you connect verify <receipt-id> [--json]");
+        console.log("       you connect revoke <receipt-id> [--json]");
+        console.log("       you connect key enroll|list [--all] [--json]");
+        console.log("       you connect key revoke <key-id> [--json]");
+        console.log("       you connect app register|update|list [--all] [--json]");
+        console.log("       you connect app revoke <application-id> [--json]");
+        console.log("       you connect prove chatgpt [--json]");
+        console.log("       you connect codex status|login [--json]");
+        console.log("       you connect codex audit --file <relative-path> [--file <relative-path> ...] [--json]");
+        console.log("       you connect bootstrap [status|verify|revoke [manifest-id]] [--trust-current-generation] [--revoke-app] [--revoke-key] [--json]");
+        console.log("  connection receipts are non-secret evidence; they never authorize an agent job");
+        return;
+    }
+    const localOrigin = normalizeLocalHandoffBase(options.localBase);
+    if (!localOrigin) {
+        const message = "a literal loopback local broker is required (for example http://127.0.0.1:49152)";
+        if (options.json)
+            console.log(JSON.stringify({ ...resultForError("unavailable"), error: message }, null, 2));
+        else {
+            console.error(ACCENT(`  ${message}`));
+            console.error(chalk_1.default.dim("  Start the registered local You.md desktop/web listener, then rerun with its current port."));
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = options.json ? null : new render_1.BrailleSpinner("requesting a one-time local browser handoff...");
+    spinner?.start();
+    const result = await startLocalBrowserHandoff({ ...options, localBase: localOrigin });
+    spinner?.stop(result.ok ? "local handoff ready for your approval" : "local handoff was not started");
+    if (!result.ok) {
+        const message = result.status === "unsupported"
+            ? "this local You.md listener does not support confirmed browser handoff yet"
+            : result.status === "rejected"
+                ? "the local listener rejected this handoff; no browser session was created"
+                : "the local listener is unavailable; no browser session was created";
+        if (options.json)
+            console.log(JSON.stringify({ ...result, error: message }, null, 2));
+        else {
+            console.error(ACCENT(`  ${message}`));
+            console.error(chalk_1.default.dim("  No CLI token, provider credential, or browser session was sent or created."));
+        }
+        process.exitCode = 1;
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`  approval URL: ${chalk_1.default.cyan(result.authorizationUrl)}`);
+        console.log(chalk_1.default.dim("  Review the exact request in your signed-in You.md browser before authorizing it."));
+    }
+    if (!options.json)
+        openExternalUrl(result.authorizationUrl);
+}
+//# sourceMappingURL=connect.js.map